openoffice-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From msei...@apache.org
Subject svn commit: r1843806 [2/3] - in /openoffice/trunk/main: bean/com/sun/star/beans/ bean/com/sun/star/comp/beans/ cli_ure/source/climaker/ embeddedobj/test/Container1/ odk/examples/DevelopersGuide/OfficeDev/DesktopEnvironment/
Date Sun, 14 Oct 2018 00:39:50 GMT
Modified: openoffice/trunk/main/cli_ure/source/climaker/climaker_emit.cxx
URL: http://svn.apache.org/viewvc/openoffice/trunk/main/cli_ure/source/climaker/climaker_emit.cxx?rev=1843806&r1=1843805&r2=1843806&view=diff
==============================================================================
--- openoffice/trunk/main/cli_ure/source/climaker/climaker_emit.cxx (original)
+++ openoffice/trunk/main/cli_ure/source/climaker/climaker_emit.cxx Sun Oct 14 00:39:50 2018
@@ -47,199 +47,199 @@ namespace climaker
 System::String* mapUnoPolymorphicName(System::String* unoName);
 //------------------------------------------------------------------------------
 static inline ::System::String * to_cts_name(
-    OUString const & uno_name )
+	OUString const & uno_name )
 {
-    OUStringBuffer buf( 7 + uno_name.getLength() );
-    buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("unoidl.") );
-    buf.append( uno_name );
-    return ustring_to_String( buf.makeStringAndClear() );
+	OUStringBuffer buf( 7 + uno_name.getLength() );
+	buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("unoidl.") );
+	buf.append( uno_name );
+	return ustring_to_String( buf.makeStringAndClear() );
 }
 
 //------------------------------------------------------------------------------
 static inline ::System::Object * to_cli_constant( Any const & value )
 {
-    switch (value.getValueTypeClass())
-    {
-    case TypeClass_CHAR:
-        return __box
-            ((::System::Char) *reinterpret_cast< sal_Unicode const * >(
-                value.getValue() ));
-    case TypeClass_BOOLEAN:
-        return __box
-            ((::System::Boolean)
-             sal_False != *reinterpret_cast< sal_Bool const * >(
-                 value.getValue() ));
-    case TypeClass_BYTE:
-        return __box
-            ((::System::Byte) *reinterpret_cast< sal_Int8 const * >(
-                value.getValue() ));
-    case TypeClass_SHORT:
-        return __box
-            ((::System::Int16) *reinterpret_cast< sal_Int16 const * >(
-                value.getValue() ));
-    case TypeClass_UNSIGNED_SHORT:
-        return __box
-            ((::System::UInt16) *reinterpret_cast< sal_uInt16 const * >(
-                value.getValue() ));
-    case TypeClass_LONG:
-        return __box
-            ((::System::Int32) *reinterpret_cast< sal_Int32 const * >(
-                value.getValue() ));
-    case TypeClass_UNSIGNED_LONG:
-        return __box
-            ((::System::UInt32) *reinterpret_cast< sal_uInt32 const * >(
-                value.getValue() ));
-    case TypeClass_HYPER:
-        return __box
-            ((::System::Int64) *reinterpret_cast< sal_Int64 const * >(
-                value.getValue() ));
-    case TypeClass_UNSIGNED_HYPER:
-        return __box
-            ((::System::UInt64) *reinterpret_cast< sal_uInt64 const * >(
-                value.getValue() ));
-    case TypeClass_FLOAT:
-        return __box
-            ((::System::Single) *reinterpret_cast< float const * >(
-                value.getValue() ));
-    case TypeClass_DOUBLE:
-        return __box
-            ((::System::Double) *reinterpret_cast< double const * >(
-                value.getValue() ));
-    default:
-        throw RuntimeException(
-            OUSTR("unexpected constant type ") +
-            value.getValueType().getTypeName(),
-            Reference< XInterface >() );
-    }
+	switch (value.getValueTypeClass())
+	{
+	case TypeClass_CHAR:
+		return __box
+			((::System::Char) *reinterpret_cast< sal_Unicode const * >(
+				value.getValue() ));
+	case TypeClass_BOOLEAN:
+		return __box
+			((::System::Boolean)
+			 sal_False != *reinterpret_cast< sal_Bool const * >(
+				 value.getValue() ));
+	case TypeClass_BYTE:
+		return __box
+			((::System::Byte) *reinterpret_cast< sal_Int8 const * >(
+				value.getValue() ));
+	case TypeClass_SHORT:
+		return __box
+			((::System::Int16) *reinterpret_cast< sal_Int16 const * >(
+				value.getValue() ));
+	case TypeClass_UNSIGNED_SHORT:
+		return __box
+			((::System::UInt16) *reinterpret_cast< sal_uInt16 const * >(
+				value.getValue() ));
+	case TypeClass_LONG:
+		return __box
+			((::System::Int32) *reinterpret_cast< sal_Int32 const * >(
+				value.getValue() ));
+	case TypeClass_UNSIGNED_LONG:
+		return __box
+			((::System::UInt32) *reinterpret_cast< sal_uInt32 const * >(
+				value.getValue() ));
+	case TypeClass_HYPER:
+		return __box
+			((::System::Int64) *reinterpret_cast< sal_Int64 const * >(
+				value.getValue() ));
+	case TypeClass_UNSIGNED_HYPER:
+		return __box
+			((::System::UInt64) *reinterpret_cast< sal_uInt64 const * >(
+				value.getValue() ));
+	case TypeClass_FLOAT:
+		return __box
+			((::System::Single) *reinterpret_cast< float const * >(
+				value.getValue() ));
+	case TypeClass_DOUBLE:
+		return __box
+			((::System::Double) *reinterpret_cast< double const * >(
+				value.getValue() ));
+	default:
+		throw RuntimeException(
+			OUSTR("unexpected constant type ") +
+			value.getValueType().getTypeName(),
+			Reference< XInterface >() );
+	}
 }
 
 //------------------------------------------------------------------------------
 static inline void emit_ldarg( Emit::ILGenerator * code, ::System::Int32 index )
 {
-    switch (index)
-    {
-    case 0:
-        code->Emit( Emit::OpCodes::Ldarg_0 );
-        break;
-    case 1:
-        code->Emit( Emit::OpCodes::Ldarg_1 );
-        break;
-    case 2:
-        code->Emit( Emit::OpCodes::Ldarg_2 );
-        break;
-    case 3:
-        code->Emit( Emit::OpCodes::Ldarg_3 );
-        break;
-    default:
-        if (index < 0x100)
-            code->Emit( Emit::OpCodes::Ldarg_S, (::System::Byte) index );
-        else if (index < 0x8000)
-            code->Emit( Emit::OpCodes::Ldarg_S, (::System::Int16) index );
-        else
-            code->Emit( Emit::OpCodes::Ldarg, index );
-        break;
-    }
+	switch (index)
+	{
+	case 0:
+		code->Emit( Emit::OpCodes::Ldarg_0 );
+		break;
+	case 1:
+		code->Emit( Emit::OpCodes::Ldarg_1 );
+		break;
+	case 2:
+		code->Emit( Emit::OpCodes::Ldarg_2 );
+		break;
+	case 3:
+		code->Emit( Emit::OpCodes::Ldarg_3 );
+		break;
+	default:
+		if (index < 0x100)
+			code->Emit( Emit::OpCodes::Ldarg_S, (::System::Byte) index );
+		else if (index < 0x8000)
+			code->Emit( Emit::OpCodes::Ldarg_S, (::System::Int16) index );
+		else
+			code->Emit( Emit::OpCodes::Ldarg, index );
+		break;
+	}
 }
 
 void polymorphicStructNameToStructName(::System::String ** sPolyName)
 {
-    if ((*sPolyName)->EndsWith(S">") == false)
-        return;
+	if ((*sPolyName)->EndsWith(S">") == false)
+		return;
 
-    int index = (*sPolyName)->IndexOf('<');
-    OSL_ASSERT(index != -1);
-    *sPolyName = (*sPolyName)->Substring(0, index);
+	int index = (*sPolyName)->IndexOf('<');
+	OSL_ASSERT(index != -1);
+	*sPolyName = (*sPolyName)->Substring(0, index);
 }
 
 
 System::String* mapUnoTypeName(System::String * typeName)
 {
 	::System::Text::StringBuilder* buf= new System::Text::StringBuilder();
-	::System::String * sUnoName = ::System::String::Copy(typeName); 
-    //determine if the type is a sequence and its dimensions
-    int dims= 0;
-    if (typeName->StartsWith(S"["))//if (usUnoName[0] == '[')
-    {
-        int index= 1;
-        while (true)
-        {
-            if (typeName->get_Chars(index++) == ']')//if (usUnoName[index++] == ']')
-                dims++;
-            if (typeName->get_Chars(index++) != '[')//usUnoName[index++] != '[')
-                break;
-        }
-        sUnoName = sUnoName->Substring(index - 1);//usUnoName = usUnoName.copy(index - 1);
-    }
+	::System::String * sUnoName = ::System::String::Copy(typeName);
+	//determine if the type is a sequence and its dimensions
+	int dims= 0;
+	if (typeName->StartsWith(S"["))//if (usUnoName[0] == '[')
+	{
+		int index= 1;
+		while (true)
+		{
+			if (typeName->get_Chars(index++) == ']')//if (usUnoName[index++] == ']')
+				dims++;
+			if (typeName->get_Chars(index++) != '[')//usUnoName[index++] != '[')
+				break;
+		}
+		sUnoName = sUnoName->Substring(index - 1);//usUnoName = usUnoName.copy(index - 1);
+	}
 	if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoBool)))
