LibreOffice Module cli_ure (master) 1
climaker_emit.cxx
Go to the documentation of this file.
1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20#include "climaker_share.h"
21
22#include "rtl/string.hxx"
23#include "rtl/ustrbuf.hxx"
24#include "com/sun/star/reflection/XIndirectTypeDescription.hpp"
25#include "com/sun/star/reflection/XStructTypeDescription.hpp"
26#include "com/sun/star/reflection/XInterfaceTypeDescription2.hpp"
27#include "com/sun/star/reflection/XInterfaceMethodTypeDescription.hpp"
28#include "com/sun/star/reflection/XInterfaceAttributeTypeDescription.hpp"
29#include "com/sun/star/reflection/XInterfaceAttributeTypeDescription2.hpp"
30#include <vector>
31
32using namespace ::System::Reflection;
33
34using namespace ::com::sun::star;
35using namespace ::com::sun::star::uno;
36
37namespace climaker
38{
39System::String^ mapUnoPolymorphicName(System::String^ unoName);
40
41static inline ::System::String ^ to_cts_name(
42 OUString const & uno_name )
43{
44 return ustring_to_String("unoidl." + uno_name);
45}
46
47
48static inline ::System::Object ^ to_cli_constant( Any const & value )
49{
50 switch (value.getValueTypeClass())
51 {
52 case TypeClass_CHAR:
53 return ((::System::Char) *reinterpret_cast< sal_Unicode const * >(
54 value.getValue() ));
55 case TypeClass_BOOLEAN:
56 return ((::System::Boolean)
57 sal_False != *reinterpret_cast< sal_Bool const * >(
58 value.getValue() ));
59 case TypeClass_BYTE:
60 return ((::System::Byte) *reinterpret_cast< sal_Int8 const * >(
61 value.getValue() ));
62 case TypeClass_SHORT:
63 return ((::System::Int16) *reinterpret_cast< sal_Int16 const * >(
64 value.getValue() ));
65 case TypeClass_UNSIGNED_SHORT:
66 return ((::System::UInt16) *reinterpret_cast< sal_uInt16 const * >(
67 value.getValue() ));
68 case TypeClass_LONG:
69 return ((::System::Int32) *reinterpret_cast< sal_Int32 const * >(
70 value.getValue() ));
71 case TypeClass_UNSIGNED_LONG:
72 return ((::System::UInt32) *reinterpret_cast< sal_uInt32 const * >(
73 value.getValue() ));
74 case TypeClass_HYPER:
75 return ((::System::Int64) *reinterpret_cast< sal_Int64 const * >(
76 value.getValue() ));
77 case TypeClass_UNSIGNED_HYPER:
78 return ((::System::UInt64) *reinterpret_cast< sal_uInt64 const * >(
79 value.getValue() ));
80 case TypeClass_FLOAT:
81 return ((::System::Single) *reinterpret_cast< float const * >(
82 value.getValue() ));
83 case TypeClass_DOUBLE:
84 return ((::System::Double) *reinterpret_cast< double const * >(
85 value.getValue() ));
86 default:
87 throw RuntimeException(
88 "unexpected constant type " +
89 value.getValueType().getTypeName() );
90 }
91}
92
93
94static inline void emit_ldarg( Emit::ILGenerator ^ code, ::System::Int32 index )
95{
96 switch (index)
97 {
98 case 0:
99#pragma warning (push)
100#pragma warning (disable: 4538) // const/volatile qualifiers on this type are not supported
101 code->Emit( Emit::OpCodes::Ldarg_0 );
102#pragma warning (pop)
103 break;
104 case 1:
105 code->Emit( Emit::OpCodes::Ldarg_1 );
106 break;
107 case 2:
108 code->Emit( Emit::OpCodes::Ldarg_2 );
109 break;
110 case 3:
111 code->Emit( Emit::OpCodes::Ldarg_3 );
112 break;
113 default:
114 if (index < 0x100)
115 code->Emit( Emit::OpCodes::Ldarg_S, (::System::Byte) index );
116 else if (index < 0x8000)
117 code->Emit( Emit::OpCodes::Ldarg_S, (::System::Int16) index );
118 else
119 code->Emit( Emit::OpCodes::Ldarg, index );
120 break;
121 }
122}
123
124void polymorphicStructNameToStructName(::System::String ^* sPolyName)
125{
126 if ((*sPolyName)->EndsWith(">") == false)
127 return;
128
129 int index = (*sPolyName)->IndexOf('<');
130 OSL_ASSERT(index != -1);
131 *sPolyName = (*sPolyName)->Substring(0, index);
132}
133
134
135System::String^ mapUnoTypeName(System::String ^ typeName)
136{
137 ::System::Text::StringBuilder^ buf= gcnew System::Text::StringBuilder();
138 ::System::String ^ sUnoName = ::System::String::Copy(typeName);
139 //determine if the type is a sequence and its dimensions
140 int dims= 0;
141 if (typeName->StartsWith("["))//if (usUnoName[0] == '[')
142 {
143 int index= 1;
144 while (true)
145 {
146 if (typeName[index++] == ']')//if (usUnoName[index++] == ']')
147 dims++;
148 if (typeName[index++] != '[')//usUnoName[index++] != '[')
149 break;
150 }
151 sUnoName = sUnoName->Substring(index - 1);//usUnoName = usUnoName.copy(index - 1);
152 }
153 if (sUnoName->Equals(const_cast<System::String^>(Constants::sUnoBool)))
154 buf->Append(const_cast<System::String^>(Constants::sBoolean));
155 else if (sUnoName->Equals(const_cast<System::String^>(Constants::sUnoChar)))
156 buf->Append(const_cast<System::String^>(Constants::sChar));
157 else if (sUnoName->Equals(const_cast<System::String^>(Constants::sUnoByte)))
158 buf->Append(const_cast<System::String^>(Constants::sByte));
159 else if (sUnoName->Equals(const_cast<System::String^>(Constants::sUnoShort)))
160 buf->Append(const_cast<System::String^>(Constants::sInt16));
161 else if (sUnoName->Equals(const_cast<System::String^>(Constants::sUnoUShort)))
162 buf->Append(const_cast<System::String^>(Constants::sUInt16));
163 else if (sUnoName->Equals(const_cast<System::String^>(Constants::sUnoLong)))
164 buf->Append(const_cast<System::String^>(Constants::sInt32));
165 else if (sUnoName->Equals(const_cast<System::String^>(Constants::sUnoULong)))
166 buf->Append(const_cast<System::String^>(Constants::sUInt32));
167 else if (sUnoName->Equals(const_cast<System::String^>(Constants::sUnoHyper)))
168 buf->Append(const_cast<System::String^>(Constants::sInt64));
169 else if (sUnoName->Equals(const_cast<System::String^>(Constants::sUnoUHyper)))
170 buf->Append(const_cast<System::String^>(Constants::sUInt64));
171 else if (sUnoName->Equals(const_cast<System::String^>(Constants::sUnoFloat)))
172 buf->Append(const_cast<System::String^>(Constants::sSingle));
173 else if (sUnoName->Equals(const_cast<System::String^>(Constants::sUnoDouble)))
174 buf->Append(const_cast<System::String^>(Constants::sDouble));
175 else if (sUnoName->Equals(const_cast<System::String^>(Constants::sUnoString)))
176 buf->Append(const_cast<System::String^>(Constants::sString));
177 else if (sUnoName->Equals(const_cast<System::String^>(Constants::sUnoVoid)))
178 buf->Append(const_cast<System::String^>(Constants::sVoid));
179 else if (sUnoName->Equals(const_cast<System::String^>(Constants::sUnoType)))
180 buf->Append(const_cast<System::String^>(Constants::sType));
181 else if (sUnoName->Equals(const_cast<System::String^>(Constants::sUnoXInterface)))
182 buf->Append(const_cast<System::String^>(Constants::sObject));
183 else if (sUnoName->Equals(const_cast<System::String^>(Constants::sUnoAny)))
184 {
185 buf->Append(const_cast<System::String^>(Constants::sAny));
186 }
187 else
188 {
189 //put "unoidl." at the beginning
190 buf->Append(const_cast<System::String^>(Constants::sUnoidl));
191 buf->Append(mapUnoPolymorphicName(sUnoName));
192 }
193 // append []
194 for (;dims--;)
195 buf->Append(const_cast<System::String^>(Constants::sBrackets));
196
197 return buf->ToString();
198}
199
200
210System::String^ mapUnoPolymorphicName(System::String^ unoName)
211{
212 int index = unoName->IndexOf('<');
213 if (index == -1)
214 return unoName;
215
216 System::Text::StringBuilder ^ builder =
217 gcnew System::Text::StringBuilder(unoName->Substring(0, index +1 ));
218
219 //Find the first occurrence of ','
220 //If the parameter is a polymorphic struct then we need to ignore everything
221 //between the brackets because it can also contain commas
222 //get the type list within < and >
223 int endIndex = unoName->Length - 1;
224 index++;
225 int cur = index;
226 int countParams = 0;
227 while (cur <= endIndex)
228 {
229 System::Char c = unoName[cur];
230 if (c == ',' || c == '>')
231 {
232 //insert a comma if needed
233 if (countParams != 0)
234 builder->Append(",");
235 countParams++;
236 System::String ^ sParam = unoName->Substring(index, cur - index);
237 //skip the comma
238 cur++;
239 //the index to the beginning of the next param
240 index = cur;
241 builder->Append(mapUnoTypeName(sParam));
242 }
243 else if (c == '<')
244 {
245 cur++;
246 //continue until the matching '>'
247 int numNested = 0;
248 for (;;cur++)
249 {
250 System::Char curChar = unoName[cur];
251 if (curChar == '<')
252 {
253 numNested ++;
254 }
255 else if (curChar == '>')
256 {
257 if (numNested > 0)
258 numNested--;
259 else
260 break;
261 }
262 }
263 }
264 cur++;
265 }
266
267 builder->Append((System::Char) '>');
268 return builder->ToString();
269}
270
271
272Assembly ^ TypeEmitter::type_resolve(
273 ::System::Object ^, ::System::ResolveEventArgs ^ args )
274{
275 ::System::String ^ cts_name = args->Name;
276 ::System::Type ^ ret_type = nullptr;
277
278 iface_entry ^ entry = dynamic_cast< iface_entry ^ >(m_incomplete_ifaces[cts_name] );
279 if (nullptr != entry)
280 ret_type = entry->m_type_builder;
281
282 if (nullptr == ret_type)
283 {
284 sal_Int32 len = m_extra_assemblies->Length;
285 for ( sal_Int32 pos = 0; pos < len; ++pos )
286 {
287 ret_type = m_extra_assemblies[ pos ]->GetType(
288 cts_name, false /* no exc */ );
289 if (nullptr != ret_type)
290 {
291 if (g_bVerbose)
292 {
293 ::System::Console::WriteLine(
294 "> resolving type {0} from {1}.",
295 cts_name, ret_type->Assembly->FullName );
296 }
297 break;
298 }
299 }
300 }
301 if (nullptr != ret_type)
302 return ret_type->Assembly;
303 return nullptr;
304}
305
306
307::System::Type ^ TypeEmitter::get_type(
308 ::System::String ^ cts_name, bool throw_exc )
309{
310 ::System::Type ^ ret_type = m_module_builder->GetType( cts_name, false );
311 //We get the type from the ModuleBuilder even if the type is not complete
312 //but have been defined.
313 //if (ret_type == 0)
314 //{
315 // iface_entry * entry = dynamic_cast< iface_entry * >(
316 // m_incomplete_ifaces->get_Item( cts_name ) );
317 // if (0 != entry)
318 // ret_type = entry->m_type_builder;
319 //}
320 //try the cli_basetypes assembly
321 if (ret_type == nullptr)
322 {
323 ::System::Text::StringBuilder ^ builder = gcnew ::System::Text::StringBuilder(cts_name);
324 builder->Append(",cli_basetypes");
325 ret_type = ::System::Type::GetType(builder->ToString());
326 }
327
328 if (ret_type == nullptr)
329 {
330 try
331 {
332 // may call on type_resolve()
333 return ::System::Type::GetType( cts_name, throw_exc );
334 }
335 catch (::System::Exception^ exc)
336 {
337 //If the type is not found one may have forgotten to specify assemblies with
338 //additional types
339 ::System::Text::StringBuilder ^ sb = gcnew ::System::Text::StringBuilder();
340 sb->Append(gcnew ::System::String("\nThe type "));
341 sb->Append(cts_name);
342 sb->Append(gcnew ::System::String(" \n could not be found. Did you forget to "
343 "specify an additional assembly with the --reference option?\n"));
344 if (throw_exc)
345 throw gcnew ::System::Exception(sb->ToString(), exc);
346 }
347 }
348 else
349 {
350 return ret_type;
351 }
352}
353
354
355::System::Type ^ TypeEmitter::get_type_Exception()
356{
357 if (nullptr == m_type_Exception)
358 {
359 m_type_Exception = get_type(
360 "unoidl.com.sun.star.uno.Exception", false /* no exc */ );
361 if (nullptr == m_type_Exception)
362 {
363 // define hardcoded type unoidl.com.sun.star.uno.Exception
364 Emit::TypeBuilder ^ type_builder =
365 m_module_builder->DefineType(
366 "unoidl.com.sun.star.uno.Exception",
367 (TypeAttributes) (TypeAttributes::Public |
368 TypeAttributes::BeforeFieldInit |
369 TypeAttributes::AnsiClass),
370 (::System::Exception::typeid) );
371 Emit::FieldBuilder ^ field_Context = type_builder->DefineField(
372 "Context", (::System::Object::typeid),
373 FieldAttributes::Public );
374 // default .ctor
375 type_builder->DefineDefaultConstructor( c_ctor_method_attr );
376 // .ctor
377 array< ::System::Type^>^ param_types =
378 gcnew array< ::System::Type^>(2);
379 param_types[ 0 ] = ::System::String::typeid;
380 param_types[ 1 ] = ::System::Object::typeid;
381 Emit::ConstructorBuilder ^ ctor_builder =
382 type_builder->DefineConstructor(
383 c_ctor_method_attr, CallingConventions::Standard,
384 param_types );
385 ctor_builder->DefineParameter(
386 1, ParameterAttributes::In, "Message" );
387 ctor_builder->DefineParameter(
388 2, ParameterAttributes::In, "Context" );
389 Emit::ILGenerator ^ code = ctor_builder->GetILGenerator();
390 code->Emit( Emit::OpCodes::Ldarg_0 );
391 code->Emit( Emit::OpCodes::Ldarg_1 );
392 param_types = gcnew array< ::System::Type^>(1);
393 param_types[ 0 ] = ::System::String::typeid;
394 code->Emit(
395 Emit::OpCodes::Call,
396 (::System::Exception::typeid)
397 ->GetConstructor( param_types ) );
398 code->Emit( Emit::OpCodes::Ldarg_0 );
399 code->Emit( Emit::OpCodes::Ldarg_2 );
400 code->Emit( Emit::OpCodes::Stfld, field_Context );
401 code->Emit( Emit::OpCodes::Ret );
402
403 if (g_bVerbose)
404 {
405 ::System::Console::WriteLine(
406 "> emitting exception type "
407 "unoidl.com.sun.star.uno.Exception" );
408 }
409 m_type_Exception = type_builder->CreateType();
410 }
411 }
412 return m_type_Exception;
413}
414
415
416::System::Type ^ TypeEmitter::get_type_RuntimeException()
417{
418 if (nullptr == m_type_RuntimeException)
419 {
420 m_type_RuntimeException = get_type(
421 "unoidl.com.sun.star.uno.RuntimeException", false /* no exc */ );
422 if (nullptr == m_type_RuntimeException)
423 {
424 // define hardcoded type unoidl.com.sun.star.uno.RuntimeException
425 ::System::Type ^ type_Exception = get_type_Exception();
426 Emit::TypeBuilder ^ type_builder =
427 m_module_builder->DefineType(
428 "unoidl.com.sun.star.uno.RuntimeException",
429 (TypeAttributes) (TypeAttributes::Public |
430 TypeAttributes::BeforeFieldInit |
431 TypeAttributes::AnsiClass),
432 type_Exception );
433 // default .ctor
434 type_builder->DefineDefaultConstructor( c_ctor_method_attr );
435 // .ctor
436 array< ::System::Type^>^ param_types =
437 gcnew array< ::System::Type^>(2);
438 param_types[ 0 ] = ::System::String::typeid;
439 param_types[ 1 ] = ::System::Object::typeid;
440 Emit::ConstructorBuilder ^ ctor_builder =
441 type_builder->DefineConstructor(
442 c_ctor_method_attr, CallingConventions::Standard,
443 param_types );
444 ctor_builder->DefineParameter(
445 1, ParameterAttributes::In, "Message" );
446 ctor_builder->DefineParameter(
447 2, ParameterAttributes::In, "Context" );
448 Emit::ILGenerator ^ code = ctor_builder->GetILGenerator();
449 code->Emit( Emit::OpCodes::Ldarg_0 );
450 code->Emit( Emit::OpCodes::Ldarg_1 );
451 code->Emit( Emit::OpCodes::Ldarg_2 );
452 code->Emit(
453 Emit::OpCodes::Call,
454 type_Exception->GetConstructor( param_types ) );
455 code->Emit( Emit::OpCodes::Ret );
456
457 if (g_bVerbose)
458 {
459 ::System::Console::WriteLine(
460 "> emitting exception type "
461 "unoidl.com.sun.star.uno.RuntimeException" );
462 }
463 m_type_RuntimeException = type_builder->CreateType();
464 }
465 }
466 return m_type_RuntimeException;
467}
468
469
470::System::Type ^ TypeEmitter::get_type(
471 Reference< reflection::XConstantTypeDescription > const & xType )
472{
473 ::System::String ^ cts_name = to_cts_name( xType->getName() );
474 ::System::Type ^ ret_type = get_type( cts_name, false /* no exc */ );
475 if (nullptr == ret_type)
476 {
477 Reference< reflection::XConstantTypeDescription > xConstant(
478 xType, UNO_SET_THROW );
479 ::System::Object ^ constant =
480 to_cli_constant( xConstant->getConstantValue() );
481 Emit::TypeBuilder ^ type_builder =
482 m_module_builder->DefineType(
483 cts_name,
484 (TypeAttributes) (TypeAttributes::Public |
485 TypeAttributes::Sealed |
486 TypeAttributes::BeforeFieldInit |
487 TypeAttributes::AnsiClass) );
488
489 Emit::FieldBuilder ^ field_builder = type_builder->DefineField(
490 cts_name->Substring( cts_name->LastIndexOf( '.' ) +1 ),
491 constant->GetType(),
492 (FieldAttributes) (FieldAttributes::Public |
493 FieldAttributes::Static |
494 FieldAttributes::Literal) );
495 field_builder->SetConstant( constant );
496
497 if (g_bVerbose)
498 {
499 ::System::Console::WriteLine(
500 "> emitting constant type {0}", cts_name );
501 }
502 ret_type = type_builder->CreateType();
503 }
504 return ret_type;
505}
506
507
508::System::Type ^ TypeEmitter::get_type(
509 Reference< reflection::XConstantsTypeDescription > const & xType )
510{
511 ::System::String ^ cts_name = to_cts_name( xType->getName() );
512 ::System::Type ^ ret_type = get_type( cts_name, false /* no exc */ );
513 if (nullptr == ret_type)
514 {
515 Emit::TypeBuilder ^ type_builder =
516 m_module_builder->DefineType(
517 cts_name,
518 (TypeAttributes) (TypeAttributes::Public |
519 TypeAttributes::Sealed |
520 TypeAttributes::BeforeFieldInit |
521 TypeAttributes::AnsiClass) );
522
523 Sequence< Reference<
524 reflection::XConstantTypeDescription > > seq_constants(
525 xType->getConstants() );
526 Reference< reflection::XConstantTypeDescription > const * constants =
527 seq_constants.getConstArray();
528 sal_Int32 constants_length = seq_constants.getLength();
529 for ( sal_Int32 constants_pos = 0;
530 constants_pos < constants_length; ++constants_pos )
531 {
532 Reference<
533 reflection::XConstantTypeDescription > const & xConstant =
534 constants[ constants_pos ];
535 ::System::Object ^ constant =
536 to_cli_constant( xConstant->getConstantValue() );
537 ::System::String ^ uno_name =
538 ustring_to_String( xConstant->getName() );
539 Emit::FieldBuilder ^ field_builder = type_builder->DefineField(
540 uno_name->Substring( uno_name->LastIndexOf( '.' ) +1 ),
541 constant->GetType(),
542 (FieldAttributes) (FieldAttributes::Public |
543 FieldAttributes::Static |
544 FieldAttributes::Literal) );
545 field_builder->SetConstant( constant );
546 }
547
548 if (g_bVerbose)
549 {
550 ::System::Console::WriteLine(
551 "> emitting constants group type {0}", cts_name );
552 }
553 ret_type = type_builder->CreateType();
554 }
555 return ret_type;
556}
557
558
559::System::Type ^ TypeEmitter::get_type(
560 Reference< reflection::XEnumTypeDescription > const & xType )
561{
562 ::System::String ^ cts_name = to_cts_name( xType->getName() );
563 ::System::Type ^ ret_type = get_type( cts_name, false /* no exc */ );
564 if (nullptr == ret_type)
565 {
566 // workaround enum builder bug
567 Emit::TypeBuilder ^ enum_builder =
568 m_module_builder->DefineType(
569 cts_name,
570 (TypeAttributes) (TypeAttributes::Public |
571 TypeAttributes::Sealed),
572 ::System::Enum::typeid );
573 enum_builder->DefineField(
574 "value__", ::System::Int32::typeid,
575 (FieldAttributes) (FieldAttributes::Private |
576 FieldAttributes::SpecialName |
577 FieldAttributes::RTSpecialName) );
578 Sequence< OUString > seq_enum_names( xType->getEnumNames() );
579 Sequence< sal_Int32 > seq_enum_values( xType->getEnumValues() );
580 sal_Int32 enum_length = seq_enum_names.getLength();
581 OSL_ASSERT( enum_length == seq_enum_values.getLength() );
582 OUString const * enum_names = seq_enum_names.getConstArray();
583 sal_Int32 const * enum_values = seq_enum_values.getConstArray();
584 for ( sal_Int32 enum_pos = 0; enum_pos < enum_length; ++enum_pos )
585 {
586// enum_builder->DefineLiteral(
587// ustring_to_String( enum_names[ enum_pos ] ),
588// __box ((::System::Int32) enum_values[ enum_pos ]) );
589 Emit::FieldBuilder ^ field_builder =
590 enum_builder->DefineField(
591 ustring_to_String( enum_names[ enum_pos ] ),
592 enum_builder,
593 (FieldAttributes) (FieldAttributes::Public |
594 FieldAttributes::Static |
595 FieldAttributes::Literal) );
596 field_builder->SetConstant(
597 ((::System::Int32) enum_values[ enum_pos ]) );
598 }
599
600 if (g_bVerbose)
601 {
602 ::System::Console::WriteLine(
603 "> emitting enum type {0}", cts_name );
604 }
605 ret_type = enum_builder->CreateType();
606 }
607 return ret_type;
608}
609
610
611::System::Type ^ TypeEmitter::get_type(
612 Reference< reflection::XCompoundTypeDescription > const & xType )
613{
614 OUString uno_name( xType->getName() );
615 if (TypeClass_EXCEPTION == xType->getTypeClass())
616 {
617 if ( uno_name == "com.sun.star.uno.Exception" )
618 {
619 return get_type_Exception();
620 }
621 if ( uno_name == "com.sun.star.uno.RuntimeException" )
622 {
623 return get_type_RuntimeException();
624 }
625 }
626 ::System::String ^ cts_name = to_cts_name( uno_name );
627 // if the struct is an instantiated polymorphic struct then we create the simple struct name
628 // For example:
629 // void func ([in] PolyStruct<boolean> arg);
630 //PolyStruct<boolean> will be converted to PolyStruct
631 polymorphicStructNameToStructName( & cts_name);
632
633 ::System::Type ^ ret_type = get_type( cts_name, false /* no exc */ );
634 if (nullptr == ret_type)
635 {
636 Reference< reflection::XCompoundTypeDescription > xBaseType(
637 xType->getBaseType(), UNO_QUERY );
638 ::System::Type ^ base_type = (xBaseType.is()
639 ? get_type( xBaseType )
640 : ::System::Object::typeid);
641 Emit::TypeBuilder ^ type_builder =
642 m_module_builder->DefineType(
643 cts_name,
644 (TypeAttributes) (TypeAttributes::Public |
645 TypeAttributes::BeforeFieldInit |
646 TypeAttributes::AnsiClass),
647 base_type );
648
649
650 // insert to be completed
651 struct_entry ^ entry = gcnew struct_entry();
652 xType->acquire();
653 entry->m_xType = xType.get();
654 entry->m_type_builder = type_builder;
655 entry->m_base_type = base_type;
656 m_incomplete_structs->Add( cts_name, entry );
657
658 // type is incomplete
659 ret_type = type_builder;
660 }
661
662 //In case of an instantiated polymorphic struct we want to return a
663 //uno.PolymorphicType (inherits Type) rather than Type. This is needed for constructing
664 //the service code. We can only do that if the struct is completed.
665 if (m_generated_structs[cts_name])
666 {
667 Reference< reflection::XStructTypeDescription> xStructTypeDesc(
668 xType, UNO_QUERY);
669
670 if (xStructTypeDesc.is())
671 {
672 Sequence< Reference< reflection::XTypeDescription > > seqTypeArgs = xStructTypeDesc->getTypeArguments();
673 sal_Int32 numTypes = seqTypeArgs.getLength();
674 if (numTypes > 0)
675 {
676 //it is an instantiated polymorphic struct
677 ::System::String ^ sCliName = mapUnoTypeName(ustring_to_String(xType->getName()));
678 ret_type = ::uno::PolymorphicType::GetType(ret_type, sCliName);
679 }
680 }
681 }
682 return ret_type;
683}
684
685
686::System::Type ^ TypeEmitter::get_type(
687 Reference< reflection::XInterfaceTypeDescription2 > const & xType )
688{
689 OUString uno_name( xType->getName() );
690 if ( uno_name == "com.sun.star.uno.XInterface" )
691 {
692 return ::System::Object::typeid;
693 }
694
695 ::System::String ^ cts_name = to_cts_name( xType->getName() );
696 ::System::Type ^ ret_type = get_type( cts_name, false /* no exc */ );
697 if (nullptr == ret_type)
698 {
699 Emit::TypeBuilder ^ type_builder;
700
701 TypeAttributes attr = (TypeAttributes) (TypeAttributes::Public |
702 TypeAttributes::Interface |
703 TypeAttributes::Abstract |
704 TypeAttributes::AnsiClass);
705
706 std::vector<Reference<reflection::XInterfaceTypeDescription2> > vecBaseTypes;
707 Sequence<Reference< reflection::XTypeDescription > > seqBaseTypes =
708 xType->getBaseTypes();
709 if (seqBaseTypes.getLength() > 0)
710 {
711 for (int i = 0; i < seqBaseTypes.getLength(); i++)
712 {
713 Reference<reflection::XInterfaceTypeDescription2> xIfaceTd =
714 resolveInterfaceTypedef(seqBaseTypes[i]);
715
716 if ( xIfaceTd->getName() != "com.sun.star.uno.XInterface" )
717 {
718 vecBaseTypes.push_back(xIfaceTd);
719 }
720 }
721
722 array< ::System::Type^>^ base_interfaces =
723 gcnew array< ::System::Type^>( vecBaseTypes.size() );
724
725 int index = 0;
726 for (auto const & vecBaseType : vecBaseTypes)
727 {
728 base_interfaces[ index ] = get_type( vecBaseType );
729 ++index;
730 }
731 type_builder = m_module_builder->DefineType(
732 cts_name, attr, nullptr, base_interfaces );
733 }
734 else
735 {
736 ::System::Console::WriteLine(
737 "warning: IDL interface {0} is not derived from "
738 "com.sun.star.uno.XInterface!",
739 ustring_to_String( uno_name ) );
740
741 type_builder = m_module_builder->DefineType( cts_name, attr );
742 }
743
744 // insert to be completed
745 iface_entry ^ entry = gcnew iface_entry();
746 xType->acquire();
747 entry->m_xType = xType.get();
748 entry->m_type_builder = type_builder;
749 m_incomplete_ifaces->Add( cts_name, entry );
750
751 // type is incomplete
752 ret_type = type_builder;
753 }
754 return ret_type;
755}
756
757
758::System::Type ^ TypeEmitter::get_type(
759 Reference< reflection::XServiceTypeDescription2 > const & xType )
760{
761 if (xType->isSingleInterfaceBased() == sal_False)
762 return nullptr;
763
764 System::String ^ cts_name = to_cts_name( xType->getName() );
765 System::Type ^ ret_type = get_type( cts_name, false /* no exc */ );
766 if (ret_type != nullptr)
767 return ret_type;
768
769 TypeAttributes attr = (TypeAttributes) (TypeAttributes::Public |
770 TypeAttributes::Sealed |
771 TypeAttributes::BeforeFieldInit |
772 TypeAttributes::AnsiClass);
773
774 Emit::TypeBuilder ^ type_builder = m_module_builder->DefineType(
775 cts_name, attr);
776
777 // insert to be completed
778 service_entry ^ entry = gcnew service_entry();
779 xType->acquire();
780 entry->m_xType = xType.get();
781 entry->m_type_builder = type_builder;
782 m_incomplete_services->Add(cts_name,entry );
783
784 return type_builder;
785}
786
787::System::Type ^ TypeEmitter::get_type(
788 Reference<reflection::XSingletonTypeDescription2 > const & xType )
789{
790 if (xType->isInterfaceBased() == sal_False)
791 return nullptr;
792
793 ::System::String^ cts_name = to_cts_name( xType->getName() );
794 ::System::Type ^ ret_type = get_type( cts_name, false /* no exc */ );
795 if (ret_type != nullptr)
796 return ret_type;
797
798 TypeAttributes attr = static_cast<TypeAttributes>(
799 TypeAttributes::Public |
800 TypeAttributes::Sealed |
801 TypeAttributes::BeforeFieldInit |
802 TypeAttributes::AnsiClass);
803
804 Emit::TypeBuilder ^ type_builder = m_module_builder->DefineType(
805 cts_name, attr);
806
807 // insert to be completed
808 singleton_entry ^ entry = gcnew singleton_entry();
809 xType->acquire();
810 entry->m_xType = xType.get();
811 entry->m_type_builder = type_builder;
812 m_incomplete_singletons->Add(cts_name,entry );
813
814 return type_builder;
815
816}
817
818
819::System::Type ^ TypeEmitter::complete_iface_type( iface_entry ^ entry )
820{
821 Emit::TypeBuilder ^ type_builder = entry->m_type_builder;
822 reflection::XInterfaceTypeDescription2 * xType = entry->m_xType;
823
824 Sequence<Reference< reflection::XTypeDescription > > seqBaseTypes( xType->getBaseTypes() );
825 if (seqBaseTypes.getLength() > 0)
826 {
827 for (int i = 0; i < seqBaseTypes.getLength(); i++)
828 {
829 //make sure we get the interface rather than a typedef
830 Reference<reflection::XInterfaceTypeDescription2> aBaseType =
831 resolveInterfaceTypedef( seqBaseTypes[i]);
832
833 if ( aBaseType->getName() != "com.sun.star.uno.XInterface" )
834 {
835 ::System::String ^ basetype_name = to_cts_name( aBaseType->getName() );
836 iface_entry ^ base_entry = dynamic_cast< iface_entry ^ >(
837 m_incomplete_ifaces[basetype_name] );
838 if (nullptr != base_entry)
839 {
840 // complete uncompleted base type first
841 complete_iface_type( base_entry );
842 }
843 }
844 }
845 }
846
847 Sequence<
848 Reference< reflection::XInterfaceMemberTypeDescription > > seq_members(
849 xType->getMembers() );
850 Reference< reflection::XInterfaceMemberTypeDescription > const * members =
851 seq_members.getConstArray();
852 sal_Int32 members_length = seq_members.getLength();
853 for ( sal_Int32 members_pos = 0;
854 members_pos < members_length; ++members_pos )
855 {
856 Reference<
857 reflection::XInterfaceMemberTypeDescription > const & xMember =
858 members[ members_pos ];
859 Sequence< Reference< reflection::XTypeDescription > > seq_exceptions;
860 Emit::MethodBuilder ^ method_builder;
861
862 MethodAttributes c_method_attr = (MethodAttributes)
863 (MethodAttributes::Public |
864 MethodAttributes::Abstract |
865 MethodAttributes::Virtual |
866 MethodAttributes::NewSlot |
867 MethodAttributes::HideBySig);
868
869 if (TypeClass_INTERFACE_METHOD == xMember->getTypeClass())
870 {
871 Reference< reflection::XInterfaceMethodTypeDescription > xMethod(
872 xMember, UNO_QUERY_THROW );
873
874 Sequence<
875 Reference< reflection::XMethodParameter > > seq_parameters(
876 xMethod->getParameters() );
877 sal_Int32 params_length = seq_parameters.getLength();
878 array< ::System::Type^>^ param_types =
879 gcnew array< ::System::Type^>( params_length );
880 Reference< reflection::XMethodParameter > const * parameters =
881 seq_parameters.getConstArray();
882 // first determine all types
883 //Make the first param type as return type
884 sal_Int32 params_pos = 0;
885 for ( ; params_pos < params_length; ++params_pos )
886 {
887 Reference< reflection::XMethodParameter > const & xParam =
888 parameters[ params_pos ];
889 ::System::Type ^ param_type = get_type( xParam->getType() );
890 ::System::String ^ param_type_name = param_type->FullName;
891 if (xParam->isOut())
892 {
893 param_type = get_type(
894 ::System::String::Concat(
895 param_type_name, "&" ), true );
896 }
897 param_types[ xParam->getPosition() ] = param_type;
898 }
899
900
901 // create method
902// if (tb)
903// method_builder = type_builder->DefineMethod(
904// ustring_to_String( xMethod->getMemberName() ),
905// c_method_attr, tb,
906// param_types );
907// else
908 method_builder = type_builder->DefineMethod(
909 ustring_to_String( xMethod->getMemberName() ),
910 c_method_attr, get_type( xMethod->getReturnType() ),
911 param_types );
912 // then define parameter infos
913 params_pos = 0;
914 for ( ; params_pos < params_length; ++params_pos )
915 {
916 Reference< reflection::XMethodParameter > const & xParam =
917 parameters[ params_pos ];
918 long param_flags = 0;
919 if (xParam->isIn())
920 param_flags |= (long)ParameterAttributes::In;
921 if (xParam->isOut())
922 param_flags |= (long)ParameterAttributes::Out;
923 OSL_ASSERT( 0 != param_flags );
924 method_builder->DefineParameter(
925 xParam->getPosition() +1 /* starts with 1 */,
926 (ParameterAttributes) param_flags,
927 ustring_to_String( xParam->getName() ) );
928 }
929 //Apply attribute TypeParametersAttribute to return value if it
930 //is a parameterized Type. Currently only structs can have parameters.
931 Reference<reflection::XStructTypeDescription> xReturnStruct(
932 xMethod->getReturnType(), UNO_QUERY);
933
934 if (xReturnStruct.is())
935 {
936 Sequence<Reference<reflection::XTypeDescription> > seq_type_args =
937 xReturnStruct->getTypeArguments();
938 if (seq_type_args.getLength() != 0)
939 {
940 //get th ctor of the attribute
941 array< ::System::Type^>^ arCtor = {::System::Type::GetType("System.Type[]")};
942 //Get the arguments for the attribute's ctor
943 Reference<reflection::XTypeDescription> const * arXTypeArgs =
944 seq_type_args.getConstArray();
945 int numTypes = seq_type_args.getLength();
946 array< ::System::Type^>^ arCtsTypes = gcnew array< ::System::Type^>(numTypes);
947 for (int i = 0; i < numTypes; i++)
948 arCtsTypes[i] = get_type(arXTypeArgs[i]);
949 array< ::System::Object^>^ arArgs = {arCtsTypes};
950
951 Emit::CustomAttributeBuilder ^ attrBuilder =
952 gcnew Emit::CustomAttributeBuilder(
953 ::uno::TypeArgumentsAttribute::typeid
954 ->GetConstructor( arCtor),
955 arArgs);
956
957 method_builder->SetCustomAttribute(attrBuilder);
958 }
959 }
960
961 //define UNO exception attribute (exceptions)--------------------------------------
962 Emit::CustomAttributeBuilder^ attrBuilder =
963 get_iface_method_exception_attribute(xMethod);
964 if (attrBuilder != nullptr)
965 method_builder->SetCustomAttribute(attrBuilder);
966
967 // oneway attribute
968 if (xMethod->isOneway())
969 {
970 array< ::System::Type^>^ arCtorOneway = gcnew array< ::System::Type^>(0);
971 array< ::System::Object^>^ arArgs = gcnew array< ::System::Object^>(0);
972 Emit::CustomAttributeBuilder ^ attrBuilder =
973 gcnew Emit::CustomAttributeBuilder(
974 ::uno::OnewayAttribute::typeid->GetConstructor( arCtorOneway),
975 arArgs);
976 method_builder->SetCustomAttribute(attrBuilder);
977 }
978 }
979 else // attribute
980 {
981 OSL_ASSERT(
982 TypeClass_INTERFACE_ATTRIBUTE == xMember->getTypeClass() );
983 Reference<
984 reflection::XInterfaceAttributeTypeDescription2 > xAttribute(
985 xMember, UNO_QUERY_THROW );
986
987 MethodAttributes c_property_method_attr = (MethodAttributes)
988 (c_method_attr | MethodAttributes::SpecialName);
989
990 ::System::Type ^ attribute_type = get_type( xAttribute->getType() );
991 array< ::System::Type^>^ parameters =
992 gcnew array< ::System::Type^> ( 0 );
993
994 Emit::PropertyBuilder ^ property_builder =
995 type_builder->DefineProperty(
996 ustring_to_String( xAttribute->getMemberName() ),
997 PropertyAttributes::None,
998 attribute_type, parameters );
999
1000 //set BoundAttribute, if necessary
1001 if (xAttribute->isBound())
1002 {
1003 ConstructorInfo ^ ctorBoundAttr =
1004 ::uno::BoundAttribute::typeid->GetConstructor(
1005 gcnew array<System::Type^>(0));
1006 Emit::CustomAttributeBuilder ^ attrBuilderBound =
1007 gcnew Emit::CustomAttributeBuilder(
1008 ctorBoundAttr, gcnew array< ::System::Object^>(0));
1009 property_builder->SetCustomAttribute(attrBuilderBound);
1010 }
1011
1012 // getter
1013 Emit::MethodBuilder ^ method_builder =
1014 type_builder->DefineMethod(
1015 ustring_to_String( "get_" +
1016 xAttribute->getMemberName() ),
1017 c_property_method_attr, attribute_type, parameters );
1018
1019 //define UNO exception attribute (exceptions)--------------------------------------
1020 Emit::CustomAttributeBuilder^ attrBuilder =
1021 get_exception_attribute(xAttribute->getGetExceptions());
1022 if (attrBuilder != nullptr)
1023 method_builder->SetCustomAttribute(attrBuilder);
1024
1025 property_builder->SetGetMethod( method_builder );
1026
1027 if (! xAttribute->isReadOnly())
1028 {
1029 // setter
1030 parameters = gcnew array< ::System::Type^> ( 1 );
1031 parameters[ 0 ] = attribute_type;
1032 method_builder =
1033 type_builder->DefineMethod(
1034 ustring_to_String( "set_" +
1035 xAttribute->getMemberName() ),
1036 c_property_method_attr, nullptr, parameters );
1037 // define parameter info
1038 method_builder->DefineParameter(
1039 1 /* starts with 1 */, ParameterAttributes::In, "value" );
1040 //define UNO exception attribute (exceptions)--------------------------------------
1041 Emit::CustomAttributeBuilder^ attrBuilder =
1042 get_exception_attribute(xAttribute->getSetExceptions());
1043 if (attrBuilder != nullptr)
1044 method_builder->SetCustomAttribute(attrBuilder);
1045
1046 property_builder->SetSetMethod( method_builder );
1047 }
1048 }
1049 }
1050
1051 // remove from incomplete types map
1052 ::System::String ^ cts_name = type_builder->FullName;
1053 m_incomplete_ifaces->Remove( cts_name );
1054 xType->release();
1055
1056 if (g_bVerbose)
1057 {
1058 ::System::Console::WriteLine(
1059 "> emitting interface type {0}", cts_name );
1060 }
1061 return type_builder->CreateType();
1062}
1063
1064::System::Type ^ TypeEmitter::complete_struct_type( struct_entry ^ entry )
1065{
1066 OSL_ASSERT(entry);
1067 ::System::String ^ cts_name = entry->m_type_builder->FullName;
1068
1069 //Polymorphic struct, define uno.TypeParametersAttribute
1070 //A polymorphic struct cannot have a basetype.
1071 //When we create the template of the struct then we have no exact types
1072 //and the name does not contain a parameter list
1073 Sequence< OUString > seq_type_parameters;
1074 Reference< reflection::XStructTypeDescription> xStructTypeDesc(
1075 entry->m_xType, UNO_QUERY);
1076 if (xStructTypeDesc.is())
1077 {
1078 seq_type_parameters = xStructTypeDesc->getTypeParameters();
1079 int numTypes = 0;
1080 if ((numTypes = seq_type_parameters.getLength()) > 0)
1081 {
1082 array< ::System::Object^>^ aArg = gcnew array< ::System::Object^>(numTypes);
1083 for (int i = 0; i < numTypes; i++)
1084 aArg[i] = ustring_to_String(seq_type_parameters.getConstArray()[i]);
1085 array< ::System::Object^>^ args = {aArg};
1086
1087 array< ::System::Type^>^ arTypesCtor =
1088 {::System::Type::GetType("System.String[]")};
1089 Emit::CustomAttributeBuilder ^ attrBuilder =
1090 gcnew Emit::CustomAttributeBuilder(
1091 ::uno::TypeParametersAttribute::typeid->GetConstructor(arTypesCtor),
1092 args);
1093 entry->m_type_builder->SetCustomAttribute(attrBuilder);
1094 }
1095 }
1096
1097 // optional: lookup base type whether generated entry of this session
1098 struct_entry ^ base_type_entry = nullptr;
1099 if (nullptr != entry->m_base_type)
1100 {
1101 //ToDo maybe get from incomplete structs
1102 base_type_entry =
1103 dynamic_cast< struct_entry ^ >(
1104 m_generated_structs[
1105 entry->m_base_type->FullName ] );
1106 }
1107
1108 // members
1109 Sequence< Reference< reflection::XTypeDescription > > seq_members(
1110 entry->m_xType->getMemberTypes() );
1111 Sequence< OUString > seq_member_names( entry->m_xType->getMemberNames() );
1112 sal_Int32 members_length = seq_members.getLength();
1113 OSL_ASSERT( seq_member_names.getLength() == members_length );
1114 //check if we have a XTypeDescription for every member. If not then the user may
1115 //have forgotten to specify additional rdbs with the --extra option.
1116 Reference< reflection::XTypeDescription > const * pseq_members =
1117 seq_members.getConstArray();
1118 OUString const * pseq_member_names =
1119 seq_member_names.getConstArray();
1120 for (int i = 0; i < members_length; i++)
1121 {
1122 const OUString sType(entry->m_xType->getName());
1123 const OUString sMemberName(pseq_member_names[i]);
1124 if ( ! pseq_members[i].is())
1125 throw RuntimeException("Missing type description . Check if you need to "
1126 "specify additional RDBs with the --extra option. Type missing for: " + sType +
1127 "::" + sMemberName,0);
1128 }
1129
1130 sal_Int32 all_members_length = 0;
1131 sal_Int32 member_pos;
1132 sal_Int32 type_param_pos = 0;
1133
1134 // collect base types; wrong order
1135 ::System::Collections::ArrayList ^ base_types_list =
1136 gcnew ::System::Collections::ArrayList( 3 /* initial capacity */ );
1137 for (::System::Type ^ base_type_pos = entry->m_base_type;
1138 ! base_type_pos->Equals( ::System::Object::typeid );
1139 base_type_pos = base_type_pos->BaseType )
1140 {
1141 base_types_list->Add( base_type_pos );
1142 if (base_type_pos->Equals( ::System::Exception::typeid ))
1143 {
1144 // special Message member
1145 all_members_length += 1;
1146 break; // don't include System.Exception base classes
1147 }
1148 else
1149 {
1150 //ensure the base type is complete. Otherwise GetFields won't work
1151 get_complete_struct(base_type_pos->FullName);
1152 all_members_length +=
1153 base_type_pos->GetFields(
1154 (BindingFlags) (BindingFlags::Instance |
1155 BindingFlags::Public |
1156 BindingFlags::DeclaredOnly) )
1157 ->Length;
1158 }
1159 }
1160
1161 // create all_members arrays; right order
1162 array< ::System::String^>^ all_member_names =
1163 gcnew array< ::System::String^> (all_members_length + members_length );
1164 array< ::System::Type^>^ all_param_types =
1165 gcnew array< ::System::Type^> (all_members_length + members_length );
1166 member_pos = 0;
1167 for ( sal_Int32 pos = base_types_list->Count; pos--; )
1168 {
1169 ::System::Type ^ base_type = safe_cast< ::System::Type ^ >(
1170 base_types_list[pos] );
1171 if (base_type->Equals( ::System::Exception::typeid ))
1172 {
1173 all_member_names[ member_pos ] = "Message";
1174 all_param_types[ member_pos ] = ::System::String::typeid;
1175 ++member_pos;
1176 }
1177 else
1178 {
1179 ::System::String ^ base_type_name = base_type->FullName;
1180
1181 //ToDo m_generated_structs?
1182 struct_entry ^ entry =
1183 dynamic_cast< struct_entry ^ >(
1184 m_generated_structs[base_type_name] );
1185 if (nullptr == entry)
1186 {
1187 // complete type
1188 array<FieldInfo^>^ fields =
1189 base_type->GetFields(
1190 (BindingFlags) (BindingFlags::Instance |
1191 BindingFlags::Public |
1192 BindingFlags::DeclaredOnly) );
1193 sal_Int32 len = fields->Length;
1194 for ( sal_Int32 pos = 0; pos < len; ++pos )
1195 {
1196 FieldInfo ^ field = fields[ pos ];
1197 all_member_names[ member_pos ] = field->Name;
1198 all_param_types[ member_pos ] = field->FieldType;
1199 ++member_pos;
1200 }
1201 }
1202 else // generated during this session:
1203 // members may be incomplete ifaces
1204 {
1205 sal_Int32 len = entry->m_member_names->Length;
1206 for ( sal_Int32 pos = 0; pos < len; ++pos )
1207 {
1208 all_member_names[ member_pos ] =
1209 entry->m_member_names[ pos ];
1210 all_param_types[ member_pos ] =
1211 entry->m_param_types[ pos ];
1212 ++member_pos;
1213 }
1214 }
1215 }
1216 }
1217 OSL_ASSERT( all_members_length == member_pos );
1218
1219 // build up entry
1220// struct_entry * entry = new struct_entry();
1221 entry->m_member_names = gcnew array< ::System::String^> ( members_length );
1222 entry->m_param_types = gcnew array< ::System::Type^> ( members_length );
1223
1224 // add members
1225 array<Emit::FieldBuilder^>^ members = gcnew array<Emit::FieldBuilder^> ( members_length );
1226 //Reference< reflection::XTypeDescription > const * pseq_members =
1227 // seq_members.getConstArray();
1228 //OUString const * pseq_member_names =
1229 // seq_member_names.getConstArray();
1230
1231 int curParamIndex = 0; //count the fields which have parameterized types
1232 for ( member_pos = 0; member_pos < members_length; ++member_pos )
1233 {
1234 ::System::String ^ field_name =
1235 ustring_to_String( pseq_member_names[ member_pos ] );
1236 ::System::Type ^ field_type;
1237 //Special handling of struct parameter types
1238 bool bParameterizedType = false;
1239 if (pseq_members[ member_pos ]->getTypeClass() == TypeClass_UNKNOWN)
1240 {
1241 bParameterizedType = true;
1242 if (type_param_pos < seq_type_parameters.getLength())
1243 {
1244 field_type = ::System::Object::typeid;
1245 type_param_pos++;
1246 }
1247 else
1248 {
1249 throw RuntimeException(
1250 "unexpected member type in " + entry->m_xType->getName() );
1251 }
1252 }
1253 else
1254 {
1255 field_type = get_type( pseq_members[ member_pos ] );
1256
1257 if (field_type->IsArray
1258 && m_incomplete_structs[cts_name]
1259 && !field_type->Namespace->Equals("System"))
1260 {
1261 //Find the value type. In case of sequence<sequence< ... > > find the actual value type
1262 ::System::Type ^ value = field_type;
1263 while ((value = value->GetElementType())->IsArray);
1264 //If the value type is a struct then make sure it is fully created.
1265 get_complete_struct(value->FullName);
1266 field_type = get_type(pseq_members[member_pos]);
1267 }
1268 }
1269 members[ member_pos ] =
1270 entry->m_type_builder->DefineField(
1271 field_name, field_type, FieldAttributes::Public );
1272
1273 //parameterized type (polymorphic struct) ?
1274 if (bParameterizedType && xStructTypeDesc.is())
1275 {
1276 //get the name
1277 OSL_ASSERT(seq_type_parameters.getLength() > curParamIndex);
1278 ::System::String^ sTypeName = ustring_to_String(
1279 seq_type_parameters.getConstArray()[curParamIndex++]);
1280 array< ::System::Object^>^ args = {sTypeName};
1281 //set ParameterizedTypeAttribute
1282 array< ::System::Type^>^ arCtorTypes = {::System::String::typeid};
1283
1284 Emit::CustomAttributeBuilder ^ attrBuilder =
1285 gcnew Emit::CustomAttributeBuilder(
1286 ::uno::ParameterizedTypeAttribute::typeid
1287 ->GetConstructor(arCtorTypes),
1288 args);
1289
1290 members[member_pos]->SetCustomAttribute(attrBuilder);
1291 }
1292 // add to all_members
1293 all_member_names[ all_members_length + member_pos ] = field_name;
1294 all_param_types[ all_members_length + member_pos ] = field_type;
1295 // add to entry
1296 entry->m_member_names[ member_pos ] = field_name;
1297 entry->m_param_types[ member_pos ] = field_type;
1298 }
1299 all_members_length += members_length;
1300
1301 // default .ctor
1302 Emit::ConstructorBuilder ^ ctor_builder =
1303 entry->m_type_builder->DefineConstructor(
1304 c_ctor_method_attr, CallingConventions::Standard,
1305 gcnew array< ::System::Type^> ( 0 ) );
1306 Emit::ILGenerator ^ code = ctor_builder->GetILGenerator();
1307 code->Emit( Emit::OpCodes::Ldarg_0 );
1308 code->Emit(
1309 Emit::OpCodes::Call,
1310 nullptr == base_type_entry
1311 ? entry->m_base_type->GetConstructor( gcnew array< ::System::Type^> ( 0 ) )
1312 : base_type_entry->m_default_ctor );
1313 // default initialize members
1314 for ( member_pos = 0; member_pos < members_length; ++member_pos )
1315 {
1316 FieldInfo ^ field = members[ member_pos ];
1317 ::System::Type ^ field_type = field->FieldType;
1318 // ::System::Type * new_field_type = m_module_builder->GetType(field_type->FullName, false);
1319 // default initialize:
1320 // string, type, enum, sequence, struct, exception, any
1321 if (field_type->Equals( ::System::String::typeid ))
1322 {
1323 code->Emit( Emit::OpCodes::Ldarg_0 );
1324 code->Emit( Emit::OpCodes::Ldstr, "" );
1325 code->Emit( Emit::OpCodes::Stfld, field );
1326 }
1327 else if (field_type->Equals( ::System::Type::typeid ))
1328 {
1329 code->Emit( Emit::OpCodes::Ldarg_0 );
1330 code->Emit(
1331 Emit::OpCodes::Ldtoken, ::System::Void::typeid );
1332 code->Emit(
1333 Emit::OpCodes::Call, m_method_info_Type_GetTypeFromHandle );
1334 code->Emit( Emit::OpCodes::Stfld, field );
1335 }
1336 else if (field_type->IsArray)
1337 {
1338 code->Emit( Emit::OpCodes::Ldarg_0 );
1339 code->Emit( Emit::OpCodes::Ldc_I4_0 );
1340 code->Emit(
1341 Emit::OpCodes::Newarr, field_type->GetElementType() );
1342 code->Emit( Emit::OpCodes::Stfld, field );
1343 }
1344 else if (field_type->IsValueType)
1345 {
1346 if (field_type->FullName->Equals( "uno.Any" ))
1347 {
1348 code->Emit( Emit::OpCodes::Ldarg_0 );
1349 code->Emit( Emit::OpCodes::Ldsfld, ::uno::Any::typeid->GetField("VOID"));
1350 code->Emit( Emit::OpCodes::Stfld, field );
1351 }
1352 }
1353 else if (field_type->IsClass)
1354 {
1355 /* may be XInterface */
1356 if (! field_type->Equals( ::System::Object::typeid ))
1357 {
1358 // struct, exception
1359 //make sure the struct is already complete.
1360 get_complete_struct(field_type->FullName);
1361 code->Emit( Emit::OpCodes::Ldarg_0 );
1362 code->Emit(
1363 Emit::OpCodes::Newobj,
1364 //GetConstructor requires that the member types of the object which is to be constructed are already known.
1365 field_type->GetConstructor(
1366 gcnew array< ::System::Type^> ( 0 ) ) );
1367 code->Emit( Emit::OpCodes::Stfld, field );
1368 }
1369 }
1370 }
1371 code->Emit( Emit::OpCodes::Ret );
1372 entry->m_default_ctor = ctor_builder;
1373
1374 // parameterized .ctor including all base members
1375 ctor_builder = entry->m_type_builder->DefineConstructor(
1376 c_ctor_method_attr, CallingConventions::Standard, all_param_types );
1377 for ( member_pos = 0; member_pos < all_members_length; ++member_pos )
1378 {
1379 ctor_builder->DefineParameter(
1380 member_pos +1 /* starts with 1 */, ParameterAttributes::In,
1381 all_member_names[ member_pos ] );
1382 }
1383 code = ctor_builder->GetILGenerator();
1384 // call base .ctor
1385 code->Emit( Emit::OpCodes::Ldarg_0 ); // push this
1386 sal_Int32 base_members_length = all_members_length - members_length;
1387 array< ::System::Type^>^ param_types =
1388 gcnew array< ::System::Type^> ( base_members_length );
1389 for ( member_pos = 0; member_pos < base_members_length; ++member_pos )
1390 {
1391 emit_ldarg( code, member_pos +1 );
1392 param_types[ member_pos ] = all_param_types[ member_pos ];
1393 }
1394 code->Emit(
1395 Emit::OpCodes::Call,
1396 nullptr == base_type_entry
1397 ? entry->m_base_type->GetConstructor( param_types )
1398 : base_type_entry->m_ctor );
1399 // initialize members
1400 for ( member_pos = 0; member_pos < members_length; ++member_pos )
1401 {
1402 code->Emit( Emit::OpCodes::Ldarg_0 ); // push this
1403 emit_ldarg( code, member_pos + base_members_length +1 );
1404 code->Emit( Emit::OpCodes::Stfld, members[ member_pos ] );
1405 }
1406 code->Emit( Emit::OpCodes::Ret );
1407 entry->m_ctor = ctor_builder;
1408
1409 if (g_bVerbose)
1410 {
1411 ::System::Console::WriteLine(
1412 "> emitting {0} type {1}",
1413 TypeClass_STRUCT == entry->m_xType->getTypeClass()
1414 ? "struct"
1415 : "exception",
1416 cts_name);
1417 }
1418 // new entry
1419 m_generated_structs->Add(cts_name, entry );
1420 ::System::Type ^ ret_type = entry->m_type_builder->CreateType();
1421
1422 // remove from incomplete types map
1423 m_incomplete_structs->Remove( cts_name );
1424 entry->m_xType->release();
1425
1426 if (g_bVerbose)
1427 {
1428 ::System::Console::WriteLine(
1429 "> emitting struct type {0}", cts_name);
1430 }
1431 return ret_type;
1432}
1433
1434//Examples of generated code
1435// public static XWeak constructor1(XComponentContext ctx)
1436// {
1437// XMultiComponentFactory factory = ctx.getServiceManager();
1438// if (factory == null)
1439// throw new com.sun.star.uno.DeploymentException("bla", null);
1440// return (XWeak) factory.createInstanceWithContext("service_specifier", ctx);
1441// }
1442// public static XWeak constructor2(XComponentContext ctx, int a, int b, Any c)
1443// {
1444// XMultiComponentFactory factory = ctx.getServiceManager();
1445// if (factory == null)
1446// throw new com.sun.star.uno.DeploymentException("bla", null);
1447// Any[] arAny = new Any[3];
1448// arAny[0] = new Any(typeof(int), a);
1449// arAny[1] = new Any(typeof(int), b);
1450// arAny[2] = new Any(c.Type, c.Value);
1451// return (XWeak) factory.createInstanceWithArgumentsAndContext("service_specifier", arAny, ctx);
1452// }
1453// Notice that an any parameter is NOT wrapped by another any. Instead the new any is created with the type and value
1454// of the parameter.
1455
1456// public static XWeak constructor3(XComponentContext ctx, params Any[] c)
1457// {
1458// XMultiComponentFactory factory = ctx.getServiceManager();
1459// if (factory == null)
1460// throw new com.sun.star.uno.DeploymentException("bla", null);
1461// return (XWeak) factory.createInstanceWithArgumentsAndContext("service_specifier", c, ctx);
1462// }
1463::System::Type ^ TypeEmitter::complete_service_type(service_entry ^ entry)
1464{
1465 Emit::TypeBuilder ^ type_builder = entry->m_type_builder;
1466 reflection::XServiceTypeDescription2 * xServiceType = entry->m_xType;
1467
1468 //Create the private default constructor
1469 Emit::ConstructorBuilder^ ctor_builder =
1470 type_builder->DefineConstructor(
1471 (MethodAttributes) (MethodAttributes::Private |
1472 MethodAttributes::HideBySig |
1473 MethodAttributes::SpecialName |
1474 MethodAttributes::RTSpecialName),
1475 CallingConventions::Standard, nullptr);
1476
1477 Emit::ILGenerator^ ilGen = ctor_builder->GetILGenerator();
1478 ilGen->Emit( Emit::OpCodes::Ldarg_0 ); // push this
1479 ilGen->Emit(
1480 Emit::OpCodes::Call,
1481 type_builder->BaseType->GetConstructor(gcnew array< ::System::Type^>(0)));
1482 ilGen->Emit( Emit::OpCodes::Ret );
1483
1484
1485 //Create the service constructors.
1486 //obtain the interface which makes up this service, it is the return
1487 //type of the constructor functions
1488 Reference<reflection::XInterfaceTypeDescription2> xIfaceType(
1489 xServiceType->getInterface(), UNO_QUERY);
1490 if (xIfaceType.is () == sal_False)
1491 xIfaceType = resolveInterfaceTypedef(xServiceType->getInterface());
1492 System::Type ^ retType = get_type(xIfaceType);
1493
1494 //Create the ConstructorInfo for a DeploymentException
1495 ::System::Type ^ typeDeploymentExc =
1496 get_type("unoidl.com.sun.star.uno.DeploymentException", true);
1497
1498 array< ::System::Type^>^ arTypeCtor = {::System::String::typeid,
1499 ::System::Object::typeid};
1500 ::System::Reflection::ConstructorInfo ^ ctorDeploymentException =
1501 typeDeploymentExc->GetConstructor(arTypeCtor);
1502
1503 Sequence<Reference<reflection::XServiceConstructorDescription> > seqCtors =
1504 xServiceType->getConstructors();
1505
1506 ::System::Type ^ type_uno_exception = get_type("unoidl.com.sun.star.uno.Exception", true);
1507
1508 for (int i = seqCtors.getLength() - 1; i >= 0; i--)
1509 {
1510 bool bParameterArray = false;
1511 ::System::Type ^ typeAny = ::uno::Any::typeid;
1512 const Reference<reflection::XServiceConstructorDescription> & ctorDes =
1513 seqCtors[i];
1514 //obtain the parameter types
1515 Sequence<Reference<reflection::XParameter> > seqParams =
1516 ctorDes->getParameters();
1517 Reference<reflection::XParameter> const * arXParams = seqParams.getConstArray();
1518 sal_Int32 cParams = seqParams.getLength();
1519 array< ::System::Type^>^ arTypeParameters = gcnew array< ::System::Type^> (cParams + 1);
1520 arTypeParameters[0] = get_type("unoidl.com.sun.star.uno.XComponentContext", true);
1521 for (int iparam = 0; iparam != cParams; iparam++)
1522 {
1523 if (arXParams[iparam]->isRestParameter())
1524 arTypeParameters[iparam + 1] = array< ::uno::Any>::typeid;
1525 else
1526 arTypeParameters[iparam + 1] = get_type(arXParams[iparam]->getType());
1527 }
1528 //The array arTypeParameters can contain:
1529 //System.Type and uno.PolymorphicType.
1530 //Passing PolymorphicType to MethodBuilder.DefineMethod will cause a problem.
1531 //The exception will read something like no on information for parameter # d
1532 //Maybe we need no override another Type method in PolymorphicType ...
1533 //Until we have figured this out, we will create another array of System.Type which
1534 //we pass on to DefineMethod.
1535 array< ::System::Type^>^ arParamTypes = gcnew array< ::System::Type^> (cParams + 1);
1536// arParamTypes[0] = get_type("unoidl.com.sun.star.uno.XComponentContext", true);
1537 for (int i = 0; i < cParams + 1; i++)
1538 {
1539 ::uno::PolymorphicType ^ pT = dynamic_cast< ::uno::PolymorphicType ^ >(arTypeParameters[i]);
1540 if (pT)
1541 arParamTypes[i] = pT->OriginalType;
1542 else
1543 arParamTypes[i] = arTypeParameters[i];
1544 }
1545 //define method
1546 System::String ^ ctorName;
1547 if (ctorDes->isDefaultConstructor())
1548 ctorName = gcnew ::System::String("create");
1549 else
1550 ctorName = ustring_to_String(ctorDes->getName());
1551 Emit::MethodBuilder^ method_builder = type_builder->DefineMethod(
1552 ctorName,
1553 static_cast<MethodAttributes>(MethodAttributes::Public | MethodAttributes::HideBySig |
1554 MethodAttributes::Static),
1555 retType,
1556// arTypeParameters);
1557 arParamTypes);
1558
1559 //define UNO exception attribute (exceptions)--------------------------------------
1560 Emit::CustomAttributeBuilder^ attrBuilder = get_service_exception_attribute(ctorDes);
1561 if (attrBuilder != nullptr)
1562 method_builder->SetCustomAttribute(attrBuilder);
1563
1564
1565 //define parameter attributes (paramarray), names etc.
1566 //The first parameter is the XComponentContext, which cannot be obtained
1567 //from reflection.
1568 //The context is not part of the idl description
1569 method_builder->DefineParameter(
1570 1, ParameterAttributes::In, "the_context");
1571
1572 array<Emit::ParameterBuilder^>^ arParameterBuilder =
1573 gcnew array<Emit::ParameterBuilder^> (cParams);
1574 for (int iparam = 0; iparam != cParams; iparam++)
1575 {
1576 Reference<reflection::XParameter> const & aParam = arXParams[iparam];
1577 ::System::String ^ sParamName = ustring_to_String(aParam->getName());
1578
1579 arParameterBuilder[iparam] = method_builder->DefineParameter(
1580 iparam + 2, ParameterAttributes::In, sParamName);
1581
1582 if (aParam->isRestParameter())
1583 {
1584 bParameterArray = true;
1585 //set the ParameterArrayAttribute
1586 ::System::Reflection::ConstructorInfo^ ctor_info =
1587 System::ParamArrayAttribute::typeid->GetConstructor(
1588 gcnew array< ::System::Type^>(0));
1589 Emit::CustomAttributeBuilder ^ attr_builder =
1590 gcnew Emit::CustomAttributeBuilder(ctor_info, gcnew array< ::System::Object^>(0));
1591 arParameterBuilder[iparam]->SetCustomAttribute(attr_builder);
1592 break;
1593 }
1594 }
1595
1596 Emit::ILGenerator ^ ilGen = method_builder->GetILGenerator();
1597
1598 //Define locals ---------------------------------
1599 //XMultiComponentFactory
1600 Emit::LocalBuilder^ local_factory =
1601 ilGen->DeclareLocal(
1602 get_type("unoidl.com.sun.star.lang.XMultiComponentFactory", true));
1603
1604 //The return type
1605 Emit::LocalBuilder^ local_return_val =
1606 ilGen->DeclareLocal(retType);
1607
1608 //Obtain the XMultiComponentFactory and throw an exception if we do not get one
1609 ilGen->Emit(Emit::OpCodes::Ldarg_0);
1610
1611 ::System::Reflection::MethodInfo ^ methodGetServiceManager = get_type(
1612 "unoidl.com.sun.star.uno.XComponentContext", true)
1613 ->GetMethod("getServiceManager");
1614 ilGen->Emit(Emit::OpCodes::Callvirt, methodGetServiceManager);
1615 ilGen->Emit(Emit::OpCodes::Stloc, local_factory);
1616 ilGen->Emit(Emit::OpCodes::Ldloc, local_factory);
1617 Emit::Label label1 = ilGen->DefineLabel();
1618 ilGen->Emit(Emit::OpCodes::Brtrue, label1);
1619 //The string for the exception
1620 ::System::Text::StringBuilder ^ strbuilder = gcnew ::System::Text::StringBuilder(256);
1621 strbuilder->Append("The service ");
1622 strbuilder->Append(to_cts_name(xServiceType->getName()));
1623 strbuilder->Append(" could not be created. The context failed to supply the service manager.");
1624
1625 ilGen->Emit(Emit::OpCodes::Ldstr, strbuilder->ToString());
1626 ilGen->Emit(Emit::OpCodes::Ldarg_0);
1627 ilGen->Emit(Emit::OpCodes::Newobj, ctorDeploymentException);
1628 ilGen->Emit(Emit::OpCodes::Throw);
1629 ilGen->MarkLabel(label1);
1630
1631 //We create a try/ catch around the createInstanceWithContext, etc. functions
1632 //There are 3 cases
1633 //1. function do not specify exceptions. Then RuntimeExceptions are re-thrown and other
1634 // exceptions produce a DeploymentException.
1635 //2. function specify Exception. Then all exceptions fly through
1636 //3. function specifies exceptions but no Exception. Then these are rethrown
1637 // and other exceptions, except RuntimeException, produce a deployment exception.
1638 //In case there are no parameters we call
1639 //XMultiComponentFactory.createInstanceWithContext
1640
1641 ::System::Collections::ArrayList ^ arExceptionTypes =
1642 get_service_ctor_method_exceptions_reduced(ctorDes->getExceptions());
1643 if (arExceptionTypes->Contains(
1644 type_uno_exception) == false)
1645 {
1646 ilGen->BeginExceptionBlock();
1647 }
1648 if (cParams == 0)
1649 {
1650 ilGen->Emit(Emit::OpCodes::Ldloc, local_factory);
1651 ilGen->Emit(Emit::OpCodes::Ldstr, ustring_to_String(xServiceType->getName()));
1652 ilGen->Emit(Emit::OpCodes::Ldarg_0);
1653
1654 ::System::Reflection::MethodInfo ^ methodCreate =
1655 local_factory->LocalType->GetMethod("createInstanceWithContext");
1656 ilGen->Emit(Emit::OpCodes::Callvirt, methodCreate);
1657 }
1658 else if(bParameterArray)
1659 {
1660 //Service constructor with parameter array
1661 ilGen->Emit(Emit::OpCodes::Ldloc, local_factory);
1662 ilGen->Emit(Emit::OpCodes::Ldstr, ustring_to_String(xServiceType->getName()));
1663 ilGen->Emit(Emit::OpCodes::Ldarg_1);
1664 ilGen->Emit(Emit::OpCodes::Ldarg_0);
1665 ::System::Reflection::MethodInfo ^ methodCreate =
1666 local_factory->LocalType->GetMethod("createInstanceWithArgumentsAndContext");
1667 ilGen->Emit(Emit::OpCodes::Callvirt, methodCreate);
1668 }
1669 else
1670 {
1671 // Any param1, Any param2, etc.
1672 // For each parameter,except the component context, and parameter array
1673 // and Any is created.
1674 array<Emit::LocalBuilder^>^ arLocalAny = gcnew array<Emit::LocalBuilder^> (cParams);
1675
1676 for (int iParam = 0; iParam < cParams; iParam ++)
1677 {
1678 arLocalAny[iParam] = ilGen->DeclareLocal(typeAny);
1679 }
1680
1681 //Any[]. This array is filled with the created Anys which contain the parameters
1682 //and the values contained in the parameter array
1683 Emit::LocalBuilder ^ local_anyParams =
1684 ilGen->DeclareLocal(array< ::uno::Any>::typeid);
1685
1686 //Create the Any for every argument, except for the parameter array
1687 //arLocalAny contains the LocalBuilder for all these parameters.
1688 //we call the ctor Any(Type, Object)
1689 //If the parameter is an Any then the Any is created with Any(param.Type, param.Value);
1690 array< ::System::Type^>^ arTypesCtorAny = {::System::Type::typeid,
1691 ::System::Object::typeid};
1692 ::System::Reflection::ConstructorInfo ^ ctorAny =
1693 typeAny->GetConstructor( arTypesCtorAny);
1694 ::System::Reflection::MethodInfo ^ methodAnyGetType =
1695 typeAny->GetProperty("Type")->GetGetMethod();
1696 ::System::Reflection::MethodInfo ^ methodAnyGetValue =
1697 typeAny->GetProperty("Value")->GetGetMethod();
1698 for (int i = 0; i < arLocalAny->Length; i ++)
1699 {
1700 //check if the parameter is a polymorphic struct
1701 ::uno::PolymorphicType ^polyType = dynamic_cast< ::uno::PolymorphicType^ >(arTypeParameters[i+1]);
1702 //arTypeParameters[i+1] = polyType->OriginalType;
1703 if (polyType)
1704 {
1705 //It is a polymorphic struct
1706 //Load the uninitialized local Any on which we will call the ctor
1707 ilGen->Emit(Emit::OpCodes::Ldloca, arLocalAny[i]);
1708 // Call PolymorphicType PolymorphicType::GetType(Type t, String polyName)
1709 // Prepare the first parameter
1710 ilGen->Emit(Emit::OpCodes::Ldtoken, polyType->OriginalType);
1711 array< ::System::Type^>^ arTypeParams = {::System::RuntimeTypeHandle::typeid};
1712 ilGen->Emit(Emit::OpCodes::Call,
1713 ::System::Type::typeid->GetMethod(
1714 "GetTypeFromHandle", arTypeParams));
1715 // Prepare the second parameter
1716 ilGen->Emit(Emit::OpCodes::Ldstr, polyType->PolymorphicName);
1717 // Make the actual call
1718 array< ::System::Type^>^ arTypeParam_GetType = {
1719 ::System::Type::typeid, ::System::String::typeid };
1720 ilGen->Emit(Emit::OpCodes::Call,
1721 ::uno::PolymorphicType::typeid->GetMethod(gcnew System::String("GetType"),
1722 arTypeParam_GetType));
1723
1724 //Stack is: localAny, PolymorphicType
1725 //Call Any::Any(Type, Object)
1726 //Prepare the second parameter for the any ctor
1727 ilGen->Emit(Emit::OpCodes::Ldarg, i + 1);
1728 // if the parameter is a value type then we need to box it, because
1729 // the Any ctor takes an Object
1730 if (arTypeParameters[i+1]->IsValueType)
1731 ilGen->Emit(Emit::OpCodes::Box, arTypeParameters[i+1]);
1732 ilGen->Emit(Emit::OpCodes::Call, ctorAny);
1733 }
1734 else if (arTypeParameters[i+1] == typeAny)
1735 {
1736 //Create the call new Any(param.Type,param,Value)
1737 //Stack must be Any,Type,Value
1738 //First load the Any which is to be constructed
1739 ilGen->Emit(Emit::OpCodes::Ldloca, arLocalAny[i]);
1740 //Load the Type, which is obtained by calling param.Type
1741 ilGen->Emit(Emit::OpCodes::Ldarga, i + 1);
1742 ilGen->Emit(Emit::OpCodes::Call, methodAnyGetType);
1743 //Load the Value, which is obtained by calling param.Value
1744 ilGen->Emit(Emit::OpCodes::Ldarga, i + 1);
1745 ilGen->Emit(Emit::OpCodes::Call, methodAnyGetValue);
1746 //Call the Any ctor.
1747 ilGen->Emit(Emit::OpCodes::Call, ctorAny);
1748 }
1749 else
1750 {
1751 ilGen->Emit(Emit::OpCodes::Ldloca, arLocalAny[i]);
1752 ilGen->Emit(Emit::OpCodes::Ldtoken, arTypeParameters[i+1]);
1753
1754 array< ::System::Type^>^ arTypeParams = {::System::RuntimeTypeHandle::typeid};
1755 ilGen->Emit(Emit::OpCodes::Call,
1756 ::System::Type::typeid->GetMethod(
1757 "GetTypeFromHandle", arTypeParams));
1758 ilGen->Emit(Emit::OpCodes::Ldarg, i + 1);
1759 // if the parameter is a value type then we need to box it, because
1760 // the Any ctor takes an Object
1761 if (arTypeParameters[i+1]->IsValueType)
1762 ilGen->Emit(Emit::OpCodes::Box, arTypeParameters[i+1]);
1763 ilGen->Emit(Emit::OpCodes::Call, ctorAny);
1764 }
1765 }
1766
1767 //Create the Any[] that is passed to the
1768 //createInstanceWithContext[AndArguments] function
1769 ilGen->Emit(Emit::OpCodes::Ldc_I4, arLocalAny->Length);
1770 ilGen->Emit(Emit::OpCodes::Newarr, typeAny);
1771 ilGen->Emit(Emit::OpCodes::Stloc, local_anyParams);
1772
1773 //Assign all anys created from the parameters
1774 //array to the Any[]
1775 for (int i = 0; i < arLocalAny->Length; i++)
1776 {
1777 ilGen->Emit(Emit::OpCodes::Ldloc, local_anyParams);
1778 ilGen->Emit(Emit::OpCodes::Ldc_I4, i);
1779 ilGen->Emit(Emit::OpCodes::Ldelema, typeAny);
1780 ilGen->Emit(Emit::OpCodes::Ldloc, arLocalAny[i]);
1781 ilGen->Emit(Emit::OpCodes::Stobj, typeAny);
1782 }
1783 // call createInstanceWithArgumentsAndContext
1784 ilGen->Emit(Emit::OpCodes::Ldloc, local_factory);
1785 ilGen->Emit(Emit::OpCodes::Ldstr, ustring_to_String(xServiceType->getName()));
1786 ilGen->Emit(Emit::OpCodes::Ldloc, local_anyParams);
1787 ilGen->Emit(Emit::OpCodes::Ldarg_0);
1788 ::System::Reflection::MethodInfo ^ methodCreate =
1789 local_factory->LocalType->GetMethod("createInstanceWithArgumentsAndContext");
1790 ilGen->Emit(Emit::OpCodes::Callvirt, methodCreate);
1791 }
1792 //cast the object returned by the functions createInstanceWithContext or
1793 //createInstanceWithArgumentsAndContext to the interface type
1794 ilGen->Emit(Emit::OpCodes::Castclass, retType);
1795 ilGen->Emit(Emit::OpCodes::Stloc, local_return_val);
1796
1797 //catch exceptions thrown by createInstanceWithArgumentsAndContext and createInstanceWithContext
1798 if (arExceptionTypes->Contains(type_uno_exception) == false)
1799 {
1800 // catch (unoidl.com.sun.star.uno.RuntimeException) {throw;}
1801 ilGen->BeginCatchBlock(get_type("unoidl.com.sun.star.uno.RuntimeException", true));
1802 ilGen->Emit(Emit::OpCodes::Pop);
1803 ilGen->Emit(Emit::OpCodes::Rethrow);
1804
1805 //catch and rethrow all other defined Exceptions
1806 for (int i = 0; i < arExceptionTypes->Count; i++)
1807 {
1808 ::System::Type ^ excType = safe_cast< ::System::Type^ >(
1809 arExceptionTypes[i]);
1810 if (excType->IsInstanceOfType(
1811 get_type("unoidl.com.sun.star.uno.RuntimeException", true)))
1812 {// we have a catch for RuntimeException already defined
1813 continue;
1814 }
1815
1816 //catch Exception and rethrow
1817 ilGen->BeginCatchBlock(excType);
1818 ilGen->Emit(Emit::OpCodes::Pop);
1819 ilGen->Emit(Emit::OpCodes::Rethrow);
1820 }
1821 //catch (unoidl.com.sun.star.uno.Exception) {throw DeploymentException...}
1822 ilGen->BeginCatchBlock(type_uno_exception);
1823
1824 //Define the local variable that keeps the exception
1825 Emit::LocalBuilder ^ local_exception = ilGen->DeclareLocal(
1826 type_uno_exception);
1827
1828 //Store the exception
1829 ilGen->Emit(Emit::OpCodes::Stloc, local_exception);
1830
1831 //prepare the construction of the exception
1832 strbuilder = gcnew ::System::Text::StringBuilder(256);
1833 strbuilder->Append("The context (com.sun.star.uno.XComponentContext) failed to supply the service ");
1834 strbuilder->Append(to_cts_name(xServiceType->getName()));
1835 strbuilder->Append(": ");
1836
1837 ilGen->Emit(Emit::OpCodes::Ldstr, strbuilder->ToString());
1838
1839 //add to the string the Exception.Message
1840 ilGen->Emit(Emit::OpCodes::Ldloc, local_exception);
1841 ilGen->Emit(Emit::OpCodes::Callvirt,
1842 type_uno_exception->GetProperty("Message")->GetGetMethod());
1843 array< ::System::Type^>^ arConcatParams = {System::String::typeid,
1844 System::String::typeid};
1845 ilGen->Emit(Emit::OpCodes::Call,
1846 System::String::typeid->GetMethod("Concat", arConcatParams));
1847 //load context argument
1848 ilGen->Emit(Emit::OpCodes::Ldarg_0);
1849 ilGen->Emit(Emit::OpCodes::Newobj, ctorDeploymentException);
1850 ilGen->Emit(Emit::OpCodes::Throw);//Exception(typeDeploymentExc);
1851
1852 ilGen->EndExceptionBlock();
1853 }
1854
1855
1856 //Check if the service instance was created and threw an exception if not
1857 Emit::Label label_service_created = ilGen->DefineLabel();
1858 ilGen->Emit(Emit::OpCodes::Ldloc, local_return_val);
1859 ilGen->Emit(Emit::OpCodes::Brtrue_S, label_service_created);
1860
1861 strbuilder = gcnew ::System::Text::StringBuilder(256);
1862 strbuilder->Append("The context (com.sun.star.uno.XComponentContext) failed to supply the service ");
1863 strbuilder->Append(to_cts_name(xServiceType->getName()));
1864 strbuilder->Append(".");
1865 ilGen->Emit(Emit::OpCodes::Ldstr, strbuilder->ToString());
1866 ilGen->Emit(Emit::OpCodes::Ldarg_0);
1867 ilGen->Emit(Emit::OpCodes::Newobj, ctorDeploymentException);
1868 ilGen->Emit(Emit::OpCodes::Throw);//Exception(typeDeploymentExc);
1869
1870 ilGen->MarkLabel(label_service_created);
1871 ilGen->Emit(Emit::OpCodes::Ldloc, local_return_val);
1872 ilGen->Emit(Emit::OpCodes::Ret);
1873
1874 }
1875 // remove from incomplete types map
1876 ::System::String ^ cts_name = type_builder->FullName;
1877 m_incomplete_services->Remove( cts_name );
1878 xServiceType->release();
1879 if (g_bVerbose)
1880 {
1881 ::System::Console::WriteLine(
1882 "> emitting service type {0}", cts_name );
1883 }
1884 return type_builder->CreateType();
1885}
1886
1887
1888Emit::CustomAttributeBuilder^ TypeEmitter::get_service_exception_attribute(
1889 const Reference<reflection::XServiceConstructorDescription> & ctorDes )
1890{
1891 return get_exception_attribute(ctorDes->getExceptions());
1892}
1893
1894Emit::CustomAttributeBuilder^ TypeEmitter::get_iface_method_exception_attribute(
1895 const Reference< reflection::XInterfaceMethodTypeDescription >& xMethod )
1896{
1897
1898 const Sequence<Reference<reflection::XTypeDescription> > seqTD = xMethod->getExceptions();
1899 int len = seqTD.getLength();
1900 Sequence<Reference<reflection::XCompoundTypeDescription> > seqCTD(len);
1901 Reference<reflection::XCompoundTypeDescription> * arCTD = seqCTD.getArray();
1902 for (int i = 0; i < len; i++)
1903 arCTD[i] = Reference<reflection::XCompoundTypeDescription>(seqTD[i], UNO_QUERY_THROW);
1904 return get_exception_attribute(seqCTD);
1905}
1906
1907Emit::CustomAttributeBuilder^ TypeEmitter::get_exception_attribute(
1908
1909 const Sequence<Reference< reflection::XCompoundTypeDescription > >& seq_exceptionsTd )
1910{
1911 Emit::CustomAttributeBuilder ^ attr_builder = nullptr;
1912
1913 Reference< reflection::XCompoundTypeDescription > const * exceptions =
1914 seq_exceptionsTd.getConstArray();
1915
1916 array< ::System::Type^>^ arTypesCtor = {::System::Type::GetType("System.Type[]")};
1917 ConstructorInfo ^ ctor_ExceptionAttribute =
1918 ::uno::ExceptionAttribute::typeid->GetConstructor(arTypesCtor);
1919
1920 sal_Int32 exc_length = seq_exceptionsTd.getLength();
1921 if (exc_length != 0) // opt
1922 {
1923 array< ::System::Type^>^ exception_types =
1924 gcnew array< ::System::Type^> ( exc_length );
1925 for ( sal_Int32 exc_pos = 0; exc_pos < exc_length; ++exc_pos )
1926 {
1927 Reference< reflection::XCompoundTypeDescription > const & xExc =
1928 exceptions[ exc_pos ];
1929 exception_types[ exc_pos ] = get_type( xExc );
1930 }
1931 array< ::System::Object^>^ args = {exception_types};
1932 attr_builder = gcnew Emit::CustomAttributeBuilder(
1933 ctor_ExceptionAttribute, args );
1934 }
1935 return attr_builder;
1936}
1937
1938
1939::System::Type ^ TypeEmitter::complete_singleton_type(singleton_entry ^ entry)
1940{
1941 Emit::TypeBuilder ^ type_builder = entry->m_type_builder;
1942 reflection::XSingletonTypeDescription2 * xSingletonType = entry->m_xType;
1943 ::System::String^ sSingletonName = to_cts_name(xSingletonType->getName());
1944
1945 //Create the private default constructor
1946 Emit::ConstructorBuilder^ ctor_builder =
1947 type_builder->DefineConstructor(
1948 static_cast<MethodAttributes>(MethodAttributes::Private |
1949 MethodAttributes::HideBySig |
1950 MethodAttributes::SpecialName |
1951 MethodAttributes::RTSpecialName),
1952 CallingConventions::Standard, nullptr);
1953
1954 Emit::ILGenerator^ ilGen = ctor_builder->GetILGenerator();
1955 ilGen->Emit( Emit::OpCodes::Ldarg_0 ); // push this
1956 ilGen->Emit(
1957 Emit::OpCodes::Call,
1958 type_builder->BaseType->GetConstructor(gcnew array< ::System::Type^>(0)));
1959 ilGen->Emit( Emit::OpCodes::Ret );
1960
1961
1962 //obtain the interface which makes up this service, it is the return
1963 //type of the constructor functions
1964 Reference<reflection::XInterfaceTypeDescription2> xIfaceType(
1965 xSingletonType->getInterface(), UNO_QUERY);
1966 if (xIfaceType.is () == sal_False)
1967 xIfaceType = resolveInterfaceTypedef(xSingletonType->getInterface());
1968 System::Type ^ retType = get_type(xIfaceType);
1969
1970 //define method
1971 array< ::System::Type^>^ arTypeParameters = {get_type("unoidl.com.sun.star.uno.XComponentContext", true)};
1972 Emit::MethodBuilder^ method_builder = type_builder->DefineMethod(
1973 gcnew System::String("get"),
1974 static_cast<MethodAttributes>(MethodAttributes::Public | MethodAttributes::HideBySig |
1975 MethodAttributes::Static),
1976 retType,
1977 arTypeParameters);
1978
1979
1980// method_builder->SetCustomAttribute(get_service_ctor_method_attribute(ctorDes));
1981
1982 //The first parameter is the XComponentContext, which cannot be obtained
1983 //from reflection.
1984 //The context is not part of the idl description
1985 method_builder->DefineParameter(1, ParameterAttributes::In, "the_context");
1986
1987
1988 ilGen = method_builder->GetILGenerator();
1989 //Define locals ---------------------------------
1990 // Any, returned by XComponentContext.getValueByName
1991 Emit::LocalBuilder^ local_any =
1992 ilGen->DeclareLocal(::uno::Any::typeid);
1993
1994 //Call XContext::getValueByName
1995 ilGen->Emit(Emit::OpCodes::Ldarg_0);
1996 // build the singleton name : /singleton/unoidl.com.sun.star.XXX
1997 ::System::Text::StringBuilder^ sBuilder =
1998 gcnew ::System::Text::StringBuilder("/singletons/");
1999 sBuilder->Append(sSingletonName);
2000 ilGen->Emit(Emit::OpCodes::Ldstr, sBuilder->ToString());
2001
2002 ::System::Reflection::MethodInfo ^ methodGetValueByName =
2003 get_type("unoidl.com.sun.star.uno.XComponentContext", true)->GetMethod("getValueByName");
2004 ilGen->Emit(Emit::OpCodes::Callvirt, methodGetValueByName);
2005 ilGen->Emit(Emit::OpCodes::Stloc_0);
2006
2007 //Contains the returned Any a value?
2008 ilGen->Emit(Emit::OpCodes::Ldloca_S, local_any);
2009 ::System::Reflection::MethodInfo ^ methodHasValue =
2010 ::uno::Any::typeid->GetMethod("hasValue");
2011 ilGen->Emit(Emit::OpCodes::Call, methodHasValue);
2012
2013 //If not, then throw a DeploymentException
2014 Emit::Label label_singleton_exists = ilGen->DefineLabel();
2015 ilGen->Emit(Emit::OpCodes::Brtrue_S, label_singleton_exists);
2016 sBuilder = gcnew ::System::Text::StringBuilder(
2017 "Component context fails to supply singleton ");
2018 sBuilder->Append(sSingletonName);
2019 sBuilder->Append(" of type ");
2020 sBuilder->Append(retType->FullName);
2021 sBuilder->Append(".");
2022 ilGen->Emit(Emit::OpCodes::Ldstr, sBuilder->ToString());
2023 ilGen->Emit(Emit::OpCodes::Ldarg_0);
2024 array< ::System::Type^>^ arTypesCtorDeploymentException = {
2025 ::System::String::typeid, ::System::Object::typeid};
2026 ilGen->Emit(Emit::OpCodes::Newobj,
2027 get_type("unoidl.com.sun.star.uno.DeploymentException",true)
2028 ->GetConstructor(arTypesCtorDeploymentException));
2029 ilGen->Emit(Emit::OpCodes::Throw);
2030 ilGen->MarkLabel(label_singleton_exists);
2031
2032 //Cast the singleton contained in the Any to the expected interface and return it.
2033 ilGen->Emit(Emit::OpCodes::Ldloca_S, local_any);
2034 ilGen->Emit(Emit::OpCodes::Call, ::uno::Any::typeid->GetProperty("Value")->GetGetMethod());
2035 ilGen->Emit(Emit::OpCodes::Castclass, retType);
2036 ilGen->Emit(Emit::OpCodes::Ret);
2037
2038 // remove from incomplete types map
2039 ::System::String ^ cts_name = type_builder->FullName;
2040 m_incomplete_singletons->Remove( cts_name );
2041 xSingletonType->release();
2042 if (g_bVerbose)
2043 {
2044 ::System::Console::WriteLine(
2045 "> emitting singleton type {0}", cts_name );
2046 }
2047 return type_builder->CreateType();
2048}
2049
2050
2051::System::Type ^ TypeEmitter::get_type(
2052 Reference< reflection::XTypeDescription > const & xType )
2053{
2054 switch (xType->getTypeClass())
2055 {
2056 case TypeClass_VOID:
2057 return ::System::Void::typeid;
2058 case TypeClass_CHAR:
2059 return ::System::Char::typeid;
2060 case TypeClass_BOOLEAN:
2061 return ::System::Boolean::typeid;
2062 case TypeClass_BYTE:
2063 return ::System::Byte::typeid;
2064 case TypeClass_SHORT:
2065 return ::System::Int16::typeid;
2066 case TypeClass_UNSIGNED_SHORT:
2067 return ::System::UInt16::typeid;
2068 case TypeClass_LONG:
2069 return ::System::Int32::typeid;
2070 case TypeClass_UNSIGNED_LONG:
2071 return ::System::UInt32::typeid;
2072 case TypeClass_HYPER:
2073 return ::System::Int64::typeid;
2074 case TypeClass_UNSIGNED_HYPER:
2075 return ::System::UInt64::typeid;
2076 case TypeClass_FLOAT:
2077 return ::System::Single::typeid;
2078 case TypeClass_DOUBLE:
2079 return ::System::Double::typeid;
2080 case TypeClass_STRING:
2081 return ::System::String::typeid;
2082 case TypeClass_TYPE:
2083 return ::System::Type::typeid;
2084 case TypeClass_ANY:
2085 return ::uno::Any::typeid;
2086 case TypeClass_ENUM:
2087 return get_type( Reference< reflection::XEnumTypeDescription >(
2088 xType, UNO_QUERY_THROW ) );
2089 case TypeClass_TYPEDEF:
2090 // unwind typedefs
2091 return get_type(
2092 Reference< reflection::XIndirectTypeDescription >(
2093 xType, UNO_QUERY_THROW )->getReferencedType() );
2094 case TypeClass_STRUCT:
2095 case TypeClass_EXCEPTION:
2096 return get_type(
2097 Reference< reflection::XCompoundTypeDescription >(
2098 xType, UNO_QUERY_THROW ) );
2099 case TypeClass_SEQUENCE:
2100 {
2101 ::System::Type ^ element_type = get_type(
2102 Reference< reflection::XIndirectTypeDescription >(
2103 xType, UNO_QUERY_THROW )->getReferencedType() );
2104 ::System::Type ^ retType = get_type(
2105 ::System::String::Concat(
2106 element_type->FullName, "[]" ), true );
2107
2108 ::uno::PolymorphicType ^ pt = dynamic_cast< ::uno::PolymorphicType ^ >(element_type);
2109 if (pt)
2110 {
2111 ::System::String ^ sName = ::System::String::Concat(pt->PolymorphicName, "[]");
2112 retType = ::uno::PolymorphicType::GetType(retType, sName);
2113 }
2114 return retType;
2115 }
2116 case TypeClass_INTERFACE:
2117 return get_type(
2118 Reference< reflection::XInterfaceTypeDescription2 >(
2119 xType, UNO_QUERY_THROW ) );
2120 case TypeClass_CONSTANT:
2121 return get_type(
2122 Reference< reflection::XConstantTypeDescription >(
2123 xType, UNO_QUERY_THROW ) );
2124 case TypeClass_CONSTANTS:
2125 return get_type(
2126 Reference< reflection::XConstantsTypeDescription >(
2127 xType, UNO_QUERY_THROW ) );
2128 case TypeClass_SERVICE:
2129 return get_type(
2130 Reference< reflection::XServiceTypeDescription2 >(
2131 xType, UNO_QUERY_THROW) );
2132 case TypeClass_SINGLETON:
2133 return get_type(
2134 Reference< reflection::XSingletonTypeDescription2 >(
2135 xType, UNO_QUERY_THROW) );
2136 case TypeClass_MODULE:
2137 // ignore these
2138 return nullptr;
2139 default:
2140 throw RuntimeException(
2141 "unexpected type " + xType->getName() );
2142 }
2143}
2144
2145
2146::System::Type ^ TypeEmitter::get_complete_struct( ::System::String ^ sName)
2147{
2148 struct_entry ^ pStruct = safe_cast< struct_entry ^>(
2149 m_incomplete_structs[sName]);
2150 if (pStruct)
2151 {
2152 complete_struct_type(pStruct);
2153 }
2154 //get_type will asked the module builder for the type or otherwise all known assemblies.
2155 return get_type(sName, true);
2156}
2157void TypeEmitter::finish()
2158{
2159 while (true)
2160 {
2161 ::System::Collections::IDictionaryEnumerator ^ enumerator =
2162 m_incomplete_ifaces->GetEnumerator();
2163 if (! enumerator->MoveNext())
2164 break;
2165 complete_iface_type(
2166 safe_cast< iface_entry ^ >( enumerator->Value ) );
2167 }
2168
2169 while (true)
2170 {
2171 ::System::Collections::IDictionaryEnumerator ^ enumerator =
2172 m_incomplete_structs->GetEnumerator();
2173 if (! enumerator->MoveNext())
2174 break;
2175 complete_struct_type(
2176 safe_cast< struct_entry ^ >( enumerator->Value ) );
2177 }
2178
2179
2180 while (true)
2181 {
2182 ::System::Collections::IDictionaryEnumerator ^ enumerator =
2183 m_incomplete_services->GetEnumerator();
2184 if (! enumerator->MoveNext())
2185 break;
2186 complete_service_type(
2187 safe_cast< service_entry ^ >( enumerator->Value ) );
2188 }
2189
2190 while (true)
2191 {
2192 ::System::Collections::IDictionaryEnumerator ^ enumerator =
2193 m_incomplete_singletons->GetEnumerator();
2194 if (! enumerator->MoveNext())
2195 break;
2196 complete_singleton_type(
2197 safe_cast< singleton_entry ^ >( enumerator->Value ) );
2198 }
2199}
2200
2201TypeEmitter::TypeEmitter(
2202 ::System::Reflection::Emit::ModuleBuilder ^ module_builder,
2203 array< ::System::Reflection::Assembly^>^ extra_assemblies )
2204 : m_module_builder( module_builder ),
2205 m_extra_assemblies( extra_assemblies ),
2206 m_method_info_Type_GetTypeFromHandle( nullptr ),
2207 m_type_Exception( nullptr ),
2208 m_type_RuntimeException( nullptr ),
2209 m_incomplete_ifaces( gcnew ::System::Collections::Hashtable() ),
2210 m_incomplete_structs( gcnew ::System::Collections::Hashtable() ),
2211 m_incomplete_services(gcnew ::System::Collections::Hashtable() ),
2212 m_incomplete_singletons(gcnew ::System::Collections::Hashtable() ),
2213 m_generated_structs( gcnew ::System::Collections::Hashtable() )
2214{
2215 array< ::System::Type^>^ param_types = gcnew array< ::System::Type^> ( 1 );
2216 param_types[ 0 ] = ::System::RuntimeTypeHandle::typeid;
2217 m_method_info_Type_GetTypeFromHandle =
2218 ::System::Type::typeid
2219 ->GetMethod( "GetTypeFromHandle", param_types );
2220}
2221
2222::System::Collections::ArrayList ^ TypeEmitter::get_service_ctor_method_exceptions_reduced(
2223 const Sequence<Reference<reflection::XCompoundTypeDescription> > & seqExceptionsTd)
2224{
2225 if (seqExceptionsTd.getLength() == 0)
2226 return gcnew ::System::Collections::ArrayList();
2227
2228 ::System::Collections::ArrayList ^ arTypes = gcnew ::System::Collections::ArrayList();
2229 for (int i = 0; i < seqExceptionsTd.getLength(); i++)
2230 arTypes->Add(get_type(to_cts_name(seqExceptionsTd[i]->getName()), true));
2231
2232 int start = 0;
2233 while (true)
2234 {
2235 bool bRemove = false;
2236 for (int i = start; i < arTypes->Count; i++)
2237 {
2238 ::System::Type ^ t = safe_cast< ::System::Type^ >(arTypes[i]);
2239 for (int j = 0; j < arTypes->Count; j++)
2240 {
2241 if (t->IsSubclassOf(safe_cast< ::System::Type^ >(arTypes[j])))
2242 {
2243 arTypes->RemoveAt(i);
2244 bRemove = true;
2245 break;
2246 }
2247 }
2248 if (bRemove)
2249 break;
2250 start++;
2251 }
2252
2253 if (bRemove == false)
2254 break;
2255 }
2256 return arTypes;
2257}
2258
2259
2260css::uno::Reference< css::reflection::XInterfaceTypeDescription2 >
2261resolveInterfaceTypedef(
2262 const css::uno::Reference<css::reflection::XTypeDescription>& type)
2263{
2264 Reference<reflection::XInterfaceTypeDescription2>
2265 xIfaceTd(type, UNO_QUERY);
2266
2267 if (xIfaceTd.is())
2268 return xIfaceTd;
2269
2270 Reference<reflection::XIndirectTypeDescription> xIndTd(
2271 type, UNO_QUERY_THROW);
2272
2273 return resolveInterfaceTypedef(xIndTd->getReferencedType());
2274}
2275
2276
2277}
2278
2279/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
sType
OptionalString sType
Hashtable
std::unordered_map< std::string, LinkedList > Hashtable
t
XPropertyListType t
xMethod
SbMethodRef xMethod
climaker::TypeEmitter::iface_entry
Definition: climaker_share.h:152
climaker::TypeEmitter::iface_entry::m_xType
css::reflection::XInterfaceTypeDescription2 * m_xType
Definition: climaker_share.h:154
climaker::TypeEmitter::iface_entry::m_type_builder
::System::Reflection::Emit::TypeBuilder m_type_builder
Definition: climaker_share.h:155
climaker::TypeEmitter::service_entry
Definition: climaker_share.h:186
climaker::TypeEmitter::service_entry::m_xType
css::reflection::XServiceTypeDescription2 * m_xType
Definition: climaker_share.h:189
climaker::TypeEmitter::service_entry::m_type_builder
::System::Reflection::Emit::TypeBuilder m_type_builder
Definition: climaker_share.h:188
climaker::TypeEmitter::singleton_entry
Definition: climaker_share.h:195
climaker::TypeEmitter::singleton_entry::m_type_builder
::System::Reflection::Emit::TypeBuilder m_type_builder
Definition: climaker_share.h:197
climaker::TypeEmitter::singleton_entry::m_xType
css::reflection::XSingletonTypeDescription2 * m_xType
Definition: climaker_share.h:198
climaker::TypeEmitter::struct_entry
Definition: climaker_share.h:161
climaker::TypeEmitter::struct_entry::m_member_names
array< ::System::String^> m_member_names
Definition: climaker_share.h:167
climaker::TypeEmitter::struct_entry::m_base_type
::System::Type m_base_type
Definition: climaker_share.h:165
climaker::TypeEmitter::struct_entry::m_param_types
array< ::System::Type^> m_param_types
Definition: climaker_share.h:168
climaker::TypeEmitter::struct_entry::m_xType
css::reflection::XCompoundTypeDescription * m_xType
Definition: climaker_share.h:163
climaker::TypeEmitter::struct_entry::m_type_builder
::System::Reflection::Emit::TypeBuilder m_type_builder
Definition: climaker_share.h:164
climaker::TypeEmitter::struct_entry::m_ctor
::System::Reflection::ConstructorInfo m_ctor
Definition: climaker_share.h:170
climaker::TypeEmitter::struct_entry::m_default_ctor
::System::Reflection::ConstructorInfo m_default_ctor
Definition: climaker_share.h:169
climaker::TypeEmitter::m_generated_structs
::System::Collections::Hashtable m_generated_structs
Definition: climaker_share.h:206
climaker::TypeEmitter::TypeEmitter
TypeEmitter(::System::Reflection::Emit::ModuleBuilder ^ module_builder, array< ::System::Reflection::Assembly^>^ assemblies)
Definition: climaker_emit.cxx:2201
climaker::TypeEmitter::m_incomplete_ifaces
::System::Collections::Hashtable m_incomplete_ifaces
Definition: climaker_share.h:157
climaker::TypeEmitter::m_incomplete_structs
::System::Collections::Hashtable m_incomplete_structs
Definition: climaker_share.h:172
climaker::TypeEmitter::type_resolve
::System::Reflection::Assembly type_resolve(::System::Object ^ sender, ::System::ResolveEventArgs ^ args)
Definition: climaker_emit.cxx:272
climaker::TypeEmitter::get_type
::System::Type get_type(::System::String ^ cli_name, bool throw_exc)
Definition: climaker_emit.cxx:307
climaker::TypeEmitter::get_exception_attribute
::System::Reflection::Emit::CustomAttributeBuilder get_exception_attribute(const css::uno::Sequence< css::uno::Reference< css::reflection::XCompoundTypeDescription > > &seq_exceptionsTd)
Definition: climaker_emit.cxx:1907
climaker::TypeEmitter::get_type_RuntimeException
::System::Type get_type_RuntimeException()
Definition: climaker_emit.cxx:416
climaker::TypeEmitter::get_iface_method_exception_attribute
::System::Reflection::Emit::CustomAttributeBuilder get_iface_method_exception_attribute(const css::uno::Reference< css::reflection::XInterfaceMethodTypeDescription > &xMethod)
Definition: climaker_emit.cxx:1894
climaker::TypeEmitter::m_module_builder
::System::Reflection::Emit::ModuleBuilder m_module_builder
Definition: climaker_share.h:115
climaker::TypeEmitter::get_type_Exception
::System::Type get_type_Exception()
Definition: climaker_emit.cxx:355
climaker::TypeEmitter::get_service_exception_attribute
::System::Reflection::Emit::CustomAttributeBuilder get_service_exception_attribute(const css::uno::Reference< css::reflection::XServiceConstructorDescription > &ctorDesc)
Definition: climaker_emit.cxx:1888
climaker::TypeEmitter::m_incomplete_singletons
::System::Collections::Hashtable m_incomplete_singletons
Definition: climaker_share.h:202
climaker::TypeEmitter::m_method_info_Type_GetTypeFromHandle
::System::Reflection::MethodInfo m_method_info_Type_GetTypeFromHandle
Definition: climaker_share.h:118
climaker::TypeEmitter::complete_singleton_type
::System::Type complete_singleton_type(singleton_entry ^ entry)
Definition: climaker_emit.cxx:1939
climaker::TypeEmitter::m_incomplete_services
::System::Collections::Hashtable m_incomplete_services
Definition: climaker_share.h:191
climaker::TypeEmitter::m_extra_assemblies
array< ::System::Reflection::Assembly^> m_extra_assemblies
Definition: climaker_share.h:116
climaker::TypeEmitter::get_service_ctor_method_exceptions_reduced
::System::Collections::ArrayList get_service_ctor_method_exceptions_reduced(const css::uno::Sequence< css::uno::Reference< css::reflection::XCompoundTypeDescription > > &seqExceptionsTd)
Definition: climaker_emit.cxx:2222
climaker::TypeEmitter::m_type_RuntimeException
::System::Type m_type_RuntimeException
Definition: climaker_share.h:122
climaker::TypeEmitter::complete_struct_type
::System::Type complete_struct_type(struct_entry ^ entry)
Definition: climaker_emit.cxx:1064
climaker::TypeEmitter::m_type_Exception
::System::Type m_type_Exception
Definition: climaker_share.h:120
climaker::TypeEmitter::complete_iface_type
::System::Type complete_iface_type(iface_entry ^ entry)
Definition: climaker_emit.cxx:819
climaker::TypeEmitter::get_complete_struct
::System::Type get_complete_struct(::System::String ^ sName)
Definition: climaker_emit.cxx:2146
climaker::TypeEmitter::complete_service_type
::System::Type complete_service_type(service_entry ^ entry)
Definition: climaker_emit.cxx:1463
uno.PolymorphicType
represents a polymorphic type.
Definition: PolymorphicType.cs:85
uno.PolymorphicType.GetType
static PolymorphicType GetType(Type type, string name)
provides a unique instance of this class.
Definition: PolymorphicType.cs:106
climaker_share.h
value
Any value
sName
OUString sName
climaker::to_cli_constant
static inline ::System::Object to_cli_constant(Any const &value)
Definition: climaker_emit.cxx:48
climaker::to_cts_name
static inline ::System::String to_cts_name(OUString const &uno_name)
Definition: climaker_emit.cxx:41
climaker::c_ctor_method_attr
::System::Reflection::MethodAttributes c_ctor_method_attr
Definition: climaker_share.h:103
climaker::ustring_to_String
inline ::System::String ustring_to_String(OUString const &ustr)
Definition: climaker_share.h:83
climaker::mapUnoTypeName
System::String mapUnoTypeName(System::String ^ typeName)
Definition: climaker_emit.cxx:135
climaker::g_bVerbose
bool g_bVerbose
Definition: climaker_app.cxx:92
climaker::polymorphicStructNameToStructName
void polymorphicStructNameToStructName(::System::String ^ *sPolyName)
Definition: climaker_emit.cxx:124
climaker::mapUnoPolymorphicName
System::String mapUnoPolymorphicName(System::String^ unoName)
For example, there is a uno type com.sun.star.Foo<char, long>.
Definition: climaker_emit.cxx:210
climaker::resolveInterfaceTypedef
css::uno::Reference< css::reflection::XInterfaceTypeDescription2 > resolveInterfaceTypedef(const css::uno::Reference< css::reflection::XTypeDescription > &type)
Definition: climaker_emit.cxx:2261
climaker::emit_ldarg
static void emit_ldarg(Emit::ILGenerator ^ code, ::System::Int32 index)
Definition: climaker_emit.cxx:94
Reference
Reference
i
int i
index
index
args
args
getTypeClass
PyRef getTypeClass(const Runtime &)
GetProperty
UNOTOOLS_DLLPUBLIC css::uno::Any GetProperty(OUString const &url, OUString const &property)
code
sal_Unicode code
getType
bool getType(BSTR name, Type &type)
typeName
OUString typeName
members
PyObject_HEAD PyUNO_callable_Internals * members
climaker::Constants::sUnoVoid
::System::String sUnoVoid
Definition: climaker_share.h:43
climaker::Constants::sByte
static System::String sByte
Definition: climaker_share.h:68
climaker::Constants::sUnoHyper
::System::String sUnoHyper
Definition: climaker_share.h:53
climaker::Constants::sUnoAny
::System::String sUnoAny
Definition: climaker_share.h:45
climaker::Constants::sType
static System::String sType
Definition: climaker_share.h:62
climaker::Constants::sUInt16
static System::String sUInt16
Definition: climaker_share.h:70
climaker::Constants::sVoid
static System::String sVoid
Definition: climaker_share.h:64
climaker::Constants::sUnoDouble
::System::String sUnoDouble
Definition: climaker_share.h:57
climaker::Constants::sAny
static System::String sAny
Definition: climaker_share.h:65
climaker::Constants::sUInt32
static System::String sUInt32
Definition: climaker_share.h:72
climaker::Constants::sSingle
static System::String sSingle
Definition: climaker_share.h:76
climaker::Constants::sUInt64
static System::String sUInt64
Definition: climaker_share.h:74
climaker::Constants::sUnoShort
::System::String sUnoShort
Definition: climaker_share.h:49
climaker::Constants::sUnoBool
::System::String sUnoBool
Definition: climaker_share.h:46
climaker::Constants::sChar
static System::String sChar
Definition: climaker_share.h:67
climaker::Constants::sUnoULong
::System::String sUnoULong
Definition: climaker_share.h:52
climaker::Constants::sUnoChar
::System::String sUnoChar
Definition: climaker_share.h:48
climaker::Constants::sInt16
static System::String sInt16
Definition: climaker_share.h:69
climaker::Constants::sBoolean
static System::String sBoolean
Definition: climaker_share.h:66
climaker::Constants::sUnoLong
::System::String sUnoLong
Definition: climaker_share.h:51
climaker::Constants::sUnoString
::System::String sUnoString
Definition: climaker_share.h:55
climaker::Constants::sString
static System::String sString
Definition: climaker_share.h:75
climaker::Constants::sUnoByte
::System::String sUnoByte
Definition: climaker_share.h:47
climaker::Constants::sInt64
static System::String sInt64
Definition: climaker_share.h:73
climaker::Constants::sObject
static System::String sObject
Definition: climaker_share.h:61
climaker::Constants::sUnoType
::System::String sUnoType
Definition: climaker_share.h:44
climaker::Constants::sInt32
static System::String sInt32
Definition: climaker_share.h:71
climaker::Constants::sDouble
static System::String sDouble
Definition: climaker_share.h:77
climaker::Constants::sUnoidl
static System::String sUnoidl
Definition: climaker_share.h:63
climaker::Constants::sUnoXInterface
::System::String sUnoXInterface
Definition: climaker_share.h:58
climaker::Constants::sBrackets
::System::String sBrackets
Definition: climaker_share.h:59
climaker::Constants::sUnoUShort
::System::String sUnoUShort
Definition: climaker_share.h:50
climaker::Constants::sUnoFloat
::System::String sUnoFloat
Definition: climaker_share.h:56
climaker::Constants::sUnoUHyper
::System::String sUnoUHyper
Definition: climaker_share.h:54
sal_False
#define sal_False
sal_Bool
unsigned char sal_Bool
sal_Unicode
sal_uInt16 sal_Unicode
sal_Int8
signed char sal_Int8
type
ResultType type
pos
size_t pos
Generated on Sun Jul 30 2023 04:41:57 for LibreOffice Module cli_ure (master) by doxygen 1.9.3