-        buf->Append(const_cast<System::String*>(Constants::sBoolean));
-    else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoChar)))
-        buf->Append(const_cast<System::String*>(Constants::sChar));
-    else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoByte)))
-        buf->Append(const_cast<System::String*>(Constants::sByte));
-    else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoShort)))
-        buf->Append(const_cast<System::String*>(Constants::sInt16));
-    else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoUShort)))
-        buf->Append(const_cast<System::String*>(Constants::sUInt16));
-    else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoLong)))
-        buf->Append(const_cast<System::String*>(Constants::sInt32));
-    else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoULong)))
-        buf->Append(const_cast<System::String*>(Constants::sUInt32));
-    else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoHyper)))
-        buf->Append(const_cast<System::String*>(Constants::sInt64));
-    else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoUHyper)))
-        buf->Append(const_cast<System::String*>(Constants::sUInt64));
-    else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoFloat)))
-        buf->Append(const_cast<System::String*>(Constants::sSingle));
-    else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoDouble)))
-        buf->Append(const_cast<System::String*>(Constants::sDouble));
-    else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoString)))
-        buf->Append(const_cast<System::String*>(Constants::sString));    
-    else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoVoid)))
-        buf->Append(const_cast<System::String*>(Constants::sVoid));
-    else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoType)))
-        buf->Append(const_cast<System::String*>(Constants::sType));
-    else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoXInterface)))
-        buf->Append(const_cast<System::String*>(Constants::sObject));
-    else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoAny)))
-    {        
-        buf->Append(const_cast<System::String*>(Constants::sAny));
-    }
-    else
-    {
-        //put "unoidl." at the beginning
-        buf->Append(const_cast<System::String*>(Constants::sUnoidl));
-        buf->Append(mapUnoPolymorphicName(sUnoName));
-    }
-    // apend []
-    for (;dims--;)
-        buf->Append(const_cast<System::String*>(Constants::sBrackets));
-
-    return buf->ToString();
+		buf->Append(const_cast<System::String*>(Constants::sBoolean));
+	else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoChar)))
+		buf->Append(const_cast<System::String*>(Constants::sChar));
+	else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoByte)))
+		buf->Append(const_cast<System::String*>(Constants::sByte));
+	else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoShort)))
+		buf->Append(const_cast<System::String*>(Constants::sInt16));
+	else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoUShort)))
+		buf->Append(const_cast<System::String*>(Constants::sUInt16));
+	else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoLong)))
+		buf->Append(const_cast<System::String*>(Constants::sInt32));
+	else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoULong)))
+		buf->Append(const_cast<System::String*>(Constants::sUInt32));
+	else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoHyper)))
+		buf->Append(const_cast<System::String*>(Constants::sInt64));
+	else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoUHyper)))
+		buf->Append(const_cast<System::String*>(Constants::sUInt64));
+	else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoFloat)))
+		buf->Append(const_cast<System::String*>(Constants::sSingle));
+	else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoDouble)))
+		buf->Append(const_cast<System::String*>(Constants::sDouble));
+	else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoString)))
+		buf->Append(const_cast<System::String*>(Constants::sString));
+	else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoVoid)))
+		buf->Append(const_cast<System::String*>(Constants::sVoid));
+	else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoType)))
+		buf->Append(const_cast<System::String*>(Constants::sType));
+	else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoXInterface)))
+		buf->Append(const_cast<System::String*>(Constants::sObject));
+	else if (sUnoName->Equals(const_cast<System::String*>(Constants::sUnoAny)))
+	{
+		buf->Append(const_cast<System::String*>(Constants::sAny));
+	}
+	else
+	{
+		//put "unoidl." at the beginning
+		buf->Append(const_cast<System::String*>(Constants::sUnoidl));
+		buf->Append(mapUnoPolymorphicName(sUnoName));
+	}
+	// append []
+	for (;dims--;)
+		buf->Append(const_cast<System::String*>(Constants::sBrackets));
+
+	return buf->ToString();
 }
 
 
-/** For example, there is a uno type
-    com.sun.star.Foo<char, long>.
-    The values in the type list
-    are uno types and are replaced by cli types, such as System.Char,
-    System.Int32, etc.
+/** For example, there is an uno type
+	com.sun.star.Foo<char, long>.
+	The values in the type list
+	are uno types and are replaced by cli types, such as System.Char,
+	System.Int32, etc.
 
 	Strings can be as complicated as this
 	test.MyStruct<char,test.MyStruct<long, []string>>
  */
 System::String* mapUnoPolymorphicName(System::String* unoName)
 {
-    int index = unoName->IndexOf('<');
-    if (index == -1)
-        return unoName;
-    
-    System::Text::StringBuilder * builder =
-        new System::Text::StringBuilder(unoName->Substring(0, index +1 ));
+	int index = unoName->IndexOf('<');
+	if (index == -1)
+		return unoName;
+
+	System::Text::StringBuilder * builder =
+		new System::Text::StringBuilder(unoName->Substring(0, index +1 ));
 
 	//Find the first occurrence of ','
-	//If the parameter is a polymorphic struct then we neede to ignore everything
+	//If the parameter is a polymorphic struct then we need to ignore everything
 	//between the brackets because it can also contain commas
-    //get the type list within < and >
+	//get the type list within < and >
 	int endIndex = unoName->Length - 1;
 	index++;
 	int cur = index;
@@ -284,82 +284,82 @@ System::String* mapUnoPolymorphicName(Sy
 		cur++;
 	}
 
-    builder->Append((System::Char) '>');
-    return builder->ToString();
+	builder->Append((System::Char) '>');
+	return builder->ToString();
 }
 
 
 
 //______________________________________________________________________________
 Assembly * TypeEmitter::type_resolve(
-    ::System::Object *, ::System::ResolveEventArgs * args )
+	::System::Object *, ::System::ResolveEventArgs * args )
 {
-    ::System::String * cts_name = args->get_Name();
-    ::System::Type * ret_type = m_module_builder->GetType(
-        cts_name, false /* no exc */ );
-    if (0 == ret_type)
-    {
-        iface_entry * entry = dynamic_cast< iface_entry * >(
-            m_incomplete_ifaces->get_Item( cts_name ) );
-        if (0 != entry)
-            ret_type = entry->m_type_builder;
-    }
-    if (0 == ret_type)
-    {
-        sal_Int32 len = m_extra_assemblies->get_Length();
-        for ( sal_Int32 pos = 0; pos < len; ++pos )
-        {
-            ret_type = m_extra_assemblies[ pos ]->GetType(
-                cts_name, false /* no exc */ );
-            if (0 != ret_type)
-            {
-                if (g_verbose)
-                {
-                    ::System::Console::WriteLine(
-                        "> resolving type {0} from {1}.",
-                        cts_name, ret_type->get_Assembly()->get_FullName() );
-                }
-                break;
-            }
-        }
-    }
-    if (0 != ret_type)
-        return ret_type->get_Assembly();
-    return 0;
+	::System::String * cts_name = args->get_Name();
+	::System::Type * ret_type = m_module_builder->GetType(
+		cts_name, false /* no exc */ );
+	if (0 == ret_type)
+	{
+		iface_entry * entry = dynamic_cast< iface_entry * >(
+			m_incomplete_ifaces->get_Item( cts_name ) );
+		if (0 != entry)
+			ret_type = entry->m_type_builder;
+	}
+	if (0 == ret_type)
+	{
+		sal_Int32 len = m_extra_assemblies->get_Length();
+		for ( sal_Int32 pos = 0; pos < len; ++pos )
+		{
+			ret_type = m_extra_assemblies[ pos ]->GetType(
+				cts_name, false /* no exc */ );
+			if (0 != ret_type)
+			{
+				if (g_verbose)
+				{
+					::System::Console::WriteLine(
+						"> resolving type {0} from {1}.",
+						cts_name, ret_type->get_Assembly()->get_FullName() );
+				}
+				break;
+			}
+		}
+	}
+	if (0 != ret_type)
+		return ret_type->get_Assembly();
+	return 0;
 }
 
 //______________________________________________________________________________
 ::System::Type * TypeEmitter::get_type(
-    ::System::String * cts_name, bool throw_exc )
+	::System::String * cts_name, bool throw_exc )
 {
-    ::System::Type * ret_type = m_module_builder->GetType( cts_name, false );
-    //We get the type from the ModuleBuilder even if the type is not complete
-    //but have been defined.
-    //if (ret_type == 0)
-    //{
-    //    iface_entry * entry = dynamic_cast< iface_entry * >(
-    //        m_incomplete_ifaces->get_Item( cts_name ) );
-    //    if (0 != entry)
-    //        ret_type = entry->m_type_builder;
-    //}
-        //try the cli_basetypes assembly
-    if (ret_type == 0)
-    {
-        ::System::Text::StringBuilder * builder = new ::System::Text::StringBuilder(cts_name);
-        builder->Append(S",cli_basetypes");
-        ret_type = ::System::Type::GetType(builder->ToString());
-    }
-
-    if (ret_type == 0)
-    {
-		try 
+	::System::Type * ret_type = m_module_builder->GetType( cts_name, false );
+	//We get the type from the ModuleBuilder even if the type is not complete
+	//but have been defined.
+	//if (ret_type == 0)
+	//{
+	//	iface_entry * entry = dynamic_cast< iface_entry * >(
+	//		m_incomplete_ifaces->get_Item( cts_name ) );
+	//	if (0 != entry)
+	//		ret_type = entry->m_type_builder;
+	//}
+		//try the cli_basetypes assembly
+	if (ret_type == 0)
+	{
+		::System::Text::StringBuilder * builder = new ::System::Text::StringBuilder(cts_name);
+		builder->Append(S",cli_basetypes");
+		ret_type = ::System::Type::GetType(builder->ToString());
+	}
+
+	if (ret_type == 0)
+	{
+		try
 		{
 			// may call on type_resolve()
 			return ::System::Type::GetType( cts_name, throw_exc );
-		} 
+		}
 		catch (::System::Exception* exc)
 		{
-			//If the type is not found one may have forgotten to specify assemblies with 
+			//If the type is not found one may have forgotten to specify assemblies with
 			//additional types
 			::System::Text::StringBuilder * sb = new ::System::Text::StringBuilder();
 			sb->Append(new ::System::String(S"\nThe type "));
@@ -369,1103 +369,1103 @@ Assembly * TypeEmitter::type_resolve(
 			if (throw_exc)
 				throw new ::System::Exception(sb->ToString(), exc);
 		}
-    }
-    else
-    {
-        return ret_type;
-    }
+	}
+	else
+	{
+		return ret_type;
+	}
 }
 
 //______________________________________________________________________________
 ::System::Type * TypeEmitter::get_type_Exception()
 {
-    if (0 == m_type_Exception)
-    {
-        m_type_Exception = get_type(
-            S"unoidl.com.sun.star.uno.Exception", false /* no exc */ );
-        if (0 == m_type_Exception)
-        {
-            // define hardcoded type unoidl.com.sun.star.uno.Exception
-            Emit::TypeBuilder * type_builder =
-                m_module_builder->DefineType(
-                      S"unoidl.com.sun.star.uno.Exception",
-                      (TypeAttributes) (TypeAttributes::Public |
-                                        TypeAttributes::BeforeFieldInit |
-                                        TypeAttributes::AnsiClass),
-                      __typeof (::System::Exception) );
-            Emit::FieldBuilder * field_Context = type_builder->DefineField(
-                S"Context", __typeof (::System::Object),
-                FieldAttributes::Public );
-            // default .ctor
-            type_builder->DefineDefaultConstructor( c_ctor_method_attr );
-            // .ctor
-            ::System::Type * param_types[] =
-                  new ::System::Type *[ 2 ];
-            param_types[ 0 ] = __typeof (::System::String);
-            param_types[ 1 ] = __typeof (::System::Object);
-            Emit::ConstructorBuilder * ctor_builder =
-                type_builder->DefineConstructor(
-                    c_ctor_method_attr, CallingConventions::Standard,
-                    param_types );
-            ctor_builder->DefineParameter(
-                1, ParameterAttributes::In, S"Message" );
-            ctor_builder->DefineParameter(
-                2, ParameterAttributes::In, S"Context" );
-            Emit::ILGenerator * code = ctor_builder->GetILGenerator();
-            code->Emit( Emit::OpCodes::Ldarg_0 );
-            code->Emit( Emit::OpCodes::Ldarg_1 );
-            param_types = new ::System::Type * [ 1 ];
-            param_types[ 0 ] = __typeof (::System::String);
-            code->Emit(
-                Emit::OpCodes::Call,
-                __typeof (::System::Exception)
-                  ->GetConstructor( param_types ) );
-            code->Emit( Emit::OpCodes::Ldarg_0 );
-            code->Emit( Emit::OpCodes::Ldarg_2 );
-            code->Emit( Emit::OpCodes::Stfld, field_Context );
-            code->Emit( Emit::OpCodes::Ret );
-            
-            if (g_verbose)
-            {
-                ::System::Console::WriteLine(
-                    "> emitting exception type "
-                    "unoidl.com.sun.star.uno.Exception" );
-            }
-            m_type_Exception = type_builder->CreateType();
-        }
-    }
-    return m_type_Exception;
+	if (0 == m_type_Exception)
+	{
+		m_type_Exception = get_type(
+			S"unoidl.com.sun.star.uno.Exception", false /* no exc */ );
+		if (0 == m_type_Exception)
+		{
+			// define hardcoded type unoidl.com.sun.star.uno.Exception
+			Emit::TypeBuilder * type_builder =
+				m_module_builder->DefineType(
+					  S"unoidl.com.sun.star.uno.Exception",
+					  (TypeAttributes) (TypeAttributes::Public |
+										TypeAttributes::BeforeFieldInit |
+										TypeAttributes::AnsiClass),
+					  __typeof (::System::Exception) );
+			Emit::FieldBuilder * field_Context = type_builder->DefineField(
+				S"Context", __typeof (::System::Object),
+				FieldAttributes::Public );
+			// default .ctor
+			type_builder->DefineDefaultConstructor( c_ctor_method_attr );
+			// .ctor
+			::System::Type * param_types[] =
+				  new ::System::Type *[ 2 ];
+			param_types[ 0 ] = __typeof (::System::String);
+			param_types[ 1 ] = __typeof (::System::Object);
+			Emit::ConstructorBuilder * ctor_builder =
+				type_builder->DefineConstructor(
+					c_ctor_method_attr, CallingConventions::Standard,
+					param_types );
+			ctor_builder->DefineParameter(
+				1, ParameterAttributes::In, S"Message" );
+			ctor_builder->DefineParameter(
+				2, ParameterAttributes::In, S"Context" );
+			Emit::ILGenerator * code = ctor_builder->GetILGenerator();
+			code->Emit( Emit::OpCodes::Ldarg_0 );
+			code->Emit( Emit::OpCodes::Ldarg_1 );
+			param_types = new ::System::Type * [ 1 ];
+			param_types[ 0 ] = __typeof (::System::String);
+			code->Emit(
+				Emit::OpCodes::Call,
+				__typeof (::System::Exception)
+				  ->GetConstructor( param_types ) );
+			code->Emit( Emit::OpCodes::Ldarg_0 );
+			code->Emit( Emit::OpCodes::Ldarg_2 );
+			code->Emit( Emit::OpCodes::Stfld, field_Context );
+			code->Emit( Emit::OpCodes::Ret );
+
+			if (g_verbose)
+			{
+				::System::Console::WriteLine(
+					"> emitting exception type "
+					"unoidl.com.sun.star.uno.Exception" );
+			}
+			m_type_Exception = type_builder->CreateType();
+		}
+	}
+	return m_type_Exception;
 }
 
 //______________________________________________________________________________
 ::System::Type * TypeEmitter::get_type_RuntimeException()
 {
-    if (0 == m_type_RuntimeException)
-    {
-        m_type_RuntimeException = get_type(
-            S"unoidl.com.sun.star.uno.RuntimeException", false /* no exc */ );
-        if (0 == m_type_RuntimeException)
-        {
-            // define hardcoded type unoidl.com.sun.star.uno.RuntimeException
-            ::System::Type * type_Exception = get_type_Exception();
-            Emit::TypeBuilder * type_builder =
-                  m_module_builder->DefineType(
-                      S"unoidl.com.sun.star.uno.RuntimeException",
-                      (TypeAttributes) (TypeAttributes::Public |
-                                        TypeAttributes::BeforeFieldInit |
-                                        TypeAttributes::AnsiClass),
-                      type_Exception );
-            // default .ctor
-            type_builder->DefineDefaultConstructor( c_ctor_method_attr );
-            // .ctor
-            ::System::Type * param_types [] =
-                  new ::System::Type * [ 2 ];
-            param_types[ 0 ] = __typeof (::System::String);
-            param_types[ 1 ] = __typeof (::System::Object);
-            Emit::ConstructorBuilder * ctor_builder =
-                type_builder->DefineConstructor(
-                    c_ctor_method_attr, CallingConventions::Standard,
-                    param_types );
-            ctor_builder->DefineParameter(
-                1, ParameterAttributes::In, S"Message" );
-            ctor_builder->DefineParameter(
-                2, ParameterAttributes::In, S"Context" );
-            Emit::ILGenerator * code = ctor_builder->GetILGenerator();
-            code->Emit( Emit::OpCodes::Ldarg_0 );
-            code->Emit( Emit::OpCodes::Ldarg_1 );
-            code->Emit( Emit::OpCodes::Ldarg_2 );
-            code->Emit(
-                Emit::OpCodes::Call,
-                type_Exception->GetConstructor( param_types ) );
-            code->Emit( Emit::OpCodes::Ret );
-            
-            if (g_verbose)
-            {
-                ::System::Console::WriteLine(
-                    "> emitting exception type "
-                    "unoidl.com.sun.star.uno.RuntimeException" );
-            }
-            m_type_RuntimeException = type_builder->CreateType();
-        }
-    }
-    return m_type_RuntimeException;
+	if (0 == m_type_RuntimeException)
+	{
+		m_type_RuntimeException = get_type(
+			S"unoidl.com.sun.star.uno.RuntimeException", false /* no exc */ );
+		if (0 == m_type_RuntimeException)
+		{
+			// define hardcoded type unoidl.com.sun.star.uno.RuntimeException
+			::System::Type * type_Exception = get_type_Exception();
+			Emit::TypeBuilder * type_builder =
+				  m_module_builder->DefineType(
+					  S"unoidl.com.sun.star.uno.RuntimeException",
+					  (TypeAttributes) (TypeAttributes::Public |
+										TypeAttributes::BeforeFieldInit |
+										TypeAttributes::AnsiClass),
+					  type_Exception );
+			// default .ctor
+			type_builder->DefineDefaultConstructor( c_ctor_method_attr );
+			// .ctor
+			::System::Type * param_types [] =
+				  new ::System::Type * [ 2 ];
+			param_types[ 0 ] = __typeof (::System::String);
+			param_types[ 1 ] = __typeof (::System::Object);
+			Emit::ConstructorBuilder * ctor_builder =
+				type_builder->DefineConstructor(
+					c_ctor_method_attr, CallingConventions::Standard,
+					param_types );
+			ctor_builder->DefineParameter(
+				1, ParameterAttributes::In, S"Message" );
+			ctor_builder->DefineParameter(
+				2, ParameterAttributes::In, S"Context" );
+			Emit::ILGenerator * code = ctor_builder->GetILGenerator();
+			code->Emit( Emit::OpCodes::Ldarg_0 );
+			code->Emit( Emit::OpCodes::Ldarg_1 );
+			code->Emit( Emit::OpCodes::Ldarg_2 );
+			code->Emit(
+				Emit::OpCodes::Call,
+				type_Exception->GetConstructor( param_types ) );
+			code->Emit( Emit::OpCodes::Ret );
+
+			if (g_verbose)
+			{
+				::System::Console::WriteLine(
+					"> emitting exception type "
+					"unoidl.com.sun.star.uno.RuntimeException" );
+			}
+			m_type_RuntimeException = type_builder->CreateType();
+		}
+	}
+	return m_type_RuntimeException;
 }
 
 //______________________________________________________________________________
 ::System::Type * TypeEmitter::get_type(
-    Reference< reflection::XConstantTypeDescription > const & xType )
+	Reference< reflection::XConstantTypeDescription > const & xType )
 {
-    ::System::String * cts_name = to_cts_name( xType->getName() );
-    ::System::Type * ret_type = get_type( cts_name, false /* no exc */ );
-    if (0 == ret_type)
-    {
-        Reference< reflection::XConstantTypeDescription > xConstant(
-            xType, UNO_QUERY_THROW );
-        ::System::Object * constant =
-              to_cli_constant( xConstant->getConstantValue() );
-        Emit::TypeBuilder * type_builder =
-            m_module_builder->DefineType(
-                cts_name,
-                (TypeAttributes) (TypeAttributes::Public |
-                                  TypeAttributes::Sealed |
-                                  TypeAttributes::BeforeFieldInit |
-                                  TypeAttributes::AnsiClass) );
-        
-        Emit::FieldBuilder * field_builder = type_builder->DefineField(
-            cts_name->Substring( cts_name->LastIndexOf( '.' ) +1 ),
-            constant->GetType(),
-            (FieldAttributes) (FieldAttributes::Public |
-                               FieldAttributes::Static |
-                               FieldAttributes::Literal) );
-        field_builder->SetConstant( constant );
-        
-        if (g_verbose)
-        {
-            ::System::Console::WriteLine(
-                "> emitting constant type {0}", cts_name );
-        }
-        ret_type = type_builder->CreateType();
-    }
-    return ret_type;
+	::System::String * cts_name = to_cts_name( xType->getName() );
+	::System::Type * ret_type = get_type( cts_name, false /* no exc */ );
+	if (0 == ret_type)
+	{
+		Reference< reflection::XConstantTypeDescription > xConstant(
+			xType, UNO_QUERY_THROW );
+		::System::Object * constant =
+			  to_cli_constant( xConstant->getConstantValue() );
+		Emit::TypeBuilder * type_builder =
+			m_module_builder->DefineType(
+				cts_name,
+				(TypeAttributes) (TypeAttributes::Public |
+								  TypeAttributes::Sealed |
+								  TypeAttributes::BeforeFieldInit |
+								  TypeAttributes::AnsiClass) );
+
+		Emit::FieldBuilder * field_builder = type_builder->DefineField(
+			cts_name->Substring( cts_name->LastIndexOf( '.' ) +1 ),
+			constant->GetType(),
+			(FieldAttributes) (FieldAttributes::Public |
+							   FieldAttributes::Static |
+							   FieldAttributes::Literal) );
+		field_builder->SetConstant( constant );
+
+		if (g_verbose)
+		{
+			::System::Console::WriteLine(
+				"> emitting constant type {0}", cts_name );
+		}
+		ret_type = type_builder->CreateType();
+	}
+	return ret_type;
 }
 
 //______________________________________________________________________________
 ::System::Type * TypeEmitter::get_type(
-    Reference< reflection::XConstantsTypeDescription > const & xType )
+	Reference< reflection::XConstantsTypeDescription > const & xType )
 {
-    ::System::String * cts_name = to_cts_name( xType->getName() );
-    ::System::Type * ret_type = get_type( cts_name, false /* no exc */ );
-    if (0 == ret_type)
-    {
-        Emit::TypeBuilder * type_builder =
-            m_module_builder->DefineType(
-                cts_name,
-                (TypeAttributes) (TypeAttributes::Public |
-                                  TypeAttributes::Sealed |
-                                  TypeAttributes::BeforeFieldInit |
-                                  TypeAttributes::AnsiClass) );
-        
-        Sequence< Reference<
-            reflection::XConstantTypeDescription > > seq_constants(
-                xType->getConstants() );
-        Reference< reflection::XConstantTypeDescription > const * constants =
-            seq_constants.getConstArray();
-        sal_Int32 constants_length = seq_constants.getLength();
-        for ( sal_Int32 constants_pos = 0;
-              constants_pos < constants_length; ++constants_pos )
-        {
-            Reference<
-                reflection::XConstantTypeDescription > const & xConstant =
-                constants[ constants_pos ];
-            ::System::Object * constant =
-                  to_cli_constant( xConstant->getConstantValue() );
-            ::System::String * uno_name =
-                  ustring_to_String( xConstant->getName() );
-            Emit::FieldBuilder * field_builder = type_builder->DefineField(
-                uno_name->Substring( uno_name->LastIndexOf( '.' ) +1 ),
-                constant->GetType(),
-                (FieldAttributes) (FieldAttributes::Public |
-                                   FieldAttributes::Static |
-                                   FieldAttributes::Literal) );
-            field_builder->SetConstant( constant );
-        }
-        
-        if (g_verbose)
-        {
-            ::System::Console::WriteLine(
-                "> emitting constants group type {0}", cts_name );
-        }
-        ret_type = type_builder->CreateType();
-    }
-    return ret_type;
+	::System::String * cts_name = to_cts_name( xType->getName() );
+	::System::Type * ret_type = get_type( cts_name, false /* no exc */ );
+	if (0 == ret_type)
+	{
+		Emit::TypeBuilder * type_builder =
+			m_module_builder->DefineType(
+				cts_name,
+				(TypeAttributes) (TypeAttributes::Public |
+								  TypeAttributes::Sealed |
+								  TypeAttributes::BeforeFieldInit |
+								  TypeAttributes::AnsiClass) );
+
+		Sequence< Reference<
+			reflection::XConstantTypeDescription > > seq_constants(
+				xType->getConstants() );
+		Reference< reflection::XConstantTypeDescription > const * constants =
+			seq_constants.getConstArray();
+		sal_Int32 constants_length = seq_constants.getLength();
+		for ( sal_Int32 constants_pos = 0;
+			  constants_pos < constants_length; ++constants_pos )
+		{
+			Reference<
+				reflection::XConstantTypeDescription > const & xConstant =
+				constants[ constants_pos ];
+			::System::Object * constant =
+				  to_cli_constant( xConstant->getConstantValue() );
+			::System::String * uno_name =
+				  ustring_to_String( xConstant->getName() );
+			Emit::FieldBuilder * field_builder = type_builder->DefineField(
+				uno_name->Substring( uno_name->LastIndexOf( '.' ) +1 ),
+				constant->GetType(),
+				(FieldAttributes) (FieldAttributes::Public |
+								   FieldAttributes::Static |
+								   FieldAttributes::Literal) );
+			field_builder->SetConstant( constant );
+		}
+
+		if (g_verbose)
+		{
+			::System::Console::WriteLine(
+				"> emitting constants group type {0}", cts_name );
+		}
+		ret_type = type_builder->CreateType();
+	}
+	return ret_type;
 }
 
 //______________________________________________________________________________
 ::System::Type * TypeEmitter::get_type(
-    Reference< reflection::XEnumTypeDescription > const & xType )
+	Reference< reflection::XEnumTypeDescription > const & xType )
 {
-    ::System::String * cts_name = to_cts_name( xType->getName() );
-    ::System::Type * ret_type = get_type( cts_name, false /* no exc */ );
-    if (0 == ret_type)
-    {
-//         Emit::EnumBuilder * enum_builder =
-//             m_module_builder->DefineEnum(
-//                 cts_name,
-//                 (TypeAttributes) (TypeAttributes::Public |
-// //                                   TypeAttributes::Sealed |
-//                                   TypeAttributes::AnsiClass),
-//                 __typeof (::System::Int32) );
-        // workaround enum builder bug
-        Emit::TypeBuilder * enum_builder =
-            m_module_builder->DefineType(
-                cts_name,
-                (TypeAttributes) (TypeAttributes::Public |
-                                  TypeAttributes::Sealed),
-                __typeof (::System::Enum) );
-        enum_builder->DefineField(
-            S"value__", __typeof (::System::Int32),
-            (FieldAttributes) (FieldAttributes::Private |
-                               FieldAttributes::SpecialName |
-                               FieldAttributes::RTSpecialName) );
-        Sequence< OUString > seq_enum_names( xType->getEnumNames() );
-        Sequence< sal_Int32 > seq_enum_values( xType->getEnumValues() );
-        sal_Int32 enum_length = seq_enum_names.getLength();
-        OSL_ASSERT( enum_length == seq_enum_values.getLength() );
-        OUString const * enum_names = seq_enum_names.getConstArray();
-        sal_Int32 const * enum_values = seq_enum_values.getConstArray();
-        for ( sal_Int32 enum_pos = 0; enum_pos < enum_length; ++enum_pos )
-        {
-//             enum_builder->DefineLiteral(
-//                 ustring_to_String( enum_names[ enum_pos ] ),
-//                 __box ((::System::Int32) enum_values[ enum_pos ]) );
-            Emit::FieldBuilder * field_builder =
-                enum_builder->DefineField(
-                    ustring_to_String( enum_names[ enum_pos ] ),
-                    enum_builder,
-                    (FieldAttributes) (FieldAttributes::Public |
-                                       FieldAttributes::Static |
-                                       FieldAttributes::Literal) );
-            field_builder->SetConstant(
-                __box ((::System::Int32) enum_values[ enum_pos ]) );
-        }
-        
-        if (g_verbose)
-        {
-            ::System::Console::WriteLine(
-                "> emitting enum type {0}", cts_name );
-        }
-        ret_type = enum_builder->CreateType();
-    }
-    return ret_type;
+	::System::String * cts_name = to_cts_name( xType->getName() );
+	::System::Type * ret_type = get_type( cts_name, false /* no exc */ );
+	if (0 == ret_type)
+	{
+//		 Emit::EnumBuilder * enum_builder =
+//			 m_module_builder->DefineEnum(
+//				 cts_name,
+//				 (TypeAttributes) (TypeAttributes::Public |
+// //								   TypeAttributes::Sealed |
+//								   TypeAttributes::AnsiClass),
+//				 __typeof (::System::Int32) );
+		// workaround enum builder bug
+		Emit::TypeBuilder * enum_builder =
+			m_module_builder->DefineType(
+				cts_name,
+				(TypeAttributes) (TypeAttributes::Public |
+								  TypeAttributes::Sealed),
+				__typeof (::System::Enum) );
+		enum_builder->DefineField(
+			S"value__", __typeof (::System::Int32),
+			(FieldAttributes) (FieldAttributes::Private |
+							   FieldAttributes::SpecialName |
+							   FieldAttributes::RTSpecialName) );
+		Sequence< OUString > seq_enum_names( xType->getEnumNames() );
+		Sequence< sal_Int32 > seq_enum_values( xType->getEnumValues() );
+		sal_Int32 enum_length = seq_enum_names.getLength();
+		OSL_ASSERT( enum_length == seq_enum_values.getLength() );
+		OUString const * enum_names = seq_enum_names.getConstArray();
+		sal_Int32 const * enum_values = seq_enum_values.getConstArray();
+		for ( sal_Int32 enum_pos = 0; enum_pos < enum_length; ++enum_pos )
+		{
+//			 enum_builder->DefineLiteral(
+//				 ustring_to_String( enum_names[ enum_pos ] ),
+//				 __box ((::System::Int32) enum_values[ enum_pos ]) );
+			Emit::FieldBuilder * field_builder =
+				enum_builder->DefineField(
+					ustring_to_String( enum_names[ enum_pos ] ),
+					enum_builder,
+					(FieldAttributes) (FieldAttributes::Public |
+									   FieldAttributes::Static |
+									   FieldAttributes::Literal) );
+			field_builder->SetConstant(
+				__box ((::System::Int32) enum_values[ enum_pos ]) );
+		}
+
+		if (g_verbose)
+		{
+			::System::Console::WriteLine(
+				"> emitting enum type {0}", cts_name );
+		}
+		ret_type = enum_builder->CreateType();
+	}
+	return ret_type;
 }
 
 //______________________________________________________________________________
 ::System::Type * TypeEmitter::get_type(
-    Reference< reflection::XCompoundTypeDescription > const & xType )
+	Reference< reflection::XCompoundTypeDescription > const & xType )
 {
-    OUString uno_name( xType->getName() );
-    if (TypeClass_EXCEPTION == xType->getTypeClass())
-    {
-        if (uno_name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(
-                                       "com.sun.star.uno.Exception") ))
-        {
-            return get_type_Exception();
-        }
-        if (uno_name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(
-                                       "com.sun.star.uno.RuntimeException") ))
-        {
-            return get_type_RuntimeException();
-        }
-    }
-    ::System::String * cts_name = to_cts_name( uno_name );
-    // if the struct is an instantiated polymorpic struct then we create the simple struct name
-    // For example:
-    // void func ([in] PolyStruct<boolean> arg);
-    //PolyStruct<boolean> will be converted to PolyStruct
-    polymorphicStructNameToStructName( & cts_name);
-
-    ::System::Type * ret_type = get_type( cts_name, false /* no exc */ );
-    if (0 == ret_type)
-    {
-        Reference< reflection::XCompoundTypeDescription > xBaseType(
-            xType->getBaseType(), UNO_QUERY );
-        ::System::Type * base_type = (xBaseType.is()
-                                      ? get_type( xBaseType )
-                                      : __typeof (::System::Object));
-        Emit::TypeBuilder * type_builder =
-            m_module_builder->DefineType(
-                cts_name,
-                (TypeAttributes) (TypeAttributes::Public |
-                                  TypeAttributes::BeforeFieldInit |
-                                  TypeAttributes::AnsiClass),
-                base_type );
-        
-  
-         // insert to be completed
-        struct_entry * entry = new struct_entry();
-        xType->acquire();
-        entry->m_xType = xType.get();
-        entry->m_type_builder = type_builder;
-        entry->m_base_type = base_type;
-        m_incomplete_structs->Add( cts_name, entry );
-        
-        // type is incomplete
-        ret_type = type_builder;
-    }
-    
-    //In case of an instantiated polymorphic struct we want to return a 
-    //uno.PolymorphicType (inherits Type) rather then Type. This is neaded for constructing
-    //the service code. We can only do that if the struct is completed.   
-    if (m_generated_structs->get_Item(cts_name))
-    {
-        Reference< reflection::XStructTypeDescription> xStructTypeDesc(
-            xType, UNO_QUERY);
-
-        if (xStructTypeDesc.is())
-        {
-            Sequence< Reference< reflection::XTypeDescription > > seqTypeArgs = xStructTypeDesc->getTypeArguments();
-            sal_Int32 numTypes = seqTypeArgs.getLength();
-            if (numTypes > 0)
-            {	
-                //it is an instantiated polymorphic struct
-                ::System::String * sCliName = mapUnoTypeName(ustring_to_String(xType->getName()));
-                ret_type = ::uno::PolymorphicType::GetType(ret_type, sCliName);
-            }
-        }
-    }
-    return ret_type;
+	OUString uno_name( xType->getName() );
+	if (TypeClass_EXCEPTION == xType->getTypeClass())
+	{
+		if (uno_name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(
+									   "com.sun.star.uno.Exception") ))
+		{
+			return get_type_Exception();
+		}
+		if (uno_name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(
+									   "com.sun.star.uno.RuntimeException") ))
+		{
+			return get_type_RuntimeException();
+		}
+	}
+	::System::String * cts_name = to_cts_name( uno_name );
+	// if the struct is an instantiated polymorpic struct then we create the simple struct name
+	// For example:
+	// void func ([in] PolyStruct<boolean> arg);
+	//PolyStruct<boolean> will be converted to PolyStruct
+	polymorphicStructNameToStructName( & cts_name);
+
+	::System::Type * ret_type = get_type( cts_name, false /* no exc */ );
+	if (0 == ret_type)
+	{
+		Reference< reflection::XCompoundTypeDescription > xBaseType(
+			xType->getBaseType(), UNO_QUERY );
+		::System::Type * base_type = (xBaseType.is()
+									  ? get_type( xBaseType )
+									  : __typeof (::System::Object));
+		Emit::TypeBuilder * type_builder =
+			m_module_builder->DefineType(
+				cts_name,
+				(TypeAttributes) (TypeAttributes::Public |
+								  TypeAttributes::BeforeFieldInit |
+								  TypeAttributes::AnsiClass),
+				base_type );
+
+
+		// insert to be completed
+		struct_entry * entry = new struct_entry();
+		xType->acquire();
+		entry->m_xType = xType.get();
+		entry->m_type_builder = type_builder;
+		entry->m_base_type = base_type;
+		m_incomplete_structs->Add( cts_name, entry );
+
+		// type is incomplete
+		ret_type = type_builder;
+	}
+
+	//In case of an instantiated polymorphic struct we want to return a
+	//uno.PolymorphicType (inherits Type) rather then Type. This is needed for constructing
+	//the service code. We can only do that if the struct is completed.
+	if (m_generated_structs->get_Item(cts_name))
+	{
+		Reference< reflection::XStructTypeDescription> xStructTypeDesc(
+			xType, UNO_QUERY);
+
+		if (xStructTypeDesc.is())
+		{
+			Sequence< Reference< reflection::XTypeDescription > > seqTypeArgs = xStructTypeDesc->getTypeArguments();
+			sal_Int32 numTypes = seqTypeArgs.getLength();
+			if (numTypes > 0)
+			{
+				//it is an instantiated polymorphic struct
+				::System::String * sCliName = mapUnoTypeName(ustring_to_String(xType->getName()));
+				ret_type = ::uno::PolymorphicType::GetType(ret_type, sCliName);
+			}
+		}
+	}
+	return ret_type;
 }
 
 //______________________________________________________________________________
 ::System::Type * TypeEmitter::get_type(
-    Reference< reflection::XInterfaceTypeDescription2 > const & xType )
+	Reference< reflection::XInterfaceTypeDescription2 > const & xType )
 {
-    OUString uno_name( xType->getName() );
-    if (uno_name.equalsAsciiL(
-            RTL_CONSTASCII_STRINGPARAM("com.sun.star.uno.XInterface") ))
-    {
-        return __typeof (::System::Object);
-    }
-    
-    ::System::String * cts_name = to_cts_name( xType->getName() );
-    ::System::Type * ret_type = get_type( cts_name, false /* no exc */ );
-    if (0 == ret_type)
-    {
-        Emit::TypeBuilder * type_builder;
-        
-        TypeAttributes attr = (TypeAttributes) (TypeAttributes::Public |
-                                                TypeAttributes::Interface |
-                                                TypeAttributes::Abstract |
-                                                TypeAttributes::AnsiClass);
-
-        std::vector<Reference<reflection::XInterfaceTypeDescription2> > vecBaseTypes;
-        Sequence<Reference< reflection::XTypeDescription > > seqBaseTypes =
-            xType->getBaseTypes();
-        if (seqBaseTypes.getLength() > 0)
-        {
-            for (int i = 0; i < seqBaseTypes.getLength(); i++)
-            {
-                Reference<reflection::XInterfaceTypeDescription2> xIfaceTd =
-                    resolveInterfaceTypedef(seqBaseTypes[i]);
-
-                if (xIfaceTd->getName().equalsAsciiL(
-                        RTL_CONSTASCII_STRINGPARAM("com.sun.star.uno.XInterface") ) == sal_False)
-                {
-                    vecBaseTypes.push_back(xIfaceTd);
-                }
-            }
-
-            ::System::Type * base_interfaces [] =
-                  new ::System::Type * [ vecBaseTypes.size() ];
-
-            typedef std::vector<Reference<reflection::XInterfaceTypeDescription2> >::const_iterator it;
-            int index = 0;
-            for (it i = vecBaseTypes.begin(); i != vecBaseTypes.end(); i++, index++)
-                base_interfaces[ index ] = get_type( *i );
-            type_builder = m_module_builder->DefineType(
-                cts_name, attr, 0, base_interfaces );
-        }
-        else
-        {
-            ::System::Console::WriteLine(
-                "warning: IDL interface {0} is not derived from "
-                "com.sun.star.uno.XInterface!",
-                ustring_to_String( uno_name ) );
-            
-            type_builder = m_module_builder->DefineType( cts_name, attr );
-        }
-        
-        // insert to be completed
-        iface_entry * entry = new iface_entry();
-        xType->acquire();
-        entry->m_xType = xType.get();
-        entry->m_type_builder = type_builder;
-        m_incomplete_ifaces->Add( cts_name, entry );
-        
-        // type is incomplete
-        ret_type = type_builder;
-    }
-    return ret_type;
+	OUString uno_name( xType->getName() );
+	if (uno_name.equalsAsciiL(
+			RTL_CONSTASCII_STRINGPARAM("com.sun.star.uno.XInterface") ))
+	{
+		return __typeof (::System::Object);
+	}
+
+	::System::String * cts_name = to_cts_name( xType->getName() );
+	::System::Type * ret_type = get_type( cts_name, false /* no exc */ );
+	if (0 == ret_type)
+	{
+		Emit::TypeBuilder * type_builder;
+
+		TypeAttributes attr = (TypeAttributes) (TypeAttributes::Public |
+												TypeAttributes::Interface |
+												TypeAttributes::Abstract |
+												TypeAttributes::AnsiClass);
+
+		std::vector<Reference<reflection::XInterfaceTypeDescription2> > vecBaseTypes;
+		Sequence<Reference< reflection::XTypeDescription > > seqBaseTypes =
+			xType->getBaseTypes();
+		if (seqBaseTypes.getLength() > 0)
+		{
+			for (int i = 0; i < seqBaseTypes.getLength(); i++)
+			{
+				Reference<reflection::XInterfaceTypeDescription2> xIfaceTd =
+					resolveInterfaceTypedef(seqBaseTypes[i]);
+
+				if (xIfaceTd->getName().equalsAsciiL(
+						RTL_CONSTASCII_STRINGPARAM("com.sun.star.uno.XInterface") ) == sal_False)
+				{
+					vecBaseTypes.push_back(xIfaceTd);
+				}
+			}
+
+			::System::Type * base_interfaces [] =
+				  new ::System::Type * [ vecBaseTypes.size() ];
+
+			typedef std::vector<Reference<reflection::XInterfaceTypeDescription2> >::const_iterator it;
+			int index = 0;
+			for (it i = vecBaseTypes.begin(); i != vecBaseTypes.end(); i++, index++)
+				base_interfaces[ index ] = get_type( *i );
+			type_builder = m_module_builder->DefineType(
+				cts_name, attr, 0, base_interfaces );
+		}
+		else
+		{
+			::System::Console::WriteLine(
+				"warning: IDL interface {0} is not derived from "
+				"com.sun.star.uno.XInterface!",
+				ustring_to_String( uno_name ) );
+
+			type_builder = m_module_builder->DefineType( cts_name, attr );
+		}
+
+		// insert to be completed
+		iface_entry * entry = new iface_entry();
+		xType->acquire();
+		entry->m_xType = xType.get();
+		entry->m_type_builder = type_builder;
+		m_incomplete_ifaces->Add( cts_name, entry );
+
+		// type is incomplete
+		ret_type = type_builder;
+	}
+	return ret_type;
 }
- 
+
 
 //______________________________________________________________________________
 ::System::Type * TypeEmitter::get_type(
-    Reference< reflection::XServiceTypeDescription2 > const & xType )
+	Reference< reflection::XServiceTypeDescription2 > const & xType )
 {
-    if (xType->isSingleInterfaceBased() == sal_False)
-        return NULL;
-    
-    System::String * cts_name = to_cts_name( xType->getName() );
-    System::Type * ret_type = get_type( cts_name, false /* no exc */ );
-    if (ret_type != NULL)
-        return ret_type;
-
-    TypeAttributes attr = (TypeAttributes) (TypeAttributes::Public |
-                                            TypeAttributes::Sealed |
-                                            TypeAttributes::BeforeFieldInit |
-                                            TypeAttributes::AnsiClass);
-    
-    Emit::TypeBuilder * type_builder = m_module_builder->DefineType(
-        cts_name, attr);
-
-    // insert to be completed
-    service_entry * entry = new service_entry();
-    xType->acquire();
-    entry->m_xType = xType.get();
-    entry->m_type_builder = type_builder;
-    m_incomplete_services->Add(cts_name,entry );
-        
-    return type_builder;
+	if (xType->isSingleInterfaceBased() == sal_False)
+		return NULL;
+
+	System::String * cts_name = to_cts_name( xType->getName() );
+	System::Type * ret_type = get_type( cts_name, false /* no exc */ );
+	if (ret_type != NULL)
+		return ret_type;
+
+	TypeAttributes attr = (TypeAttributes) (TypeAttributes::Public |
+											TypeAttributes::Sealed |
+											TypeAttributes::BeforeFieldInit |
+											TypeAttributes::AnsiClass);
+
+	Emit::TypeBuilder * type_builder = m_module_builder->DefineType(
+		cts_name, attr);
+
+	// insert to be completed
+	service_entry * entry = new service_entry();
+	xType->acquire();
+	entry->m_xType = xType.get();
+	entry->m_type_builder = type_builder;
+	m_incomplete_services->Add(cts_name,entry );
+
+	return type_builder;
 }
 
 ::System::Type * TypeEmitter::get_type(
-    Reference<reflection::XSingletonTypeDescription2 > const & xType )
+	Reference<reflection::XSingletonTypeDescription2 > const & xType )
 {
-    if (xType->isInterfaceBased() == sal_False)
-        return NULL;
-    
-    ::System::String* cts_name = to_cts_name( xType->getName() );
-    ::System::Type * ret_type = get_type( cts_name, false /* no exc */ );
-    if (ret_type != NULL)
-        return ret_type;
-
-    TypeAttributes attr = static_cast<TypeAttributes>(
-        TypeAttributes::Public |
-        TypeAttributes::Sealed |
-        TypeAttributes::BeforeFieldInit |
-        TypeAttributes::AnsiClass);
-    
-    Emit::TypeBuilder * type_builder = m_module_builder->DefineType(
-        cts_name, attr);
-
-    // insert to be completed
-    singleton_entry * entry = new singleton_entry();
-    xType->acquire();
-    entry->m_xType = xType.get();
-    entry->m_type_builder = type_builder;
-    m_incomplete_singletons->Add(cts_name,entry );
-        
-    return type_builder;
+	if (xType->isInterfaceBased() == sal_False)
+		return NULL;
+
+	::System::String* cts_name = to_cts_name( xType->getName() );
+	::System::Type * ret_type = get_type( cts_name, false /* no exc */ );
+	if (ret_type != NULL)
+		return ret_type;
+
+	TypeAttributes attr = static_cast<TypeAttributes>(
+		TypeAttributes::Public |
+		TypeAttributes::Sealed |
+		TypeAttributes::BeforeFieldInit |
+		TypeAttributes::AnsiClass);
+
+	Emit::TypeBuilder * type_builder = m_module_builder->DefineType(
+		cts_name, attr);
+
+	// insert to be completed
+	singleton_entry * entry = new singleton_entry();
+	xType->acquire();
+	entry->m_xType = xType.get();
+	entry->m_type_builder = type_builder;
+	m_incomplete_singletons->Add(cts_name,entry );
+
+	return type_builder;
 
 }
 
 //______________________________________________________________________________
 ::System::Type * TypeEmitter::complete_iface_type( iface_entry * entry )
 {
-    Emit::TypeBuilder * type_builder = entry->m_type_builder;
-    reflection::XInterfaceTypeDescription2 * xType = entry->m_xType;
-    
-    Sequence<Reference< reflection::XTypeDescription > > seqBaseTypes( xType->getBaseTypes() );
-    if (seqBaseTypes.getLength() > 0)
-    {
-        for (int i = 0; i < seqBaseTypes.getLength(); i++)
-        {
-            //make sure we get the interface rather then a typedef
-            Reference<reflection::XInterfaceTypeDescription2> aBaseType =
-                resolveInterfaceTypedef( seqBaseTypes[i]);
-
-            if (aBaseType->getName().equalsAsciiL(
-                    RTL_CONSTASCII_STRINGPARAM("com.sun.star.uno.XInterface") ) == sal_False)
-            {
-                ::System::String * basetype_name = to_cts_name( aBaseType->getName() );
-                iface_entry * base_entry = dynamic_cast< iface_entry * >(
-                    m_incomplete_ifaces->get_Item( basetype_name ) );
-                if (0 != base_entry)
-                {
-                // complete uncompleted base type first
-                    complete_iface_type( base_entry );
-                }
-            }
-        }
-    }
-
-    Sequence<
-        Reference< reflection::XInterfaceMemberTypeDescription > > seq_members(
-            xType->getMembers() );
-    Reference< reflection::XInterfaceMemberTypeDescription > const * members =
-        seq_members.getConstArray();
-    sal_Int32 members_length = seq_members.getLength();
-    for ( sal_Int32 members_pos = 0;
-          members_pos < members_length; ++members_pos )
-    {
-        Reference<
-            reflection::XInterfaceMemberTypeDescription > const & xMember =
-            members[ members_pos ];
-        Sequence< Reference< reflection::XTypeDescription > > seq_exceptions;
-        Emit::MethodBuilder * method_builder;
-        
-        const MethodAttributes c_method_attr = (MethodAttributes)
-            (MethodAttributes::Public |
-             MethodAttributes::Abstract |
-             MethodAttributes::Virtual |
-             MethodAttributes::NewSlot |
-             MethodAttributes::HideBySig);
+	Emit::TypeBuilder * type_builder = entry->m_type_builder;
+	reflection::XInterfaceTypeDescription2 * xType = entry->m_xType;
+
+	Sequence<Reference< reflection::XTypeDescription > > seqBaseTypes( xType->getBaseTypes() );
+	if (seqBaseTypes.getLength() > 0)
+	{
+		for (int i = 0; i < seqBaseTypes.getLength(); i++)
+		{
+			//make sure we get the interface rather then a typedef
+			Reference<reflection::XInterfaceTypeDescription2> aBaseType =
+				resolveInterfaceTypedef( seqBaseTypes[i]);
+
+			if (aBaseType->getName().equalsAsciiL(
+					RTL_CONSTASCII_STRINGPARAM("com.sun.star.uno.XInterface") ) == sal_False)
+			{
+				::System::String * basetype_name = to_cts_name( aBaseType->getName() );
+				iface_entry * base_entry = dynamic_cast< iface_entry * >(
+					m_incomplete_ifaces->get_Item( basetype_name ) );
+				if (0 != base_entry)
+				{
+				// complete uncompleted base type first
+					complete_iface_type( base_entry );
+				}
+			}
+		}
+	}
+
+	Sequence<
+		Reference< reflection::XInterfaceMemberTypeDescription > > seq_members(
+			xType->getMembers() );
+	Reference< reflection::XInterfaceMemberTypeDescription > const * members =
+		seq_members.getConstArray();
+	sal_Int32 members_length = seq_members.getLength();
+	for ( sal_Int32 members_pos = 0;
+		  members_pos < members_length; ++members_pos )
+	{
+		Reference<
+			reflection::XInterfaceMemberTypeDescription > const & xMember =
+			members[ members_pos ];
+		Sequence< Reference< reflection::XTypeDescription > > seq_exceptions;
+		Emit::MethodBuilder * method_builder;
+
+		const MethodAttributes c_method_attr = (MethodAttributes)
+			(MethodAttributes::Public |
+			 MethodAttributes::Abstract |
+			 MethodAttributes::Virtual |
+			 MethodAttributes::NewSlot |
+			 MethodAttributes::HideBySig);
 //#if defined(_MSC_VER) && (_MSC_VER < 1400)
-//             MethodAttributes::Instance);
+//			 MethodAttributes::Instance);
 //#else
-//	     Instance);
+//		 Instance);
 //#endif
-        
-        if (TypeClass_INTERFACE_METHOD == xMember->getTypeClass())
-        {
-            Reference< reflection::XInterfaceMethodTypeDescription > xMethod(
-                xMember, UNO_QUERY_THROW );
-            
-            Sequence<
-                Reference< reflection::XMethodParameter > > seq_parameters(
-                    xMethod->getParameters() );
-            sal_Int32 params_length = seq_parameters.getLength();
-            ::System::Type * param_types [] =
-                  new ::System::Type * [ params_length ];
-            Reference< reflection::XMethodParameter > const * parameters =
-                seq_parameters.getConstArray();
-            // first determine all types
-            //Make the first param type as return type
-            sal_Int32 params_pos = 0;
-            for ( ; params_pos < params_length; ++params_pos )
-            {
-                Reference< reflection::XMethodParameter > const & xParam =
-                    parameters[ params_pos ];
-                ::System::Type * param_type = get_type( xParam->getType() );
-                ::System::String * param_type_name = param_type->get_FullName();
-                if (xParam->isOut())
-                {
-                    param_type = get_type(
-                        ::System::String::Concat(
-                            param_type_name, S"&" ), true );
-                }
-                param_types[ xParam->getPosition() ] = param_type;
-            }
-
-
-            // create method
-//             if (tb)
-//                 method_builder = type_builder->DefineMethod(
-//                 ustring_to_String( xMethod->getMemberName() ),
-//                 c_method_attr, tb,
-//                 param_types );
-//             else
-                method_builder = type_builder->DefineMethod(
-                    ustring_to_String( xMethod->getMemberName() ),
-                    c_method_attr, get_type( xMethod->getReturnType() ),
-                    param_types );
-            // then define parameter infos
-            params_pos = 0;
-            for ( ; params_pos < params_length; ++params_pos )
-            {
-                Reference< reflection::XMethodParameter > const & xParam =
-                    parameters[ params_pos ];
-                long param_flags = 0;
-                if (xParam->isIn())
-                    param_flags |= ParameterAttributes::In;
-                if (xParam->isOut())
-                    param_flags |= ParameterAttributes::Out;
-                OSL_ASSERT( 0 != param_flags );
-                method_builder->DefineParameter(
-                    xParam->getPosition() +1 /* starts with 1 */,
-                    (ParameterAttributes) param_flags,
-                    ustring_to_String( xParam->getName() ) );
-            }
-            //Apply attribute TypeParametersAttribute to return value if it
-            //is a parameterized Type. Currently only structs can have parameters.
-            Reference<reflection::XStructTypeDescription> xReturnStruct(
-                xMethod->getReturnType(), UNO_QUERY);
-
-            if (xReturnStruct.is())
-            {
-                Sequence<Reference<reflection::XTypeDescription> > seq_type_args =
-                    xReturnStruct->getTypeArguments();
-                if (seq_type_args.getLength() != 0)
-                {
-                    //get th ctor of the attribute
-                    ::System::Type * arCtor[] = {::System::Type::GetType(S"System.Type[]")};
-                    //Get the arguments for the attribute's ctor
-                    Reference<reflection::XTypeDescription> const * arXTypeArgs =
-                        seq_type_args.getConstArray();
-                    int numTypes = seq_type_args.getLength();
-                    ::System::Type * arCtsTypes[] = new ::System::Type*[numTypes];
-                    for (int i = 0; i < numTypes; i++)
-                        arCtsTypes[i] = get_type(arXTypeArgs[i]);
-                    ::System::Object * arArgs[] = {arCtsTypes};
-                    
+
+		if (TypeClass_INTERFACE_METHOD == xMember->getTypeClass())
+		{
+			Reference< reflection::XInterfaceMethodTypeDescription > xMethod(
+				xMember, UNO_QUERY_THROW );
+
+			Sequence<
+				Reference< reflection::XMethodParameter > > seq_parameters(
+					xMethod->getParameters() );
+			sal_Int32 params_length = seq_parameters.getLength();
+			::System::Type * param_types [] =
+				  new ::System::Type * [ params_length ];
+			Reference< reflection::XMethodParameter > const * parameters =
+				seq_parameters.getConstArray();
+			// first determine all types
+			//Make the first param type as return type
+			sal_Int32 params_pos = 0;
+			for ( ; params_pos < params_length; ++params_pos )
+			{
+				Reference< reflection::XMethodParameter > const & xParam =
+					parameters[ params_pos ];
+				::System::Type * param_type = get_type( xParam->getType() );
+				::System::String * param_type_name = param_type->get_FullName();
+				if (xParam->isOut())
+				{
+					param_type = get_type(
+						::System::String::Concat(
+							param_type_name, S"&" ), true );
+				}
+				param_types[ xParam->getPosition() ] = param_type;
+			}
+
+
+			// create method
+//			 if (tb)
+//				 method_builder = type_builder->DefineMethod(
+//				 ustring_to_String( xMethod->getMemberName() ),
+//				 c_method_attr, tb,
+//				 param_types );
+//			 else
+				method_builder = type_builder->DefineMethod(
+					ustring_to_String( xMethod->getMemberName() ),
+					c_method_attr, get_type( xMethod->getReturnType() ),
+					param_types );
+			// then define parameter infos
+			params_pos = 0;
+			for ( ; params_pos < params_length; ++params_pos )
+			{
+				Reference< reflection::XMethodParameter > const & xParam =
+					parameters[ params_pos ];
+				long param_flags = 0;
+				if (xParam->isIn())
+					param_flags |= ParameterAttributes::In;
+				if (xParam->isOut())
+					param_flags |= ParameterAttributes::Out;
+				OSL_ASSERT( 0 != param_flags );
+				method_builder->DefineParameter(
+					xParam->getPosition() +1 /* starts with 1 */,
+					(ParameterAttributes) param_flags,
+					ustring_to_String( xParam->getName() ) );
+			}
+			//Apply attribute TypeParametersAttribute to return value if it
+			//is a parameterized Type. Currently only structs can have parameters.
+			Reference<reflection::XStructTypeDescription> xReturnStruct(
+				xMethod->getReturnType(), UNO_QUERY);
+
+			if (xReturnStruct.is())
+			{
+				Sequence<Reference<reflection::XTypeDescription> > seq_type_args =
+					xReturnStruct->getTypeArguments();
+				if (seq_type_args.getLength() != 0)
+				{
+					//get th ctor of the attribute
+					::System::Type * arCtor[] = {::System::Type::GetType(S"System.Type[]")};
+					//Get the arguments for the attribute's ctor
+					Reference<reflection::XTypeDescription> const * arXTypeArgs =
+						seq_type_args.getConstArray();
+					int numTypes = seq_type_args.getLength();
+					::System::Type * arCtsTypes[] = new ::System::Type*[numTypes];
+					for (int i = 0; i < numTypes; i++)
+						arCtsTypes[i] = get_type(arXTypeArgs[i]);
+					::System::Object * arArgs[] = {arCtsTypes};
+
 					Emit::CustomAttributeBuilder * attrBuilder =
-                        new Emit::CustomAttributeBuilder(
-                            __typeof(::uno::TypeArgumentsAttribute)
-                            ->GetConstructor( arCtor),
-                            arArgs);
-
-                    method_builder->SetCustomAttribute(attrBuilder);
-                }
-            }
-
-            //define UNO exception attribute (exceptions)--------------------------------------
-            Emit::CustomAttributeBuilder* attrBuilder =
-                get_iface_method_exception_attribute(xMethod);
-            if (attrBuilder != NULL)
-                method_builder->SetCustomAttribute(attrBuilder);
-
-            // oneway attribute
-            if (xMethod->isOneway())
-            {
-                ::System::Type * arCtorOneway[] = new ::System::Type*[0];
-                ::System::Object * arArgs[] = new ::System::Object*[0];
-                Emit::CustomAttributeBuilder * attrBuilder =
-                    new Emit::CustomAttributeBuilder(
-                        __typeof(::uno::OnewayAttribute)->GetConstructor( arCtorOneway),
-                        arArgs);
-                method_builder->SetCustomAttribute(attrBuilder);
-            }
-        }
-        else // attribute
-        {
-            OSL_ASSERT(
-                TypeClass_INTERFACE_ATTRIBUTE == xMember->getTypeClass() );
-            Reference<
-                reflection::XInterfaceAttributeTypeDescription2 > xAttribute(
-                    xMember, UNO_QUERY_THROW );
-            
-            const MethodAttributes c_property_method_attr = (MethodAttributes)
-                (c_method_attr | MethodAttributes::SpecialName);
-            
-            ::System::Type * attribute_type = get_type( xAttribute->getType() );
-            ::System::Type * parameters [] =
-                  new ::System::Type * [ 0 ];
-            
-            Emit::PropertyBuilder * property_builder =
-                type_builder->DefineProperty(
-                    ustring_to_String( xAttribute->getMemberName() ),
-                    PropertyAttributes::None,
-                    attribute_type, parameters );
-
-            //set BoundAttribute, if necessary
-            if (xAttribute->isBound())
-            {
-                ConstructorInfo * ctorBoundAttr =
-                    __typeof(::uno::BoundAttribute)->GetConstructor(
-                        new System::Type*[0]);
-                Emit::CustomAttributeBuilder * attrBuilderBound =
-                    new Emit::CustomAttributeBuilder(
-                        ctorBoundAttr, new ::System::Object*[0]);
-                property_builder->SetCustomAttribute(attrBuilderBound);
-            }
-            
-            // getter
-            Emit::MethodBuilder * method_builder =
-                type_builder->DefineMethod(
-                    ustring_to_String( OUSTR("get_") +
-                                       xAttribute->getMemberName() ),
-                    c_property_method_attr, attribute_type, parameters );
-
-           //define UNO exception attribute (exceptions)--------------------------------------
-            Emit::CustomAttributeBuilder* attrBuilder =
-                get_exception_attribute(xAttribute->getGetExceptions());
-            if (attrBuilder != NULL)
-                method_builder->SetCustomAttribute(attrBuilder);
-
-            property_builder->SetGetMethod( method_builder );
-            
-            if (! xAttribute->isReadOnly())
-            {
-                // setter
-                parameters = new ::System::Type * [ 1 ];
-                parameters[ 0 ] = attribute_type;
-                method_builder =
-                    type_builder->DefineMethod(
-                        ustring_to_String( OUSTR("set_") +
-                                           xAttribute->getMemberName() ),
-                        c_property_method_attr, 0, parameters );
-                // define parameter info
-                method_builder->DefineParameter(
-                    1 /* starts with 1 */, ParameterAttributes::In, S"value" );
-                //define UNO exception attribute (exceptions)--------------------------------------
-                Emit::CustomAttributeBuilder* attrBuilder =
-                    get_exception_attribute(xAttribute->getSetExceptions());
-                if (attrBuilder != NULL)
-                    method_builder->SetCustomAttribute(attrBuilder);
-                
-                property_builder->SetSetMethod( method_builder );
-            }
-        }
-    }
-    
-    // remove from incomplete types map
-    ::System::String * cts_name = type_builder->get_FullName();
-    m_incomplete_ifaces->Remove( cts_name );
-    xType->release();
-    
-    if (g_verbose)
-    {
-        ::System::Console::WriteLine(
-            "> emitting interface type {0}", cts_name );
-    }
-    return type_builder->CreateType();
+						new Emit::CustomAttributeBuilder(
+							__typeof(::uno::TypeArgumentsAttribute)
+							->GetConstructor( arCtor),
+							arArgs);
+
+					method_builder->SetCustomAttribute(attrBuilder);
+				}
+			}
+
+			//define UNO exception attribute (exceptions)--------------------------------------
+			Emit::CustomAttributeBuilder* attrBuilder =
+				get_iface_method_exception_attribute(xMethod);
+			if (attrBuilder != NULL)
+				method_builder->SetCustomAttribute(attrBuilder);
+
+			// oneway attribute
+			if (xMethod->isOneway())
+			{
+				::System::Type * arCtorOneway[] = new ::System::Type*[0];
+				::System::Object * arArgs[] = new ::System::Object*[0];
+				Emit::CustomAttributeBuilder * attrBuilder =
+					new Emit::CustomAttributeBuilder(
+						__typeof(::uno::OnewayAttribute)->GetConstructor( arCtorOneway),
+						arArgs);
+				method_builder->SetCustomAttribute(attrBuilder);
+			}
+		}
+		else // attribute
+		{
+			OSL_ASSERT(
+				TypeClass_INTERFACE_ATTRIBUTE == xMember->getTypeClass() );
+			Reference<
+				reflection::XInterfaceAttributeTypeDescription2 > xAttribute(
+					xMember, UNO_QUERY_THROW );
+
+			const MethodAttributes c_property_method_attr = (MethodAttributes)
+				(c_method_attr | MethodAttributes::SpecialName);
+
+			::System::Type * attribute_type = get_type( xAttribute->getType() );
+			::System::Type * parameters [] =
+				  new ::System::Type * [ 0 ];
+
+			Emit::PropertyBuilder * property_builder =
+				type_builder->DefineProperty(
+					ustring_to_String( xAttribute->getMemberName() ),
+					PropertyAttributes::None,
+					attribute_type, parameters );
+
+			//set BoundAttribute, if necessary
+			if (xAttribute->isBound())
+			{
+				ConstructorInfo * ctorBoundAttr =
+					__typeof(::uno::BoundAttribute)->GetConstructor(
+						new System::Type*[0]);
+				Emit::CustomAttributeBuilder * attrBuilderBound =
+					new Emit::CustomAttributeBuilder(
+						ctorBoundAttr, new ::System::Object*[0]);
+				property_builder->SetCustomAttribute(attrBuilderBound);
+			}
+
+			// getter
+			Emit::MethodBuilder * method_builder =
+				type_builder->DefineMethod(
+					ustring_to_String( OUSTR("get_") +
+									   xAttribute->getMemberName() ),
+					c_property_method_attr, attribute_type, parameters );
+
+			//define UNO exception attribute (exceptions)--------------------------------------
+			Emit::CustomAttributeBuilder* attrBuilder =
+				get_exception_attribute(xAttribute->getGetExceptions());
+			if (attrBuilder != NULL)
+				method_builder->SetCustomAttribute(attrBuilder);
+
+			property_builder->SetGetMethod( method_builder );
+
+			if (! xAttribute->isReadOnly())
+			{
+				// setter
+				parameters = new ::System::Type * [ 1 ];
+				parameters[ 0 ] = attribute_type;
+				method_builder =
+					type_builder->DefineMethod(
+						ustring_to_String( OUSTR("set_") +
+										   xAttribute->getMemberName() ),
+						c_property_method_attr, 0, parameters );
+				// define parameter info
+				method_builder->DefineParameter(
+					1 /* starts with 1 */, ParameterAttributes::In, S"value" );
+				//define UNO exception attribute (exceptions)--------------------------------------
+				Emit::CustomAttributeBuilder* attrBuilder =
+					get_exception_attribute(xAttribute->getSetExceptions());
+				if (attrBuilder != NULL)
+					method_builder->SetCustomAttribute(attrBuilder);
+
+				property_builder->SetSetMethod( method_builder );
+			}
+		}
+	}
+
+	// remove from incomplete types map
+	::System::String * cts_name = type_builder->get_FullName();
+	m_incomplete_ifaces->Remove( cts_name );
+	xType->release();
+
+	if (g_verbose)
+	{
+		::System::Console::WriteLine(
+			"> emitting interface type {0}", cts_name );
+	}
+	return type_builder->CreateType();
 }
 
 ::System::Type * TypeEmitter::complete_struct_type( struct_entry * entry )
 {
-     OSL_ASSERT(entry);   
-    ::System::String * cts_name = entry->m_type_builder->get_FullName();
+	 OSL_ASSERT(entry);
+	::System::String * cts_name = entry->m_type_builder->get_FullName();
+
+	//Polymorphic struct, define uno.TypeParametersAttribute
+	//A polymorphic struct cannot have a basetype.
+	//When we create the template of the struct then we have no exact types
+	//and the name does not contain a parameter list
+	Sequence< OUString > seq_type_parameters;
+	Reference< reflection::XStructTypeDescription> xStructTypeDesc(
+		entry->m_xType, UNO_QUERY);
+	if (xStructTypeDesc.is())
+	{
+		seq_type_parameters = xStructTypeDesc->getTypeParameters();
+		int numTypes = 0;
+		if ((numTypes = seq_type_parameters.getLength()) > 0)
+		{
+			::System::Object * aArg[] = new ::System::Object*[numTypes];
+			for (int i = 0; i < numTypes; i++)
+				aArg[i] = ustring_to_String(seq_type_parameters.getConstArray()[i]);
+			::System::Object * args[] = {aArg};
+
+			::System::Type * arTypesCtor[] =
+			{::System::Type::GetType(S"System.String[]")};
+			Emit::CustomAttributeBuilder * attrBuilder =
+				new Emit::CustomAttributeBuilder(
+				__typeof(::uno::TypeParametersAttribute)->GetConstructor(arTypesCtor),
+				args);
+			entry->m_type_builder->SetCustomAttribute(attrBuilder);
+		}
+	}
+
+	// optional: lookup base type whether generated entry of this session
+	struct_entry * base_type_entry = 0;
+	if (0 != entry->m_base_type)
+	{
+		//ToDo maybe get from incomplete structs
+		base_type_entry =
+			dynamic_cast< struct_entry * >(
+				m_generated_structs->get_Item(
+					entry->m_base_type->get_FullName() ) );
+	}
 
-    //Polymorphic struct, define uno.TypeParametersAttribute
-    //A polymorphic struct cannot have a basetype.
-    //When we create the template of the struct then we have no exact types
-    //and the name does not contain a parameter list
-    Sequence< OUString > seq_type_parameters;
-    Reference< reflection::XStructTypeDescription> xStructTypeDesc(
-        entry->m_xType, UNO_QUERY);
-    if (xStructTypeDesc.is())
-    {
-        seq_type_parameters = xStructTypeDesc->getTypeParameters();
-        int numTypes = 0;
-        if ((numTypes = seq_type_parameters.getLength()) > 0)
-        {
-            ::System::Object * aArg[] = new ::System::Object*[numTypes];
-            for (int i = 0; i < numTypes; i++)
-                aArg[i] = ustring_to_String(seq_type_parameters.getConstArray()[i]);
-            ::System::Object * args[] = {aArg};
-
-            ::System::Type * arTypesCtor[] =
-            {::System::Type::GetType(S"System.String[]")};
-            Emit::CustomAttributeBuilder * attrBuilder =
-                new Emit::CustomAttributeBuilder(
-                __typeof(::uno::TypeParametersAttribute)->GetConstructor(arTypesCtor),
-                args);
-            entry->m_type_builder->SetCustomAttribute(attrBuilder);                   
-        }
-    }
-
-    // optional: lookup base type whether generated entry of this session
-    struct_entry * base_type_entry = 0;
-    if (0 != entry->m_base_type)
-    {
-        //ToDo maybe get from incomplete structs
-        base_type_entry =
-            dynamic_cast< struct_entry * >(
-                m_generated_structs->get_Item(
-                    entry->m_base_type->get_FullName() ) );
-    }
-        
-        // members
-    Sequence< Reference< reflection::XTypeDescription > > seq_members(
-        entry->m_xType->getMemberTypes() );
-    Sequence< OUString > seq_member_names( entry->m_xType->getMemberNames() );
-    sal_Int32 members_length = seq_members.getLength();
-    OSL_ASSERT( seq_member_names.getLength() == members_length );
-	//check if we have a XTypeDescription for every member. If not then the user may 
+		// members
+	Sequence< Reference< reflection::XTypeDescription > > seq_members(
+		entry->m_xType->getMemberTypes() );
+	Sequence< OUString > seq_member_names( entry->m_xType->getMemberNames() );
+	sal_Int32 members_length = seq_members.getLength();
+	OSL_ASSERT( seq_member_names.getLength() == members_length );
+	//check if we have a XTypeDescription for every member. If not then the user may
 	//have forgotten to specify additional rdbs with the --extra option.
-    Reference< reflection::XTypeDescription > const * pseq_members =
-	        seq_members.getConstArray();
-    OUString const * pseq_member_names =
-        seq_member_names.getConstArray();
+	Reference< reflection::XTypeDescription > const * pseq_members =
+			seq_members.getConstArray();
+	OUString const * pseq_member_names =
+		seq_member_names.getConstArray();
 	for (int i = 0; i < members_length; i++)
 	{
 		const OUString sType(entry->m_xType->getName());
 		const OUString sMemberName(pseq_member_names[i]);
 		if ( ! pseq_members[i].is())
 			throw RuntimeException(OUSTR("Missing type description . Check if you need to " \
-			"specify additional RDBs with the --extra option. Type missing for: ") +  sType +
+			"specify additional RDBs with the --extra option. Type missing for: ") + sType +
 			OUSTR("::") + sMemberName,0);
 	}
-        
-    sal_Int32 all_members_length = 0;
-    sal_Int32 member_pos;
-    sal_Int32 type_param_pos = 0;
-    
-    // collect base types; wrong order
-    ::System::Collections::ArrayList * base_types_list =
-            new ::System::Collections::ArrayList( 3 /* initial capacity */ );
-    for (::System::Type * base_type_pos = entry->m_base_type;
-        ! base_type_pos->Equals( __typeof (::System::Object) );
-        base_type_pos = base_type_pos->get_BaseType() )
-    {
-        base_types_list->Add( base_type_pos );
-        if (base_type_pos->Equals( __typeof (::System::Exception) ))
-        {
-            // special Message member
-            all_members_length += 1;
-            break; // don't include System.Exception base classes
-        }
-        else
-        {
-            //ensure the base type is complete. Otherwise GetFields won't work
-            get_complete_struct(base_type_pos->get_FullName());
-            all_members_length +=
-                base_type_pos->GetFields(
-                (BindingFlags) (BindingFlags::Instance |
-                BindingFlags::Public |
-                BindingFlags::DeclaredOnly) )
-                ->get_Length();
-        }
-    }
-
-    // create all_members arrays; right order
-    ::System::String * all_member_names[] =
-        new ::System::String * [all_members_length + members_length ];
-    ::System::Type * all_param_types[] =
-        new ::System::Type * [all_members_length + members_length ];
-    member_pos = 0;
-    for ( sal_Int32 pos = base_types_list->get_Count(); pos--; )
-    {
-        ::System::Type * base_type = __try_cast< ::System::Type * >(
-            base_types_list->get_Item( pos ) );
-        if (base_type->Equals( __typeof (::System::Exception) ))
-        {
-            all_member_names[ member_pos ] = S"Message";
-            all_param_types[ member_pos ] = __typeof (::System::String);
-            ++member_pos;
-        }
-        else
-        {
-            ::System::String * base_type_name = base_type->get_FullName();
-
-            //ToDo m_generated_structs?
-            struct_entry * entry =
-                dynamic_cast< struct_entry * >(
-                m_generated_structs->get_Item( base_type_name ) );
-            if (0 == entry)
-            {
-                // complete type
-                FieldInfo * fields [] =
-                    base_type->GetFields(
-                    (BindingFlags) (BindingFlags::Instance |
-                    BindingFlags::Public |
-                    BindingFlags::DeclaredOnly) );
-                sal_Int32 len = fields->get_Length();
-                for ( sal_Int32 pos = 0; pos < len; ++pos )
-                {
-                    FieldInfo * field = fields[ pos ];
-                    all_member_names[ member_pos ] = field->get_Name();
-                    all_param_types[ member_pos ] = field->get_FieldType();
-                    ++member_pos;
-                }
-            }
-            else // generated during this session:
-                // members may be incomplete ifaces
-            {
-                sal_Int32 len = entry->m_member_names->get_Length();
-                for ( sal_Int32 pos = 0; pos < len; ++pos )
-                {
-                    all_member_names[ member_pos ] =
-                        entry->m_member_names[ pos ];
-                    all_param_types[ member_pos ] =
-                        entry->m_param_types[ pos ];
-                    ++member_pos;
-                }
-            }
-        }
-    }
-    OSL_ASSERT( all_members_length == member_pos );
-
-    // build up entry
-//    struct_entry * entry = new struct_entry();
-    entry->m_member_names = new ::System::String * [ members_length ];
-    entry->m_param_types = new ::System::Type * [ members_length ];
-
-    // add members
-    Emit::FieldBuilder * members[] = new Emit::FieldBuilder * [ members_length ];
-    //Reference< reflection::XTypeDescription > const * pseq_members =
-    //    seq_members.getConstArray();
-    //OUString const * pseq_member_names =
-    //    seq_member_names.getConstArray();
-
-    int curParamIndex = 0; //count the fields which have parameterized types
-    for ( member_pos = 0; member_pos < members_length; ++member_pos )
-    {
-        ::System::String * field_name =
-            ustring_to_String( pseq_member_names[ member_pos ] );
-        ::System::Type * field_type;
-        //Special handling of struct parameter types
-        bool bParameterizedType = false;
-        if (pseq_members[ member_pos ]->getTypeClass() == TypeClass_UNKNOWN)
-        {
-            bParameterizedType = true;
-            if (type_param_pos < seq_type_parameters.getLength())
-            {
-                field_type = __typeof(::System::Object);
-                type_param_pos++;
-            }
-            else
-            {
-                throw RuntimeException(
-                    OUSTR("unexpected member type in ") + entry->m_xType->getName(),
-                    Reference< XInterface >() );
-            }
-        }
-        else
-        {
-            field_type =
-                get_type( pseq_members[ member_pos ] );
-        }
-        members[ member_pos ] =
-            entry->m_type_builder->DefineField(
-            field_name, field_type, FieldAttributes::Public );
-
-        //parameterized type (polymorphic struct) ?
-        if (bParameterizedType && xStructTypeDesc.is())
-        {
-            //get the name
-            OSL_ASSERT(seq_type_parameters.getLength() > curParamIndex);
-            ::System::String* sTypeName = ustring_to_String(
-                seq_type_parameters.getConstArray()[curParamIndex++]);
-            ::System::Object * args[] = {sTypeName};
-            //set ParameterizedTypeAttribute
-            ::System::Type * arCtorTypes[] = {__typeof(::System::String)};
-
-            Emit::CustomAttributeBuilder * attrBuilder =
-                new Emit::CustomAttributeBuilder(
-                __typeof(::uno::ParameterizedTypeAttribute)
-                ->GetConstructor(arCtorTypes),
-                args);
-
-            members[member_pos]->SetCustomAttribute(attrBuilder);
-        }
-        // add to all_members
-        all_member_names[ all_members_length + member_pos ] = field_name;
-        all_param_types[ all_members_length + member_pos ] = field_type;
-        // add to entry
-        entry->m_member_names[ member_pos ] = field_name;
-        entry->m_param_types[ member_pos ] = field_type;
-    }
-    all_members_length += members_length;
-
-    // default .ctor
-    Emit::ConstructorBuilder * ctor_builder =
-        entry->m_type_builder->DefineConstructor(
-        c_ctor_method_attr, CallingConventions::Standard,
-        new ::System::Type * [ 0 ] );
-    Emit::ILGenerator * code = ctor_builder->GetILGenerator();
-    code->Emit( Emit::OpCodes::Ldarg_0 );
-    code->Emit(
-        Emit::OpCodes::Call,
-        0 == base_type_entry
-        ? entry->m_base_type->GetConstructor( new ::System::Type * [ 0 ] )
-        : base_type_entry->m_default_ctor );
-    // default initialize members
-    for ( member_pos = 0; member_pos < members_length; ++member_pos )
-    {
-        FieldInfo * field = members[ member_pos ];
-        ::System::Type * field_type = field->get_FieldType();
-        //            ::System::Type * new_field_type = m_module_builder->GetType(field_type->FullName, false);
-        // default initialize:
-        // string, type, enum, sequence, struct, exception, any
-        if (field_type->Equals( __typeof (::System::String) ))
-        {
-            code->Emit( Emit::OpCodes::Ldarg_0 );
-            code->Emit( Emit::OpCodes::Ldstr, S"" );
-            code->Emit( Emit::OpCodes::Stfld, field );
-        }
-        else if (field_type->Equals( __typeof (::System::Type) ))
-        {
-            code->Emit( Emit::OpCodes::Ldarg_0 );
-            code->Emit(
-                Emit::OpCodes::Ldtoken, __typeof (::System::Void) );
-            code->Emit(
-                Emit::OpCodes::Call, m_method_info_Type_GetTypeFromHandle );
-            code->Emit( Emit::OpCodes::Stfld, field );
-        }
-        else if (field_type->get_IsArray())
-        {
-            //Find the value type. In case of sequence<sequence< ... > > find the actual value type
-            ::System::Type * value = field_type;
-            while ((value = value->GetElementType())->get_IsArray());
-            //If the value type is a struct then make sure it is fully created.
-            get_complete_struct(value->get_FullName());
-
-            code->Emit( Emit::OpCodes::Ldarg_0 );
-            code->Emit( Emit::OpCodes::Ldc_I4_0 );
-            code->Emit(
-                Emit::OpCodes::Newarr, field_type->GetElementType() );
-            code->Emit( Emit::OpCodes::Stfld, field );
-        }
-        else if (field_type->get_IsValueType())
-        {
-            if (field_type->get_FullName()->Equals( S"uno.Any" ))
-            {
-                code->Emit( Emit::OpCodes::Ldarg_0 );
-                code->Emit( Emit::OpCodes::Ldsfld, __typeof(::uno::Any)->GetField(S"VOID"));
-                code->Emit( Emit::OpCodes::Stfld, field );
-            }
-        }
-        else if (field_type->get_IsClass())
-        {
-            /* may be XInterface */
-            if (! field_type->Equals( __typeof (::System::Object) ))
-            {
-                // struct, exception
-                //make sure the struct is already complete.
-                get_complete_struct(field_type->get_FullName());
-                code->Emit( Emit::OpCodes::Ldarg_0 );
-                code->Emit(
-                    Emit::OpCodes::Newobj,

[... 1801 lines stripped ...]


Mime
View raw message