| blob | b69c2f8a69683611c730f69f7d0adc1dddc3a39e |
1 --- cli_ure/source/bootstrap/makefile.mk.old 2009-04-06 16:41:58.000000000 +0000
2 +++ cli_ure/source/bootstrap/makefile.mk 2009-04-06 16:41:58.000000000 +0000
3 @@ -76,8 +76,12 @@ $(ASSEMBLY_ATTRIBUTES) .PHONY: assembly.
5 EXTERNAL_DIR=$(PRJ)$/..$/external/cli
7 -$(OUT)$/bin$/cli_uretypes.dll : $(EXTERNAL_DIR)$/cli_uretypes.dll
8 - +$(COPY) $< $@
9 +.IF "$(ENABLE_MONO_CLIMAKER)" != "YES"
10 +
11 +$(OUT)$/bin$/cli_uretypes.dll : $(EXTERNAL_DIR)$/cli_uretypes.dll $(EXTERNAL_DIR)$/cli_uretypes.config $(EXTERNAL_DIR)$/policy.1.0.cli_uretypes.dll
12 + +$(COPY) $? $(OUT)$/bin$/
13 +
14 +.ENDIF
16 $(BIN)$/cli_cppuhelper.dll : $(CSFILES) $(OUT)$/bin$/cli_uretypes.dll
17 +$(CSC) $(CSCFLAGS) \
18 --- cli_ure/source/climaker/makefile.mk.old 2009-04-02 10:49:20.000000000 +0000
19 +++ cli_ure/source/climaker/makefile.mk 2009-04-06 16:41:58.000000000 +0000
20 @@ -45,6 +45,30 @@ CCACHE_DISABLE=TRUE
21 .INCLUDE : settings.mk
22 .INCLUDE : $(PRJ)$/util$/makefile.pmk
24 +.IF "$(ENABLE_MONO)" == "YES"
25 +
26 +.IF "$(ENABLE_MONO_CLIMAKER)" != "YES"
27 +
28 +ALLTAR : # do nothing
29 +
30 +.ELSE
31 +
32 +SLOFILES = $(SLO)$/climaker_mono.obj
33 +SHL1OBJS=$(SLOFILES)
34 +SHL1STDLIBS= $(CPPULIB) $(CPPUHELPERLIB) $(SALLIB)
35 +SHL1TARGET=$(TARGET)
36 +
37 +ALLTAR : $(BIN)$/climaker
38 +
39 +$(BIN)$/climaker : climaker_csharp.cs
40 + gmcs -debug -unsafe climaker_csharp.cs -reference:$(BIN)/cli_basetypes.dll -out:$(BIN)$/climaker.exe
41 + mkbundle2 --static -o $(BIN)$/climaker $(BIN)$/climaker.exe -L $(OUT)/lib
42 +
43 +.INCLUDE : target.mk
44 +.ENDIF
45 +
46 +.ELSE
47 +
48 .IF "$(BUILD_FOR_CLI)" != ""
50 NO_OFFUH=TRUE
51 @@ -138,6 +162,4 @@ $(OBJFILES): $(BIN)$/cli_basetypes.dll
53 .ENDIF
55 -
56 -
57 -
58 +.ENDIF
59 --- cli_ure/unotypes/makefile.mk.old 2009-04-06 16:41:58.000000000 +0000
60 +++ cli_ure/unotypes/makefile.mk 2009-04-06 16:41:58.000000000 +0000
61 @@ -41,7 +41,14 @@ TARGET = unotypes
62 .INCLUDE : $(PRJ)$/util$/target.pmk
63 .INCLUDE : target.mk
65 -.IF "$(BUILD_FOR_CLI)" != ""
66 +.IF "$(BUILD_FOR_CLI)" != "" && ("$(GUI)" == "WNT" || "$(ENABLE_MONO_CLIMAKER)" == "YES")
67 +
68 +.IF "$(ENABLE_MONO_CLIMAKER)" == "YES"
69 +WRAPCMD=MONO_PATH=$(OUT)/bin:$(MONO_PATH) LD_LIBRARY_PATH=$(SOLARLIBDIR):$(OUT)/lib
70 +CLIMAKER=$(BIN)$/climaker
71 +.ELSE
72 +CLIMAKER=climaker.exe
73 +.ENDIF
75 .INCLUDE : $(BIN)$/cliureversion.mk
77 @@ -57,8 +64,8 @@ CLIMAKERFLAGS += --verbose
78 .ENDIF
80 #When changing the assembly version then this must also be done in scp2
81 -$(OUT)$/bin$/cli_uretypes.dll : $(BIN)$/climaker.exe $(SOLARBINDIR)$/types.rdb $(BIN)$/cliureversion.mk
82 - $(subst,$(SOLARBINDIR)$/climaker,$(BIN)$/climaker $(CLIMAKER)) $(CLIMAKERFLAGS) \
83 +$(OUT)$/bin$/cli_uretypes.dll : $(CLIMAKER) $(SOLARBINDIR)$/types.rdb $(BIN)$/cliureversion.mk
84 + $(WRAPCMD) $(CLIMAKER) $(CLIMAKERFLAGS) \
85 --out $@ \
86 --keyfile $(BIN)$/cliuno.snk \
87 --assembly-version $(CLI_URETYPES_NEW_VERSION) \
88 @@ -69,7 +76,7 @@ $(OUT)$/bin$/cli_uretypes.dll : $(BIN)$/
89 #do not forget to deliver cli_uretypes.config. It is NOT embedded in the policy file.
90 #see i62886 for the dependency on cli_uretypes.dll
91 $(POLICY_ASSEMBLY_FILE) : $(BIN)$/cli_uretypes.config $(OUT)$/bin$/cli_uretypes.dll
92 - $(WRAPCMD) AL.exe -out:$@ \
93 + $(WRAPCMD) $(AL) -out:$@ \
94 -version:$(CLI_URETYPES_POLICY_VERSION) \
95 -keyfile:$(BIN)$/cliuno.snk \
96 -link:cli_uretypes.config,$(BIN)$/cli_uretypes.config
97 --- cli_ure/source/climaker/climaker_mono.cxx.old 1970-01-01 00:00:00.000000000 +0000
98 +++ cli_ure/source/climaker/climaker_mono.cxx 2009-04-06 16:41:58.000000000 +0000
99 @@ -0,0 +1,1247 @@
100 +#include <stdio.h>
101 +#include <vector>
102 +#include <memory>
103 +#include <cstring>
104 +
105 +#include "osl/process.h"
106 +#include "osl/file.hxx"
107 +#include "osl/thread.h"
108 +#include "rtl/ustring.hxx"
109 +#include "rtl/ustrbuf.hxx"
110 +#include "cppuhelper/shlib.hxx"
111 +#include "cppuhelper/bootstrap.hxx"
112 +#include "com/sun/star/lang/XInitialization.hpp"
113 +#include "com/sun/star/lang/XSingleComponentFactory.hpp"
114 +#include "com/sun/star/lang/XComponent.hpp"
115 +#include "com/sun/star/container/XSet.hpp"
116 +#include "com/sun/star/container/XHierarchicalNameAccess.hpp"
117 +#include "com/sun/star/reflection/XConstantTypeDescription.hpp"
118 +#include "com/sun/star/reflection/XConstantsTypeDescription.hpp"
119 +#include "com/sun/star/reflection/XEnumTypeDescription.hpp"
120 +#include "com/sun/star/reflection/XIndirectTypeDescription.hpp"
121 +#include "com/sun/star/reflection/XInterfaceTypeDescription2.hpp"
122 +#include "com/sun/star/reflection/XInterfaceAttributeTypeDescription2.hpp"
123 +#include "com/sun/star/reflection/XInterfaceMethodTypeDescription.hpp"
124 +#include "com/sun/star/reflection/XMethodParameter.hpp"
125 +#include "com/sun/star/reflection/XParameter.hpp"
126 +#include "com/sun/star/reflection/XServiceConstructorDescription.hpp"
127 +#include "com/sun/star/reflection/XServiceTypeDescription2.hpp"
128 +#include "com/sun/star/reflection/XSingletonTypeDescription2.hpp"
129 +#include "com/sun/star/reflection/XStructTypeDescription.hpp"
130 +#include "com/sun/star/reflection/XTypeDescriptionEnumerationAccess.hpp"
131 +#include "com/sun/star/registry/XSimpleRegistry.hpp"
132 +
133 +using namespace ::std;
134 +
135 +using namespace ::rtl;
136 +using namespace ::com::sun::star;
137 +using namespace ::com::sun::star::uno;
138 +
139 +#define OUSTR(x) ::rtl::OUString(x, strlen (x), osl_getThreadTextEncoding ())
140 +
141 +enum UnoTypeClass {
142 + UTC_Unknown,
143 + UTC_Void,
144 + UTC_Char,
145 + UTC_Boolean,
146 + UTC_Byte,
147 + UTC_Short,
148 + UTC_UnsignedShort,
149 + UTC_Long,
150 + UTC_UnsignedLong,
151 + UTC_Hyper,
152 + UTC_UnsignedHyper,
153 + UTC_Float,
154 + UTC_Double,
155 + UTC_String,
156 + UTC_Type,
157 + UTC_Any,
158 + UTC_Enum,
159 + UTC_Typedef,
160 + UTC_Struct,
161 + UTC_Exception,
162 + UTC_Sequence,
163 + UTC_Interface,
164 + UTC_InterfaceAttribute,
165 + UTC_InterfaceMethod,
166 + UTC_Constant,
167 + UTC_Constants,
168 + UTC_Service,
169 + UTC_Singleton,
170 + UTC_Module
171 +};
172 +
173 +UnoTypeClass unoTypeClassToCLI (TypeClass tc)
174 +{
175 + switch (tc) {
176 + case TypeClass_UNKNOWN:
177 + return UTC_Unknown;
178 + case TypeClass_VOID:
179 + return UTC_Void;
180 + case TypeClass_CHAR:
181 + return UTC_Char;
182 + case TypeClass_BOOLEAN:
183 + return UTC_Boolean;
184 + case TypeClass_BYTE:
185 + return UTC_Byte;
186 + case TypeClass_SHORT:
187 + return UTC_Short;
188 + case TypeClass_UNSIGNED_SHORT:
189 + return UTC_UnsignedShort;
190 + case TypeClass_LONG:
191 + return UTC_Long;
192 + case TypeClass_UNSIGNED_LONG:
193 + return UTC_UnsignedLong;
194 + case TypeClass_HYPER:
195 + return UTC_Hyper;
196 + case TypeClass_UNSIGNED_HYPER:
197 + return UTC_UnsignedHyper;
198 + case TypeClass_FLOAT:
199 + return UTC_Float;
200 + case TypeClass_DOUBLE:
201 + return UTC_Double;
202 + case TypeClass_STRING:
203 + return UTC_String;
204 + case TypeClass_TYPE:
205 + return UTC_Type;
206 + case TypeClass_ANY:
207 + return UTC_Any;
208 + case TypeClass_ENUM:
209 + return UTC_Enum;
210 + case TypeClass_TYPEDEF:
211 + return UTC_Typedef;
212 + case TypeClass_STRUCT:
213 + return UTC_Struct;
214 + case TypeClass_EXCEPTION:
215 + return UTC_Exception;
216 + case TypeClass_SEQUENCE:
217 + return UTC_Sequence;
218 + case TypeClass_INTERFACE:
219 + return UTC_Interface;
220 + case TypeClass_INTERFACE_ATTRIBUTE:
221 + return UTC_InterfaceAttribute;
222 + case TypeClass_INTERFACE_METHOD:
223 + return UTC_InterfaceMethod;
224 + case TypeClass_CONSTANT:
225 + return UTC_Constant;
226 + case TypeClass_CONSTANTS:
227 + return UTC_Constants;
228 + case TypeClass_SERVICE:
229 + return UTC_Service;
230 + case TypeClass_SINGLETON:
231 + return UTC_Singleton;
232 + case TypeClass_MODULE:
233 + return UTC_Module;
234 + default:
235 + break;
236 + }
237 +
238 + throw RuntimeException(
239 + OUSTR("unexpected type in unoTypeClassToCLI"),
240 + Reference< XInterface >() );
241 +}
242 +
243 +UnoTypeClass unoTypeClass (reflection::XTypeDescription* xType)
244 +{
245 + return unoTypeClassToCLI (xType->getTypeClass ());
246 +}
247 +
248 +class UnoHelper
249 +{
250 + Reference< XComponentContext > mxContext;
251 + Reference< lang::XSingleComponentFactory > mxTDprov_factory;
252 + Reference< container::XHierarchicalNameAccess > mxTDmgr;
253 + Reference< XInterface > mxTD_provider;
254 + Reference< reflection::XTypeDescriptionEnumeration > mxTD_enum;
255 + Reference< reflection::XTypeDescription > mxTD;
256 + sal_Int32 mnPos;
257 +
258 + vector< OUString > mMandatoryRegistries;
259 + vector< OUString > mExtraRegistries;
260 + vector< OUString > mExplicitTypes;
261 +
262 + static OUString const & path_get_working_dir()
263 + {
264 + static OUString s_workingDir;
265 + if (! s_workingDir.getLength())
266 + osl_getProcessWorkingDir( &s_workingDir.pData );
267 + return s_workingDir;
268 + }
269 +
270 + static OUString path_make_absolute_file_url( OUString const & path )
271 + {
272 + OUString file_url;
273 + oslFileError rc = osl_getFileURLFromSystemPath(
274 + path.pData, &file_url.pData );
275 + if (osl_File_E_None == rc)
276 + {
277 + OUString abs;
278 + rc = osl_getAbsoluteFileURL(
279 + path_get_working_dir().pData, file_url.pData, &abs.pData );
280 + if (osl_File_E_None == rc)
281 + {
282 + return abs;
283 + }
284 + else
285 + {
286 + throw RuntimeException(
287 + OUSTR("cannot make absolute: ") + file_url,
288 + Reference< XInterface >() );
289 + }
290 + }
291 + else
292 + {
293 + throw RuntimeException(
294 + OUSTR("cannot get file url from system path: ") + path,
295 + Reference< XInterface >() );
296 + }
297 + }
298 +
299 + Reference< registry::XSimpleRegistry > open_registries(
300 + vector< OUString > const & registries )
301 + {
302 + if (registries.empty())
303 + {
304 + throw RuntimeException(OUSTR("no registries given!"),
305 + Reference< XInterface >() );
306 + }
307 +
308 + Reference< registry::XSimpleRegistry > xSimReg;
309 + for ( size_t nPos = registries.size(); nPos--; )
310 + {
311 + Reference< registry::XSimpleRegistry > xReg(
312 + mxContext->getServiceManager()->createInstanceWithContext(
313 + OUSTR("com.sun.star.registry.SimpleRegistry"), mxContext ),
314 + UNO_QUERY_THROW );
315 + xReg->open( registries[ nPos ], sal_True, sal_False );
316 + if (! xReg->isValid())
317 + {
318 + throw RuntimeException(
319 + OUSTR("invalid registry: ") + registries[ nPos ],
320 + Reference< XInterface >() );
321 + }
322 +
323 + if (xSimReg.is()) // nest?
324 + {
325 + Reference< registry::XSimpleRegistry > xNested(
326 + mxContext->getServiceManager()->createInstanceWithContext(
327 + OUSTR("com.sun.star.registry.NestedRegistry"), mxContext ),
328 + UNO_QUERY_THROW );
329 + Reference< lang::XInitialization > xInit(
330 + xNested, UNO_QUERY_THROW );
331 + Sequence< Any > args( 2 );
332 + args[ 0 ] <<= xReg;
333 + args[ 1 ] <<= xSimReg;
334 + xInit->initialize( args );
335 + xSimReg = xNested;
336 + }
337 + else
338 + {
339 + xSimReg = xReg;
340 + }
341 + }
342 +
343 + return xSimReg;
344 + }
345 +
346 + public:
347 +
348 + UnoHelper ()
349 + {
350 + // bootstrap uno
351 + mxContext = ::cppu::bootstrap_InitialComponentContext(
352 + Reference< registry::XSimpleRegistry >() );
353 + mxTDmgr = Reference< container::XHierarchicalNameAccess > (
354 + mxContext->getValueByName(
355 + OUSTR("/singletons/com.sun.star.reflection."
356 + "theTypeDescriptionManager") ),
357 + UNO_QUERY_THROW );
358 +
359 + // get rdb tdprovider factory
360 + mxTDprov_factory = Reference< lang::XSingleComponentFactory > (
361 + ::cppu::loadSharedLibComponentFactory(
362 + OUSTR("bootstrap.uno" SAL_DLLEXTENSION), OUString(),
363 + OUSTR("com.sun.star.comp.stoc.RegistryTypeDescriptionProvider"),
364 + Reference< lang::XMultiServiceFactory >(
365 + mxContext->getServiceManager(), UNO_QUERY ),
366 + Reference< registry::XRegistryKey >() ), UNO_QUERY );
367 + if (! mxTDprov_factory.is())
368 + {
369 + throw RuntimeException(
370 + OUSTR("cannot get registry typedescription provider: "
371 + "bootstrap.uno" SAL_DLLEXTENSION "!"),
372 + Reference< XInterface >() );
373 + }
374 + }
375 +
376 + void AddMandatoryRegistry (char *registry)
377 + {
378 + mMandatoryRegistries.push_back(
379 + path_make_absolute_file_url( OUSTR( registry ) ) );
380 + }
381 +
382 + void AddExtraRegistry (char *registry)
383 + {
384 + mExtraRegistries.push_back(
385 + path_make_absolute_file_url( OUSTR( registry ) ) );
386 + }
387 +
388 + void AddExplicitType (char *typeName)
389 + {
390 + mExplicitTypes.push_back( OUSTR( typeName ) );
391 + }
392 +
393 + void OpenRegistries ()
394 + {
395 + // create registry td provider for mandatory registry files
396 + Any arg( makeAny( open_registries( mMandatoryRegistries ) ) );
397 + mxTD_provider = Reference< XInterface >(
398 + mxTDprov_factory->createInstanceWithArgumentsAndContext(
399 + Sequence< Any >( &arg, 1 ), mxContext ) );
400 +
401 + // insert provider to tdmgr
402 + Reference< container::XSet > xSet( mxTDmgr, UNO_QUERY_THROW );
403 + Any provider( makeAny( mxTD_provider ) );
404 + xSet->insert( provider );
405 + OSL_ASSERT( xSet->has( provider ) );
406 +
407 + if (! mExtraRegistries.empty())
408 + {
409 + arg = makeAny( open_registries( mExtraRegistries ) );
410 + provider = makeAny(
411 + mxTDprov_factory->createInstanceWithArgumentsAndContext(
412 + Sequence< Any >( &arg, 1 ), mxContext ) );
413 + xSet->insert( provider );
414 + OSL_ASSERT( xSet->has( provider ) );
415 + }
416 +
417 + // and emit types to it
418 + if (mExplicitTypes.empty())
419 + {
420 + mxTD_enum = Reference< reflection::XTypeDescriptionEnumeration > (
421 + Reference< reflection::XTypeDescriptionEnumerationAccess >(
422 + mxTD_provider, UNO_QUERY_THROW )
423 + ->createTypeDescriptionEnumeration(
424 + OUString() /* all IDL modules */,
425 + Sequence< TypeClass >() /* all classes of types */,
426 + reflection::TypeDescriptionSearchDepth_INFINITE ) );
427 + } else
428 + mnPos = 0;
429 + }
430 +
431 + void* NextType ()
432 + {
433 + Reference< reflection::XTypeDescription > xTD;
434 +
435 + if (mnPos < mExplicitTypes.size()) {
436 + Reference< container::XHierarchicalNameAccess > xHNA(
437 + mxTD_provider, UNO_QUERY_THROW );
438 + xTD = Reference< reflection::XTypeDescription >(
439 + xHNA->getByHierarchicalName( mExplicitTypes[ mnPos ] ),
440 + UNO_QUERY_THROW );
441 + mnPos ++;
442 + } else if (mxTD_enum.is() && mxTD_enum->hasMoreElements())
443 + xTD = Reference< reflection::XTypeDescription >(mxTD_enum->nextTypeDescription());
444 +
445 + if (xTD.is()) {
446 + xTD.get ()->acquire ();
447 +
448 + return xTD.get ();
449 + }
450 +
451 + return NULL;
452 + }
453 +
454 + ~UnoHelper ()
455 + {
456 + }
457 +};
458 +
459 +extern "C" {
460 +
461 + static char* oustr_to_char (OUString oustr)
462 + {
463 + OString os = OUStringToOString (oustr, osl_getThreadTextEncoding());
464 +
465 + size_t len = os.getLength () + 1;
466 + char *str = (char *) malloc (len);
467 + memcpy (str, os.getStr (), len);
468 +
469 + return str;
470 + }
471 +
472 + /* UnoHelper class glue */
473 +
474 + void* SAL_CALL
475 + cmm_uno_helper_new ()
476 + {
477 + return new UnoHelper ();
478 + }
479 +
480 + void SAL_CALL
481 + cmm_uno_helper_add_mandatory_registry (void *ptr, char *registry)
482 + {
483 + UnoHelper *helper = (UnoHelper *) ptr;
484 +
485 + helper->AddMandatoryRegistry (registry);
486 + }
487 +
488 + void SAL_CALL
489 + cmm_uno_helper_add_extra_registry (void *ptr, char *registry)
490 + {
491 + UnoHelper *helper = (UnoHelper *) ptr;
492 +
493 + helper->AddExtraRegistry (registry);
494 + }
495 +
496 + void SAL_CALL
497 + cmm_uno_helper_add_explicit_type (void *ptr, char *typeName)
498 + {
499 + UnoHelper *helper = (UnoHelper *) ptr;
500 +
501 + helper->AddExplicitType (typeName);
502 + }
503 +
504 + void SAL_CALL
505 + cmm_uno_helper_open_registries (void *ptr)
506 + {
507 + UnoHelper *helper = (UnoHelper *) ptr;
508 +
509 + helper->OpenRegistries ();
510 + }
511 +
512 + void* SAL_CALL
513 + cmm_uno_helper_next_type (void *ptr)
514 + {
515 + UnoHelper *helper = (UnoHelper *) ptr;
516 +
517 + return helper->NextType ();
518 + }
519 +
520 + void SAL_CALL
521 + cmm_uno_helper_delete (void *ptr)
522 + {
523 + UnoHelper *helper = (UnoHelper *) ptr;
524 +
525 + delete helper;
526 + }
527 +
528 + /* XTypeDescription glue */
529 +
530 + char * SAL_CALL
531 + cmm_x_type_description_get_name (void *ptr)
532 + {
533 + reflection::XTypeDescription* xTD = (reflection::XTypeDescription *) ptr;
534 +
535 + return oustr_to_char (xTD->getName ());
536 + }
537 +
538 + int SAL_CALL
539 + cmm_x_type_description_get_type_class (void *ptr)
540 + {
541 + reflection::XTypeDescription* xTD = (reflection::XTypeDescription *) ptr;
542 +
543 + return unoTypeClass (xTD);
544 + }
545 +
546 + void SAL_CALL
547 + cmm_x_type_description_release (void *ptr)
548 + {
549 + reflection::XTypeDescription* xTD = (reflection::XTypeDescription *) ptr;
550 +
551 + xTD->release ();
552 + }
553 +
554 + /* XEnumTypeDescription glue */
555 +
556 + char * SAL_CALL
557 + cmm_x_enum_type_description_get_name (void *ptr, int idx)
558 + {
559 + reflection::XEnumTypeDescription* xTD = (reflection::XEnumTypeDescription *) ptr;
560 +
561 + Sequence< OUString > seq_enum_names (xTD->getEnumNames ());
562 +
563 + return oustr_to_char (seq_enum_names [idx]);
564 + }
565 +
566 + int SAL_CALL
567 + cmm_x_enum_type_description_get_value (void *ptr, int idx)
568 + {
569 + reflection::XEnumTypeDescription* xTD = (reflection::XEnumTypeDescription *) ptr;
570 +
571 + Sequence< sal_Int32 > seq_enum_values (xTD->getEnumValues ());
572 +
573 + return seq_enum_values [idx];
574 + }
575 +
576 + int SAL_CALL
577 + cmm_x_enum_type_description_get_length (void *ptr)
578 + {
579 + reflection::XEnumTypeDescription* xTD = (reflection::XEnumTypeDescription *) ptr;
580 +
581 + Sequence< sal_Int32 > seq_enum_values (xTD->getEnumValues ());
582 +
583 + return seq_enum_values.getLength ();
584 + }
585 +
586 + /* XInterfaceTypeDescription glue */
587 +
588 + int SAL_CALL
589 + cmm_x_interface_type_description_get_members (void *ptr, const void **handle)
590 + {
591 + reflection::XInterfaceTypeDescription* xTD = (reflection::XInterfaceTypeDescription *) ptr;
592 +
593 + Sequence<
594 + Reference< reflection::XInterfaceMemberTypeDescription > > seq_members (xTD->getMembers ());
595 + Reference< reflection::XInterfaceMemberTypeDescription > const * types = seq_members.getConstArray();
596 +
597 + int length = seq_members.getLength ();
598 + reflection::XInterfaceMemberTypeDescription **array = (reflection::XInterfaceMemberTypeDescription**) malloc (length*sizeof (reflection::XInterfaceMemberTypeDescription *));
599 +
600 + *handle = array;
601 +
602 + for (int i = 0; i < length; i ++) {
603 + array [i] = types [i].get ();
604 + array [i]->acquire ();
605 + }
606 +
607 + return length;
608 + }
609 +
610 + void * SAL_CALL
611 + cmm_x_interface_type_description_get_member (void *ptr, int idx)
612 + {
613 + reflection::XInterfaceMemberTypeDescription** members = (reflection::XInterfaceMemberTypeDescription**) ptr;
614 +
615 + members [idx]->acquire ();
616 +
617 + return members [idx];
618 + }
619 +
620 + void SAL_CALL
621 + cmm_x_interface_type_description_members_release (void *ptr)
622 + {
623 +// uno_Sequence* seq = (uno_Sequence*) ptr;
624 +
625 +// seq->release ();
626 + }
627 +
628 + /* XInterfaceTypeDescription2 glue */
629 +
630 + void * SAL_CALL
631 + cmm_resolveInterface (Reference< reflection::XTypeDescription > type)
632 + {
633 + Reference<reflection::XInterfaceTypeDescription2>
634 + xIfaceTd (type, UNO_QUERY);
635 +
636 + if (xIfaceTd.is()) {
637 + reflection::XTypeDescription* xtd = type.get ();
638 +
639 + xtd->acquire ();
640 +
641 + return xtd;
642 + } else {
643 + Reference<reflection::XIndirectTypeDescription> xIndTd(
644 + type, UNO_QUERY);
645 + if (xIndTd.is() == sal_False)
646 + throw uno::Exception(
647 + OUSTR("resolveInterfaceTypedef was called with an invalid argument"), 0);
648 + return cmm_resolveInterface (xIndTd->getReferencedType());
649 + }
650 + }
651 +
652 +
653 + void* SAL_CALL
654 + cmm_x_interface_type_description_get_base_type (void *ptr, int idx)
655 + {
656 + reflection::XInterfaceTypeDescription2* xTD = (reflection::XInterfaceTypeDescription2 *) ptr;
657 +
658 + Sequence< Reference< reflection::XTypeDescription > > seq_base_types (xTD->getBaseTypes ());
659 +
660 + Reference< reflection::XTypeDescription > type (seq_base_types [idx]);
661 +
662 + return cmm_resolveInterface (type);
663 + }
664 +
665 + int SAL_CALL
666 + cmm_x_interface_type_description_get_length (void *ptr)
667 + {
668 + reflection::XInterfaceTypeDescription2* xTD = (reflection::XInterfaceTypeDescription2 *) ptr;
669 +
670 + Sequence< Reference< reflection::XTypeDescription > > seq_base_types (xTD->getBaseTypes ());
671 +
672 + return seq_base_types.getLength ();
673 + }
674 +
675 + /* XInterfaceAttributeTypeDescription glue */
676 +
677 + void* SAL_CALL
678 + cmm_x_interface_attribute_type_description_get_type (void *ptr)
679 + {
680 + reflection::XInterfaceAttributeTypeDescription2* xTD = (reflection::XInterfaceAttributeTypeDescription2 *) ptr;
681 + Reference< reflection::XTypeDescription > xrt = xTD->getType ();
682 +
683 + xrt.get ()->acquire ();
684 +
685 + return xrt.get ();
686 + }
687 +
688 + bool SAL_CALL
689 + cmm_x_interface_attribute_type_description_is_bound (void *ptr)
690 + {
691 + reflection::XInterfaceAttributeTypeDescription2* xTD = (reflection::XInterfaceAttributeTypeDescription2 *) ptr;
692 +
693 + return xTD->isBound ();
694 + }
695 +
696 + bool SAL_CALL
697 + cmm_x_interface_attribute_type_description_is_read_only (void *ptr)
698 + {
699 + reflection::XInterfaceAttributeTypeDescription2* xTD = (reflection::XInterfaceAttributeTypeDescription2 *) ptr;
700 +
701 + return xTD->isReadOnly ();
702 + }
703 +
704 + static int
705 + get_exception_types (const Sequence<Reference< reflection::XCompoundTypeDescription > >& seq_exceptionsCTD, void **handle)
706 + {
707 + int length = seq_exceptionsCTD.getLength ();
708 +
709 + if (length <= 0)
710 + return 0;
711 +
712 + Reference< reflection::XCompoundTypeDescription > const * types = seq_exceptionsCTD.getConstArray();
713 + size_t size = length*sizeof (reflection::XCompoundTypeDescription *);
714 + reflection::XCompoundTypeDescription **array = (reflection::XCompoundTypeDescription**) malloc (size);
715 +
716 + *handle = array;
717 +
718 + for (int i = 0; i < length; i ++) {
719 + array [i] = types [i].get ();
720 + array [i]->acquire ();
721 + }
722 +
723 + return length;
724 + }
725 +
726 + int SAL_CALL
727 + cmm_x_interface_attribute_type_description_get_get_exception_types (void *ptr, void **handle)
728 + {
729 + reflection::XInterfaceAttributeTypeDescription2* xTD = (reflection::XInterfaceAttributeTypeDescription2 *) ptr;
730 +
731 + return get_exception_types (xTD->getGetExceptions (), handle);
732 + }
733 +
734 + int SAL_CALL
735 + cmm_x_interface_attribute_type_description_get_set_exception_types (void *ptr, void **handle)
736 + {
737 + reflection::XInterfaceAttributeTypeDescription2* xTD = (reflection::XInterfaceAttributeTypeDescription2 *) ptr;
738 +
739 + return get_exception_types (xTD->getSetExceptions (), handle);
740 + }
741 +
742 + void* SAL_CALL
743 + cmm_x_interface_attribute_type_description_get_exception_type (void *ptr, int index)
744 + {
745 + reflection::XCompoundTypeDescription **array = (reflection::XCompoundTypeDescription**) ptr;;
746 +
747 + return array [index];
748 + }
749 +
750 + static void
751 + free_exception_types (void *ptr, int count)
752 + {
753 + reflection::XCompoundTypeDescription **array = (reflection::XCompoundTypeDescription**) ptr;;
754 + int i;
755 +
756 + for (i = 0; i < count; i ++)
757 + array [i]->release ();
758 +
759 + free (array);
760 + }
761 +
762 + void SAL_CALL
763 + cmm_x_interface_attribute_type_description_free_exception_types (void *ptr, int count)
764 + {
765 + free_exception_types (ptr, count);
766 + }
767 +
768 + /* XInterfaceMemberTypeDescription glue */
769 +
770 + char* SAL_CALL
771 + cmm_x_interface_member_type_description_get_member_name (void *ptr)
772 + {
773 + reflection::XInterfaceMemberTypeDescription* xTD = (reflection::XInterfaceMemberTypeDescription *) ptr;
774 +
775 + return oustr_to_char (xTD->getMemberName ());;
776 + }
777 +
778 + /* XInterfaceMethodTypeDescription glue */
779 +
780 + int SAL_CALL
781 + cmm_x_interface_method_type_description_get_parameters (void *ptr, const void **parametersHandle, const void** parametersArrayHandle)
782 + {
783 + reflection::XInterfaceMethodTypeDescription* xTD = (reflection::XInterfaceMethodTypeDescription *) ptr;
784 +
785 + Sequence<
786 + Reference< reflection::XMethodParameter > > seq_parameters (xTD->getParameters ());
787 + Reference< reflection::XMethodParameter > const * parameters = seq_parameters.getConstArray();
788 +
789 + *parametersHandle = seq_parameters.get ();
790 +
791 + int length = seq_parameters.getLength();
792 + size_t size = length*sizeof (Reference< reflection::XMethodParameter > const);
793 + Reference< reflection::XMethodParameter > *copy = (Reference< reflection::XMethodParameter > *) malloc (size);
794 + memcpy (copy, parameters, size);
795 +
796 + *parametersArrayHandle = copy;
797 +
798 + for (int i=0; i<length; i++) {
799 + copy[i].get()->acquire ();
800 + }
801 +
802 + return length;
803 + }
804 +
805 + void * SAL_CALL
806 + cmm_x_interface_method_type_description_get_parameter (void *ptr, int idx)
807 + {
808 + Reference< reflection::XMethodParameter > const * parameters = (Reference< reflection::XMethodParameter > const *) ptr;
809 +
810 + reflection::XMethodParameter* parameterHandle = parameters [idx].get ();
811 +
812 + parameterHandle->acquire ();
813 +
814 + return parameterHandle;
815 + }
816 +
817 + int SAL_CALL
818 + cmm_x_interface_method_type_description_get_exception_types (void *ptr, const void **exceptionTypesHandle, const void** exceptionTypesArrayHandle)
819 + {
820 + reflection::XInterfaceMethodTypeDescription* xMethod = (reflection::XInterfaceMethodTypeDescription *) ptr;
821 +
822 + const Sequence<Reference<reflection::XTypeDescription> > seqTD = xMethod->getExceptions();
823 + int length = seqTD.getLength();
824 + Sequence<Reference<reflection::XCompoundTypeDescription> > seqCTD( length );
825 + Reference< reflection::XCompoundTypeDescription > * arCTD = seqCTD.getArray();
826 +
827 + if (length > 0) {
828 + size_t size = length*sizeof (Reference< reflection::XCompoundTypeDescription > const);
829 + Reference< reflection::XCompoundTypeDescription > *copy = (Reference< reflection::XCompoundTypeDescription > *) malloc (size);
830 +
831 + for (int i=0; i<length; i++) {
832 + arCTD[i] = Reference<reflection::XCompoundTypeDescription>(seqTD[i], UNO_QUERY_THROW);
833 + }
834 +
835 + memcpy (copy, arCTD, size);
836 +
837 + *exceptionTypesArrayHandle = copy;
838 +
839 + for (int i=0; i<length; i++) {
840 + copy[i].get()->acquire ();
841 + }
842 + } else {
843 + *exceptionTypesArrayHandle = NULL;
844 + *exceptionTypesHandle = NULL;
845 + }
846 +
847 + return length;
848 + }
849 +
850 + void * SAL_CALL
851 + cmm_x_interface_method_type_description_get_exception_type (void *ptr, int idx)
852 + {
853 + Reference< reflection::XCompoundTypeDescription > const * exceptionTypes = (Reference< reflection::XCompoundTypeDescription > const *) ptr;
854 +
855 + reflection::XCompoundTypeDescription* exceptionTypeHandle = exceptionTypes [idx].get ();
856 +
857 + exceptionTypeHandle->acquire ();
858 +
859 + return exceptionTypeHandle;
860 + }
861 +
862 + void* SAL_CALL
863 + cmm_x_interface_method_type_description_get_return_type (void *ptr)
864 + {
865 + reflection::XInterfaceMethodTypeDescription* xTD = (reflection::XInterfaceMethodTypeDescription *) ptr;
866 + Reference< reflection::XTypeDescription > xrt = xTD->getReturnType ();
867 +
868 + xrt.get ()->acquire ();
869 +
870 + return xrt.get ();
871 + }
872 +
873 + bool SAL_CALL
874 + cmm_x_interface_method_type_description_returns_struct (void *ptr)
875 + {
876 + reflection::XInterfaceMethodTypeDescription* xTD = (reflection::XInterfaceMethodTypeDescription *) ptr;
877 + Reference< reflection::XStructTypeDescription > xrt (xTD->getReturnType (), UNO_QUERY);
878 +
879 + return xrt.is ();
880 + }
881 +
882 + bool SAL_CALL
883 + cmm_x_interface_method_type_description_is_oneway (void *ptr)
884 + {
885 + reflection::XInterfaceMethodTypeDescription* xTD = (reflection::XInterfaceMethodTypeDescription *) ptr;
886 +
887 + return xTD->isOneway ();
888 + }
889 +
890 + /* XMethodParameter glue */
891 +
892 + bool SAL_CALL
893 + cmm_x_method_parameter_is_out (void *ptr)
894 + {
895 + reflection::XMethodParameter* p = (reflection::XMethodParameter *) ptr;
896 +
897 + return p->isOut ();
898 + }
899 +
900 + bool SAL_CALL
901 + cmm_x_method_parameter_is_in (void *ptr)
902 + {
903 + reflection::XMethodParameter* p = (reflection::XMethodParameter *) ptr;
904 +
905 + return p->isIn ();
906 + }
907 +
908 + int SAL_CALL
909 + cmm_x_method_parameter_position (void *ptr)
910 + {
911 + reflection::XMethodParameter* p = (reflection::XMethodParameter *) ptr;
912 +
913 + return p->getPosition ();
914 + }
915 +
916 + char* SAL_CALL
917 + cmm_x_method_parameter_name (void *ptr)
918 + {
919 + reflection::XMethodParameter* p = (reflection::XMethodParameter *) ptr;
920 +
921 + return oustr_to_char (p->getName ());
922 + }
923 +
924 + void* SAL_CALL
925 + cmm_x_method_parameter_type (void *ptr)
926 + {
927 + reflection::XMethodParameter* p = (reflection::XMethodParameter *) ptr;
928 + Reference< reflection::XTypeDescription > xtd = p->getType ();
929 +
930 + xtd.get ()->acquire ();
931 +
932 + return xtd.get ();
933 + }
934 +
935 + /* XCompoundTypeDescription glue */
936 +
937 + void* SAL_CALL
938 + cmm_x_compound_type_description_get_base_type (void *ptr)
939 + {
940 + reflection::XCompoundTypeDescription* xTD = (reflection::XCompoundTypeDescription *) ptr;
941 + Reference< reflection::XTypeDescription > xrt = xTD->getBaseType ();
942 +
943 + if (!xrt.is ())
944 + return NULL;
945 +
946 + xrt.get ()->acquire ();
947 +
948 + return xrt.get ();
949 + }
950 +
951 + int SAL_CALL
952 + cmm_x_compound_type_description_get_member_names (void *ptr, const void **handle)
953 + {
954 + reflection::XCompoundTypeDescription* xTD = (reflection::XCompoundTypeDescription *) ptr;
955 +
956 + Sequence< OUString > seq_member_names = xTD->getMemberNames ();
957 + int length = seq_member_names.getLength ();
958 +
959 + if (length <= 0)
960 + return 0;
961 +
962 + OUString const * parameters = seq_member_names.getConstArray();
963 + char **array = (char**) malloc (length*sizeof (char *));
964 +
965 + *handle = array;
966 +
967 + for (int i = 0; i < length; i ++) {
968 + array [i] = oustr_to_char (parameters [i]);
969 + }
970 +
971 + return length;
972 + }
973 +
974 + void * SAL_CALL
975 + cmm_x_compound_type_description_get_member_name (void *ptr, int idx)
976 + {
977 + char** member_names = (char **) ptr;
978 +
979 + return strdup (member_names [idx]);
980 + }
981 +
982 + int SAL_CALL
983 + cmm_x_compound_type_description_get_member_types (void *ptr, const void **handle)
984 + {
985 + reflection::XCompoundTypeDescription* xTD = (reflection::XCompoundTypeDescription *) ptr;
986 +
987 + Sequence< Reference< reflection::XTypeDescription > > seq_member_types = xTD->getMemberTypes ();
988 + int length = seq_member_types.getLength ();
989 +
990 + if (length <= 0)
991 + return 0;
992 +
993 + Reference< reflection::XTypeDescription > const * types = seq_member_types.getConstArray();
994 + reflection::XTypeDescription **array = (reflection::XTypeDescription**) malloc (length*sizeof (reflection::XTypeDescription*));
995 +
996 + *handle = array;
997 +
998 + for (int i = 0; i < length; i ++) {
999 + array [i] = types [i].get ();
1000 + array [i]->acquire ();
1001 + }
1002 +
1003 + return length;
1004 + }
1005 +
1006 + void * SAL_CALL
1007 + cmm_x_compound_type_description_get_member_type (void *ptr, int idx)
1008 + {
1009 + reflection::XTypeDescription** member_types = (reflection::XTypeDescription **) ptr;
1010 + member_types [idx]->acquire ();
1011 +
1012 + return member_types [idx];
1013 + }
1014 +
1015 + /* XStructTypeDescription glue */
1016 +
1017 + int SAL_CALL
1018 + cmm_x_struct_type_description_get_type_parameters (void *ptr, const void **handle)
1019 + {
1020 + reflection::XStructTypeDescription* xTD = (reflection::XStructTypeDescription *) ptr;
1021 +
1022 + Sequence< OUString > seq_type_parameters = xTD->getTypeParameters ();
1023 + int length = seq_type_parameters.getLength ();
1024 +
1025 + if (length <= 0)
1026 + return 0;
1027 +
1028 + OUString const * parameters = seq_type_parameters.getConstArray();
1029 + char **array = (char**) malloc (length*sizeof (char *));
1030 +
1031 + *handle = array;
1032 +
1033 + for (int i = 0; i < length; i ++) {
1034 + array [i] = oustr_to_char (parameters [i]);
1035 + }
1036 +
1037 + return length;
1038 + }
1039 +
1040 + void * SAL_CALL
1041 + cmm_x_struct_type_description_get_type_parameter (void *ptr, int idx)
1042 + {
1043 + char** type_parameters = (char **) ptr;
1044 +
1045 + return strdup (type_parameters [idx]);
1046 + }
1047 +
1048 + int SAL_CALL
1049 + cmm_x_struct_type_description_get_type_arguments (void *ptr, const void **typeArgumentsHandle, const void** typeArgumentsArrayHandle)
1050 + {
1051 + reflection::XStructTypeDescription* xTD = (reflection::XStructTypeDescription *) ptr;
1052 +
1053 + Sequence<
1054 + Reference< reflection::XTypeDescription > > seq_type_arguments (xTD->getTypeArguments ());
1055 + Reference< reflection::XTypeDescription > const * type_arguments = seq_type_arguments.getConstArray();
1056 +
1057 + *typeArgumentsHandle = seq_type_arguments.get ();
1058 +
1059 + int length = seq_type_arguments.getLength();
1060 + size_t size = length*sizeof (Reference< reflection::XTypeDescription > const);
1061 + Reference< reflection::XTypeDescription > *copy = (Reference< reflection::XTypeDescription > *) malloc (size);
1062 + memcpy (copy, type_arguments, size);
1063 +
1064 + *typeArgumentsArrayHandle = copy;
1065 +
1066 + for (int i=0; i<length; i++) {
1067 + copy[i].get()->acquire ();
1068 + }
1069 +
1070 + return length;
1071 + }
1072 +
1073 + void * SAL_CALL
1074 + cmm_x_struct_type_description_get_type_argument (void *ptr, int idx)
1075 + {
1076 + Reference< reflection::XTypeDescription > const * type_arguments = (Reference< reflection::XTypeDescription > const *) ptr;
1077 +
1078 + reflection::XTypeDescription* typeArgumentHandle = type_arguments [idx].get ();
1079 +
1080 + typeArgumentHandle->acquire ();
1081 +
1082 + return typeArgumentHandle;
1083 + }
1084 +
1085 + /* XIndirectTypeDescription glue */
1086 +
1087 + void* SAL_CALL
1088 + cmm_x_indirect_type_description_get_referenced_type (void *ptr)
1089 + {
1090 + reflection::XIndirectTypeDescription* xTD = (reflection::XIndirectTypeDescription *) ptr;
1091 + Reference< reflection::XTypeDescription > xrt = xTD->getReferencedType ();
1092 +
1093 + xrt.get ()->acquire ();
1094 +
1095 + return xrt.get ();
1096 + }
1097 +
1098 + /* XConstantTypeDescription glue */
1099 +
1100 + UnoTypeClass SAL_CALL
1101 + cmm_any_to_cli_constant (void *ptr,
1102 + sal_Unicode *tChar, sal_Bool *tBool,
1103 + sal_uInt8 *tByte,
1104 + sal_Int16 *tInt16, sal_uInt16 *tUInt16,
1105 + sal_Int32 *tInt32, sal_uInt32 *tUInt32,
1106 + sal_Int16 *tInt64, sal_uInt64 *tUInt64,
1107 + float *tFloat, double *tDouble)
1108 + {
1109 + reflection::XConstantTypeDescription* xtd = (reflection::XConstantTypeDescription*) ptr;
1110 + Any const & value (xtd->getConstantValue ());
1111 +
1112 + switch (value.getValueTypeClass ()) {
1113 + case TypeClass_CHAR:
1114 + *tChar = *reinterpret_cast< sal_Unicode const * > (value.getValue ());
1115 + break;
1116 + case TypeClass_BOOLEAN:
1117 + *tBool = *reinterpret_cast< sal_Bool const * > (value.getValue ());
1118 + case TypeClass_BYTE:
1119 + *tByte = *reinterpret_cast< sal_uInt8 const * > (value.getValue ());
1120 + break;
1121 + case TypeClass_SHORT:
1122 + *tInt16 = *reinterpret_cast< sal_Int16 const * > (value.getValue ());
1123 + break;
1124 + case TypeClass_UNSIGNED_SHORT:
1125 + *tUInt16 = *reinterpret_cast< sal_uInt16 const * > (value.getValue ());
1126 + break;
1127 + case TypeClass_LONG:
1128 + *tInt32 = *reinterpret_cast< sal_Int32 const * > (value.getValue ());
1129 + break;
1130 + case TypeClass_UNSIGNED_LONG:
1131 + *tUInt32 = *reinterpret_cast< sal_uInt32 const * > (value.getValue ());
1132 + break;
1133 + case TypeClass_HYPER:
1134 + *tInt64 = *reinterpret_cast< sal_Int64 const * > (value.getValue ());
1135 + break;
1136 + case TypeClass_UNSIGNED_HYPER:
1137 + *tUInt64 = *reinterpret_cast< sal_uInt64 const * > (value.getValue ());
1138 + break;
1139 + case TypeClass_FLOAT:
1140 + *tFloat = *reinterpret_cast< float const * > (value.getValue ());
1141 + break;
1142 + case TypeClass_DOUBLE:
1143 + *tDouble = *reinterpret_cast< double const * > (value.getValue ());
1144 + break;
1145 + default:
1146 + throw RuntimeException(OUSTR("unexpected constant type ") +
1147 + value.getValueType().getTypeName(),
1148 + Reference< XInterface >() );
1149 + }
1150 +
1151 + return unoTypeClassToCLI (value.getValueTypeClass ());
1152 + }
1153 +
1154 + /* XConstantsTypeDescription glue */
1155 +
1156 + int SAL_CALL
1157 + cmm_x_constants_type_description_get_constants (void *ptr, const void **handle)
1158 + {
1159 + reflection::XConstantsTypeDescription* xTD = (reflection::XConstantsTypeDescription *) ptr;
1160 +
1161 + Sequence< Reference< reflection::XConstantTypeDescription > > seq_member_types = xTD->getConstants ();
1162 + int length = seq_member_types.getLength ();
1163 +
1164 + if (length <= 0)
1165 + return 0;
1166 +
1167 + Reference< reflection::XConstantTypeDescription > const * types = seq_member_types.getConstArray();
1168 + reflection::XConstantTypeDescription **array = (reflection::XConstantTypeDescription**) malloc (length*sizeof (reflection::XConstantTypeDescription*));
1169 +
1170 + *handle = array;
1171 +
1172 + for (int i = 0; i < length; i ++) {
1173 + array [i] = types [i].get ();
1174 + array [i]->acquire ();
1175 + }
1176 +
1177 + return length;
1178 + }
1179 +
1180 + void * SAL_CALL
1181 + cmm_x_constants_type_description_get_constant (void *ptr, int idx)
1182 + {
1183 + reflection::XConstantTypeDescription** array = (reflection::XConstantTypeDescription **) ptr;
1184 + array [idx]->acquire ();
1185 +
1186 + return array [idx];
1187 + }
1188 +
1189 + /* XServiceTypeDescription glue */
1190 +
1191 + bool SAL_CALL
1192 + cmm_x_service_type_description_is_single_interface_based (void *ptr)
1193 + {
1194 + reflection::XServiceTypeDescription2* xTD = (reflection::XServiceTypeDescription2 *) ptr;
1195 +
1196 + return xTD->isSingleInterfaceBased ();
1197 + }
1198 +
1199 + void* SAL_CALL
1200 + cmm_x_service_type_description_get_interface (void *ptr)
1201 + {
1202 + reflection::XServiceTypeDescription2* xTD = (reflection::XServiceTypeDescription2 *) ptr;
1203 + reflection::XTypeDescription* xTDiface = xTD->getInterface ().get ();
1204 +
1205 + xTDiface->acquire ();
1206 +
1207 + return xTDiface;
1208 + }
1209 +
1210 + int SAL_CALL
1211 + cmm_x_service_type_description_get_constructors (void *ptr, const void **handle)
1212 + {
1213 + reflection::XServiceTypeDescription2* xTD = (reflection::XServiceTypeDescription2 *) ptr;
1214 +
1215 + Sequence< Reference< reflection::XServiceConstructorDescription > > seq_member_types = xTD->getConstructors ();
1216 + int length = seq_member_types.getLength ();
1217 +
1218 + if (length <= 0)
1219 + return 0;
1220 +
1221 + Reference< reflection::XServiceConstructorDescription > const * types = seq_member_types.getConstArray();
1222 + reflection::XServiceConstructorDescription **array = (reflection::XServiceConstructorDescription**) malloc (length*sizeof (reflection::XServiceConstructorDescription*));
1223 +
1224 + *handle = array;
1225 +
1226 + for (int i = 0; i < length; i ++) {
1227 + array [i] = types [i].get ();
1228 + array [i]->acquire ();
1229 + }
1230 +
1231 + return length;
1232 + }
1233 +
1234 + void * SAL_CALL
1235 + cmm_x_service_type_description_get_constructor (void *ptr, int idx)
1236 + {
1237 + reflection::XServiceConstructorDescription** array = (reflection::XServiceConstructorDescription **) ptr;
1238 + array [idx]->acquire ();
1239 +
1240 + return array [idx];
1241 + }
1242 +
1243 + /* XServiceConstructorDescription glue */
1244 +
1245 + int SAL_CALL
1246 + cmm_x_service_constructor_description_get_parameters (void *ptr, const void **handle)
1247 + {
1248 + reflection::XServiceConstructorDescription* xTD = (reflection::XServiceConstructorDescription *) ptr;
1249 +
1250 + Sequence< Reference< reflection::XParameter > > seq_member_types = xTD->getParameters ();
1251 + int length = seq_member_types.getLength ();
1252 +
1253 + if (length <= 0)
1254 + return 0;
1255 +
1256 + Reference< reflection::XParameter > const * types = seq_member_types.getConstArray();
1257 + reflection::XParameter **array = (reflection::XParameter**) malloc (length*sizeof (reflection::XParameter*));
1258 +
1259 + *handle = array;
1260 +
1261 + for (int i = 0; i < length; i ++) {
1262 + array [i] = types [i].get ();
1263 + array [i]->acquire ();
1264 + }
1265 +
1266 + return length;
1267 + }
1268 +
1269 + void * SAL_CALL
1270 + cmm_x_service_constructor_description_get_parameter (void *ptr, int idx)
1271 + {
1272 + reflection::XParameter** array = (reflection::XParameter **) ptr;
1273 + array [idx]->acquire ();
1274 +
1275 + return array [idx];
1276 + }
1277 +
1278 + char * SAL_CALL
1279 + cmm_x_service_constructor_description_get_name (void *ptr)
1280 + {
1281 + reflection::XServiceConstructorDescription* xTD = (reflection::XServiceConstructorDescription *) ptr;
1282 +
1283 + return oustr_to_char (xTD->getName ());
1284 + }
1285 +
1286 + bool SAL_CALL
1287 + cmm_x_service_constructor_description_is_default_constructor (void *ptr)
1288 + {
1289 + reflection::XServiceConstructorDescription* xTD = (reflection::XServiceConstructorDescription *) ptr;
1290 +
1291 + return xTD->isDefaultConstructor ();
1292 + }
1293 +
1294 + int SAL_CALL
1295 + cmm_x_service_constructor_description_get_exception_types (void *ptr, void **handle)
1296 + {
1297 + reflection::XServiceConstructorDescription* xTD = (reflection::XServiceConstructorDescription *) ptr;
1298 +
1299 + return get_exception_types (xTD->getExceptions (), handle);
1300 + }
1301 +
1302 + void* SAL_CALL
1303 + cmm_x_service_constructor_description_get_exception_type (void *ptr, int index)
1304 + {
1305 + reflection::XCompoundTypeDescription **array = (reflection::XCompoundTypeDescription**) ptr;;
1306 +
1307 + return array [index];
1308 + }
1309 +
1310 + void SAL_CALL
1311 + cmm_x_service_constructor_description_free_exception_types (void *ptr, int count)
1312 + {
1313 + free_exception_types (ptr, count);
1314 + }
1315 +
1316 + /* XParameter glue */
1317 +
1318 + bool SAL_CALL
1319 + cmm_x_parameter_is_rest (void *ptr)
1320 + {
1321 + reflection::XParameter* xTD = (reflection::XParameter *) ptr;
1322 +
1323 + return xTD->isRestParameter ();
1324 + }
1325 +
1326 + /* XServiceTypeDescription glue */
1327 +
1328 + bool SAL_CALL
1329 + cmm_x_singleton_type_description_is_interface_based (void *ptr)
1330 + {
1331 + reflection::XSingletonTypeDescription2* xTD = (reflection::XSingletonTypeDescription2 *) ptr;
1332 +
1333 + return xTD->isInterfaceBased ();
1334 + }
1335 +
1336 + void* SAL_CALL
1337 + cmm_x_singleton_type_description_get_interface (void *ptr)
1338 + {
1339 + reflection::XSingletonTypeDescription2* xTD = (reflection::XSingletonTypeDescription2 *) ptr;
1340 + Reference< reflection::XTypeDescription > xrt = xTD->getInterface ();
1341 +
1342 + xrt.get ()->acquire ();
1343 +
1344 + return xrt.get ();
1345 + }
1346 +}
1347 --- cli_ure/source/climaker/climaker_csharp.cs.old 1970-01-01 00:00:00.000000000 +0000
1348 +++ cli_ure/source/climaker/climaker_csharp.cs 2009-04-06 16:41:58.000000000 +0000
1349 @@ -0,0 +1,3200 @@
1350 +using System;
1351 +using System.Collections;
1352 +using System.Reflection;
1353 +using System.Reflection.Emit;
1354 +using System.Runtime.InteropServices;
1355 +
1356 +enum UnoTypeClass {
1357 + Unknown,
1358 + Void,
1359 + Char,
1360 + Boolean,
1361 + Byte,
1362 + Short,
1363 + UnsignedShort,
1364 + Long,
1365 + UnsignedLong,
1366 + Hyper,
1367 + UnsignedHyper,
1368 + Float,
1369 + Double,
1370 + String,
1371 + Type,
1372 + Any,
1373 + Enum,
1374 + Typedef,
1375 + Struct,
1376 + Exception,
1377 + Sequence,
1378 + Interface,
1379 + InterfaceAttribute,
1380 + InterfaceMethod,
1381 + Constant,
1382 + Constants,
1383 + Service,
1384 + Singleton,
1385 + Module
1386 +}
1387 +
1388 +struct Constants
1389 +{
1390 + public static readonly string UnoVoid = "void";
1391 + public static readonly string UnoType = "type";
1392 + public static readonly string UnoAny = "any";
1393 + public static readonly string UnoBool = "boolean";
1394 + public static readonly string UnoByte = "byte";
1395 + public static readonly string UnoChar = "char";
1396 + public static readonly string UnoShort = "short";
1397 + public static readonly string UnoUShort = "unsigned short";
1398 + public static readonly string UnoLong = "long";
1399 + public static readonly string UnoULong = "unsigned long";
1400 + public static readonly string UnoHyper = "hyper";
1401 + public static readonly string UnoUHyper = "unsigned hyper";
1402 + public static readonly string UnoString = "string";
1403 + public static readonly string UnoFloat = "float";
1404 + public static readonly string UnoDouble = "double";
1405 + public static readonly string UnoXInterface = "com.sun.star.uno.XInterface";
1406 + public static readonly string Brackets = "[]";
1407 +
1408 + public static readonly string Object = "System.Object";
1409 + public static readonly string Type = "System.Type";
1410 + public static readonly string Unoidl = "unoidl.";
1411 + public static readonly string Void = "System.Void";
1412 + public static readonly string Any = "uno.Any";
1413 + public static readonly string Boolean = "System.Boolean";
1414 + public static readonly string Char = "System.Char";
1415 + public static readonly string Byte = "System.Byte";
1416 + public static readonly string Int16 = "System.Int16";
1417 + public static readonly string UInt16 = "System.UInt16";
1418 + public static readonly string Int32 = "System.Int32";
1419 + public static readonly string UInt32 = "System.UInt32";
1420 + public static readonly string Int64 = "System.Int64";
1421 + public static readonly string UInt64 = "System.UInt64";
1422 + public static readonly string String = "System.String";
1423 + public static readonly string Single = "System.Single";
1424 + public static readonly string Double = "System.Double";
1425 + public static readonly string Comma = ",";
1426 +}
1427 +
1428 +class TypeEmitter : IDisposable
1429 +{
1430 + ResolveEventHandler mTypeResolver;
1431 + ModuleBuilder mModuleBuilder;
1432 + ArrayList mExtraAssemblies;
1433 + Hashtable mIncompleteIFaces;
1434 + Hashtable mIncompleteServices;
1435 + Hashtable mIncompleteSingletons;
1436 + Hashtable mGeneratedStructs;
1437 + Config mConfig;
1438 +
1439 + Type mTypeException = null;
1440 + Type mTypeRuntimeException = null;
1441 +
1442 + readonly static MethodAttributes cCtorMethodAttr =
1443 + MethodAttributes.Public |
1444 + MethodAttributes.HideBySig |
1445 + MethodAttributes.SpecialName |
1446 + MethodAttributes.RTSpecialName;
1447 + /* | xxx todo: ??? compiler does not know Instance ???
1448 + ::System::Reflection::MethodAttributes::Instance*/
1449 +
1450 + MethodInfo mMethodInfoTypeGetTypeFromHandle;
1451 +
1452 + class IFaceEntry
1453 + {
1454 + public UnoXInterfaceTypeDescription mType;
1455 + public TypeBuilder mTypeBuilder;
1456 + }
1457 +
1458 + class ServiceEntry
1459 + {
1460 + public UnoXServiceTypeDescription mType;
1461 + public TypeBuilder mTypeBuilder;
1462 + }
1463 +
1464 + class SingletonEntry
1465 + {
1466 + public UnoXSingletonTypeDescription mType;
1467 + public TypeBuilder mTypeBuilder;
1468 + }
1469 +
1470 + class StructEntry
1471 + {
1472 + public string[] mMemberNames;
1473 + public Type[] mParamTypes;
1474 + public ConstructorInfo mDefaultConstructor;
1475 + public ConstructorInfo mConstructor;
1476 + }
1477 +
1478 + public TypeEmitter (Config config, ModuleBuilder builder)
1479 + {
1480 + mConfig = config;
1481 +
1482 + // load extra assemblies
1483 + mExtraAssemblies = new ArrayList ();
1484 + foreach (string assemblyPath in mConfig.mExtraAssemblies)
1485 + mExtraAssemblies.Add (Assembly.LoadFrom (assemblyPath));
1486 +
1487 + mTypeResolver = new ResolveEventHandler (TypeResolveHandler);
1488 + mModuleBuilder = builder;
1489 +
1490 + mIncompleteIFaces = new Hashtable ();
1491 + mIncompleteServices = new Hashtable ();
1492 + mIncompleteSingletons = new Hashtable ();
1493 + mGeneratedStructs = new Hashtable ();
1494 +
1495 + Type[] paramTypes = { typeof (RuntimeTypeHandle) };
1496 + mMethodInfoTypeGetTypeFromHandle = typeof (Type).GetMethod ("GetTypeFromHandle", paramTypes);
1497 + }
1498 +
1499 + public ResolveEventHandler ResolveEventHandler
1500 + {
1501 + get
1502 + {
1503 + return mTypeResolver;
1504 + }
1505 + }
1506 +
1507 + Assembly TypeResolveHandler (object o, ResolveEventArgs args)
1508 + {
1509 + Type ret = mModuleBuilder.GetType (args.Name, false);
1510 + //Console.WriteLine ("mModuleBuilder.GetType yields {0}", ret);
1511 +
1512 + if (ret is TypeBuilder) {
1513 + TypeBuilder tb = ret as TypeBuilder;
1514 + //Console.WriteLine ("{0} is type builder", tb);
1515 + if (tb.IsCreated ()) {
1516 + ret = tb.CreateType ();
1517 + //Console.WriteLine ("resolving to created {0} {1}", ret, tb);
1518 + }
1519 + }
1520 +
1521 + if (ret == null) {
1522 + IFaceEntry entry = mIncompleteIFaces [args.Name] as IFaceEntry;
1523 + if (entry != null)
1524 + ret = entry.mTypeBuilder;
1525 + }
1526 +
1527 + if (ret == null && mExtraAssemblies != null) {
1528 + //Console.WriteLine ("assemblies {0}", mExtraAssemblies);
1529 + foreach (Assembly assembly in mExtraAssemblies) {
1530 + ret = assembly.GetType (args.Name, false);
1531 + if (ret != null) {
1532 + if (mConfig.mVerbose) {
1533 + Console.WriteLine ("> resolving type {0} from {1}.",
1534 + args.Name, ret.Assembly.FullName);
1535 + }
1536 + break;
1537 + }
1538 + }
1539 + //Console.WriteLine ("done {0}", ret);
1540 + }
1541 +
1542 + if (ret != null)
1543 + return ret.Assembly;
1544 +
1545 + return null;
1546 + }
1547 +
1548 + Type GetType (string name, bool throwExc)
1549 + {
1550 + Type ret = mModuleBuilder.GetType (name, false);
1551 + //Console.WriteLine ("mModuleBuilder.GetType yields {0}", ret);
1552 +
1553 + if (ret is TypeBuilder) {
1554 + TypeBuilder tb = ret as TypeBuilder;
1555 + //Console.WriteLine ("{0} is type builder", tb);
1556 + if (tb.IsCreated ()) {
1557 + ret = tb.CreateType ();
1558 + //Console.WriteLine ("resolving to created {0} {1}", ret, tb);
1559 + }
1560 + }
1561 +
1562 + if (ret == null) {
1563 + //Console.WriteLine ("looking name {0}", name);
1564 + IFaceEntry entry = mIncompleteIFaces [name] as IFaceEntry;
1565 + if (entry != null)
1566 + ret = entry.mTypeBuilder;
1567 + }
1568 +
1569 + //try the cli_basetypes assembly
1570 + if (ret == null) {
1571 + ret = Type.GetType (name + ",cli_basetypes");
1572 + }
1573 +
1574 + if (ret == null) {
1575 + try {
1576 + // may call on type_resolve()
1577 + return Type.GetType (name, throwExc);
1578 + } catch (Exception e) {
1579 + //If the type is not found one may have forgotten to specify assemblies with
1580 + //additional types
1581 + if (throwExc)
1582 + throw new Exception ("\nThe type " + name + " \n could not be found. Did you forget to " +
1583 + "specify an additional assembly with the --reference option?\n", e);
1584 + }
1585 + }
1586 +
1587 + return ret;
1588 + }
1589 +
1590 + public Type GetType (UnoXEnumTypeDescription xtd)
1591 + {
1592 + //Console.WriteLine ("emit enum {0} {1}", xtd.Name, xtd.Length);
1593 + string name = "unoidl." + xtd.Name;
1594 +
1595 + Type ret = GetType (name, false /* no exc */);
1596 + if (ret == null) {
1597 +// Emit::EnumBuilder * enum_builder =
1598 +// m_module_builder->DefineEnum(
1599 +// cts_name,
1600 +// (TypeAttributes) (TypeAttributes::Public |
1601 +// // TypeAttributes::Sealed |
1602 +// TypeAttributes::AnsiClass),
1603 +// __typeof (::System::Int32) );
1604 + // workaround enum builder bug
1605 + TypeBuilder enumBuilder =
1606 + mModuleBuilder.DefineType (name,
1607 + TypeAttributes.Public |
1608 + TypeAttributes.Sealed,
1609 + typeof (System.Enum));
1610 + enumBuilder.DefineField ("value__", typeof (System.Int32),
1611 + FieldAttributes.Public |
1612 + FieldAttributes.SpecialName |
1613 + FieldAttributes.RTSpecialName);
1614 +
1615 + int length = xtd.Length;
1616 + for (int pos = 0; pos < length; pos ++) {
1617 +// enum_builder->DefineLiteral(
1618 +// ustring_to_String( enum_names[ enum_pos ] ),
1619 +// __box ((::System::Int32) enum_values[ enum_pos ]) );
1620 + FieldBuilder fieldBuilder =
1621 + enumBuilder.DefineField (xtd.ValueName (pos),
1622 + enumBuilder,
1623 + FieldAttributes.Public |
1624 + FieldAttributes.Static |
1625 + FieldAttributes.Literal);
1626 + fieldBuilder.SetConstant (xtd.Value (pos));
1627 + }
1628 +
1629 + if (mConfig.mVerbose)
1630 + Console.WriteLine ("> emitting enum type {0}", name );
1631 +
1632 + ret = enumBuilder.CreateType ();
1633 + }
1634 +
1635 + return ret;
1636 + }
1637 +
1638 + public Type GetType (UnoXInterfaceTypeDescription xtd)
1639 + {
1640 + //Console.WriteLine ("get iface {0}", xtd.Name);
1641 +
1642 + if (String.Compare (xtd.Name, "com.sun.star.uno.XInterface") == 0) {
1643 + return typeof (object);
1644 + }
1645 +
1646 + string name = "unoidl." + xtd.Name;
1647 +
1648 + Type ret = GetType (name, false /* no exc */);
1649 +
1650 + if (ret == null) {
1651 + //Console.WriteLine ("creating name {0}", name);
1652 + TypeBuilder typeBuilder;
1653 +
1654 + TypeAttributes attr = TypeAttributes.Public |
1655 + TypeAttributes.Interface |
1656 + TypeAttributes.Abstract |
1657 + TypeAttributes.AnsiClass;
1658 +
1659 + int length = xtd.BaseTypes;
1660 + if (length > 0) {
1661 + ArrayList ifaces = new ArrayList ();
1662 + int i;
1663 +
1664 + for (i = 0; i < length; i ++) {
1665 + UnoXInterfaceTypeDescription baseType = xtd.BaseType (i);
1666 + if (String.Compare (baseType.Name, "com.sun.star.uno.XInterface") != 0)
1667 + ifaces.Add (baseType);
1668 + }
1669 + Type[] baseInterfaces = new Type [ifaces.Count];
1670 +
1671 + i = 0;
1672 + foreach (UnoXInterfaceTypeDescription iface in ifaces) {
1673 + baseInterfaces[i] = GetType (iface);
1674 + i++;
1675 + }
1676 +
1677 + typeBuilder = mModuleBuilder.DefineType (name, attr, null, baseInterfaces);
1678 + } else {
1679 + System.Console.WriteLine ("warning: IDL interface {0} is not derived from " +
1680 + "com.sun.star.uno.XInterface!", name);
1681 +
1682 + typeBuilder = mModuleBuilder.DefineType (name, attr);
1683 + }
1684 +
1685 + // insert to be completed
1686 + IFaceEntry entry = new IFaceEntry ();
1687 + entry.mType = xtd;
1688 + entry.mTypeBuilder = typeBuilder;
1689 + mIncompleteIFaces [name] = entry;
1690 +
1691 + // type is incomplete
1692 + ret = typeBuilder;
1693 + }
1694 +
1695 + return ret;
1696 + }
1697 +
1698 + string PolymorphicStructNameToStructName (string name)
1699 + {
1700 + if (!name.EndsWith (">"))
1701 + return name;
1702 +
1703 + int index = name.IndexOf ('<');
1704 +
1705 + if (index == -1)
1706 + return name;
1707 +
1708 + return name.Substring (0, index);
1709 + }
1710 +
1711 + Type TypeException ()
1712 + {
1713 + if (mTypeException == null) {
1714 + mTypeException = GetType ("unoidl.com.sun.star.uno.Exception", false);
1715 +
1716 + if (mTypeException == null) {
1717 + // define hardcoded type unoidl.com.sun.star.uno.Exception
1718 + TypeBuilder typeBuilder = mModuleBuilder.DefineType ("unoidl.com.sun.star.uno.Exception",
1719 + TypeAttributes.Public |
1720 + TypeAttributes.BeforeFieldInit |
1721 + TypeAttributes.AnsiClass,
1722 + typeof (System.Exception));
1723 + FieldBuilder fieldContext = typeBuilder.DefineField ("Context", typeof (object),
1724 + FieldAttributes.Public);
1725 + // default .ctor
1726 + typeBuilder.DefineDefaultConstructor (cCtorMethodAttr);
1727 + // .ctor
1728 + Type[] paramTypes = new Type [2];
1729 + paramTypes [0] = typeof (string);
1730 + paramTypes [1] = typeof (object);
1731 + ConstructorBuilder ctorBuilder = typeBuilder.DefineConstructor (cCtorMethodAttr,
1732 + CallingConventions.Standard,
1733 + paramTypes);
1734 + ctorBuilder.DefineParameter (1, ParameterAttributes.In, "Message");
1735 + ctorBuilder.DefineParameter (2, ParameterAttributes.In, "Context");
1736 + ILGenerator code = ctorBuilder.GetILGenerator ();
1737 + code.Emit (OpCodes.Ldarg_0);
1738 + code.Emit (OpCodes.Ldarg_1);
1739 + paramTypes = new Type [1];
1740 + paramTypes [0] = typeof (string);
1741 + code.Emit (OpCodes.Call, typeof (System.Exception).GetConstructor (paramTypes));
1742 + code.Emit( OpCodes.Ldarg_0 );
1743 + code.Emit( OpCodes.Ldarg_2 );
1744 + code.Emit( OpCodes.Stfld, fieldContext );
1745 + code.Emit( OpCodes.Ret );
1746 +
1747 + if (mConfig.mVerbose)
1748 + Console.WriteLine ("> emitting exception type unoidl.com.sun.star.uno.Exception");
1749 +
1750 + mTypeException = typeBuilder.CreateType ();
1751 + }
1752 + }
1753 +
1754 + return mTypeException;
1755 + }
1756 +
1757 + Type TypeRuntimeException ()
1758 + {
1759 + if (mTypeRuntimeException == null) {
1760 + mTypeRuntimeException = GetType ("unoidl.com.sun.star.uno.RuntimeException", false);
1761 + if (mTypeRuntimeException == null) {
1762 + // define hardcoded type unoidl.com.sun.star.uno.RuntimeException
1763 + Type typeException = TypeException ();
1764 + TypeBuilder typeBuilder = mModuleBuilder.DefineType ("unoidl.com.sun.star.uno.RuntimeException",
1765 + TypeAttributes.Public |
1766 + TypeAttributes.BeforeFieldInit |
1767 + TypeAttributes.AnsiClass,
1768 + typeException);
1769 + // default .ctor
1770 + typeBuilder.DefineDefaultConstructor (cCtorMethodAttr);
1771 + // .ctor
1772 + Type[] paramTypes = new Type [2];
1773 + paramTypes [0] = typeof (string);
1774 + paramTypes [1] = typeof (object);
1775 + ConstructorBuilder ctorBuilder = typeBuilder.DefineConstructor (cCtorMethodAttr,
1776 + CallingConventions.Standard,
1777 + paramTypes);
1778 + ctorBuilder.DefineParameter (1, ParameterAttributes.In, "Message");
1779 + ctorBuilder.DefineParameter (2, ParameterAttributes.In, "Context");
1780 + ILGenerator code = ctorBuilder.GetILGenerator ();
1781 + code.Emit (OpCodes.Ldarg_0);
1782 + code.Emit (OpCodes.Ldarg_1);
1783 + code.Emit (OpCodes.Ldarg_2 );
1784 + code.Emit (OpCodes.Call,
1785 + typeException.GetConstructor (paramTypes));
1786 + code.Emit (OpCodes.Ret);
1787 +
1788 + if (mConfig.mVerbose)
1789 + Console.WriteLine ("> emitting exception type unoidl.com.sun.star.uno.RuntimeException");
1790 +
1791 + mTypeRuntimeException = typeBuilder.CreateType ();
1792 + }
1793 + }
1794 +
1795 + return mTypeRuntimeException;
1796 + }
1797 +
1798 + public Type GetType (UnoXServiceTypeDescription xtd)
1799 + {
1800 + // Console.WriteLine ("get service {0}", xtd.Name);
1801 +
1802 + if (!xtd.IsSingleInterfaceBased)
1803 + return null;
1804 +
1805 + string name = "unoidl." + xtd.Name;
1806 +
1807 + Type ret = GetType (name, false /* no exc */);
1808 +
1809 + if (ret != null)
1810 + return ret;
1811 +
1812 + TypeAttributes attr =
1813 + TypeAttributes.Public |
1814 + TypeAttributes.Sealed |
1815 + TypeAttributes.BeforeFieldInit |
1816 + TypeAttributes.AnsiClass;
1817 +
1818 + // insert to be completed
1819 + ServiceEntry entry = new ServiceEntry ();
1820 + entry.mType = xtd;
1821 + entry.mTypeBuilder = mModuleBuilder.DefineType (name, attr);
1822 + mIncompleteServices.Add (name, entry);
1823 +
1824 + return entry.mTypeBuilder;
1825 + }
1826 +
1827 + static void EmitLdarg (ILGenerator code, int index)
1828 + {
1829 + switch (index) {
1830 + case 0:
1831 + code.Emit( OpCodes.Ldarg_0 );
1832 + break;
1833 + case 1:
1834 + code.Emit( OpCodes.Ldarg_1 );
1835 + break;
1836 + case 2:
1837 + code.Emit( OpCodes.Ldarg_2 );
1838 + break;
1839 + case 3:
1840 + code.Emit( OpCodes.Ldarg_3 );
1841 + break;
1842 + default:
1843 + if (index < 0x100)
1844 + code.Emit (OpCodes.Ldarg_S, (byte) index);
1845 + else if (index < 0x8000)
1846 + code.Emit (OpCodes.Ldarg_S, (System.Int16) index);
1847 + else
1848 + code.Emit (OpCodes.Ldarg, index);
1849 + break;
1850 + }
1851 + }
1852 +
1853 + /** For example, there is a uno type
1854 + com.sun.star.Foo<char, long>.
1855 + The values in the type list
1856 + are uno types and are replaced by cli types, such as System.Char,
1857 + System.Int32, etc.
1858 +
1859 + Strings can be as complicated as this
1860 + test.MyStruct<char,test.MyStruct<long, []string>>
1861 + */
1862 + string MapUnoPolymorphicName (string unoName)
1863 + {
1864 + int index = unoName.IndexOf('<');
1865 + if (index == -1)
1866 + return unoName;
1867 +
1868 + System.Text.StringBuilder builder = new System.Text.StringBuilder (unoName.Substring (0, index + 1));
1869 +
1870 + //Find the first occurrence of ','
1871 + //If the parameter is a polymorphic struct then we neede to ignore everything
1872 + //between the brackets because it can also contain commas
1873 + //get the type list within < and >
1874 + int endIndex = unoName.Length - 1;
1875 + index ++;
1876 + int cur = index;
1877 + int countParams = 0;
1878 + while (cur <= endIndex) {
1879 + char c = unoName [cur];
1880 +
1881 + if (c == ',' || c == '>') {
1882 + //insert a comma if needed
1883 + if (countParams != 0)
1884 + builder.Append (",");
1885 + countParams++;
1886 + string param = unoName.Substring (index, cur - index);
1887 + //skip the comma
1888 + cur ++;
1889 + //the the index to the beginning of the next param
1890 + index = cur;
1891 + builder.Append (MapUnoTypeName (param));
1892 + } else if (c == '<') {
1893 + cur++;
1894 + //continue until the matching '>'
1895 + int numNested = 0;
1896 + for (;; cur ++) {
1897 + char curChar = unoName [cur];
1898 + if (curChar == '<')
1899 + numNested ++;
1900 + else if (curChar == '>') {
1901 + if (numNested > 0)
1902 + numNested --;
1903 + else
1904 + break;
1905 + }
1906 + }
1907 + }
1908 + cur ++;
1909 + }
1910 +
1911 + builder.Append ('>');
1912 + return builder.ToString();
1913 + }
1914 +
1915 + string MapUnoTypeName (string typeName)
1916 + {
1917 + System.Text.StringBuilder buf= new System.Text.StringBuilder ();
1918 + string unoName = String.Copy (typeName);
1919 +
1920 + //determine if the type is a sequence and its dimensions
1921 + int dims = 0;
1922 + if (typeName.StartsWith ("[")) {
1923 + int index= 1;
1924 + while (true) {
1925 + if (typeName [index ++] == ']')
1926 + dims++;
1927 + if (typeName [index ++] != '[')
1928 + break;
1929 + }
1930 + unoName = unoName.Substring (index - 1);
1931 + }
1932 +
1933 + if (unoName.Equals (Constants.UnoBool))
1934 + buf.Append (Constants.Boolean);
1935 + else if (unoName.Equals(Constants.UnoChar))
1936 + buf.Append (Constants.Char);
1937 + else if (unoName.Equals(Constants.UnoByte))
1938 + buf.Append (Constants.Byte);
1939 + else if (unoName.Equals(Constants.UnoShort))
1940 + buf.Append (Constants.Int16);
1941 + else if (unoName.Equals(Constants.UnoUShort))
1942 + buf.Append (Constants.UInt16);
1943 + else if (unoName.Equals(Constants.UnoLong))
1944 + buf.Append (Constants.Int32);
1945 + else if (unoName.Equals(Constants.UnoULong))
1946 + buf.Append (Constants.UInt32);
1947 + else if (unoName.Equals(Constants.UnoHyper))
1948 + buf.Append (Constants.Int64);
1949 + else if (unoName.Equals(Constants.UnoUHyper))
1950 + buf.Append (Constants.UInt64);
1951 + else if (unoName.Equals(Constants.UnoFloat))
1952 + buf.Append (Constants.Single);
1953 + else if (unoName.Equals(Constants.UnoDouble))
1954 + buf.Append (Constants.Double);
1955 + else if (unoName.Equals(Constants.UnoString))
1956 + buf.Append (Constants.String);
1957 + else if (unoName.Equals(Constants.UnoVoid))
1958 + buf.Append (Constants.Void);
1959 + else if (unoName.Equals(Constants.UnoType))
1960 + buf.Append (Constants.Type);
1961 + else if (unoName.Equals(Constants.UnoXInterface))
1962 + buf.Append (Constants.Object);
1963 + else if (unoName.Equals(Constants.UnoAny)) {
1964 + buf.Append (Constants.Any);
1965 + } else {
1966 + //put "unoidl." at the beginning
1967 + buf.Append (Constants.Unoidl);
1968 + buf.Append (MapUnoPolymorphicName (unoName));
1969 + }
1970 +
1971 + // apend []
1972 + for (;dims-- > 0;)
1973 + buf.Append (Constants.Brackets);
1974 +
1975 + // Console.WriteLine ("MapUnoTypeName {0} => {1}", typeName, buf.ToString ());
1976 +
1977 + return buf.ToString();
1978 + }
1979 +
1980 + public Type GetType (UnoXCompoundTypeDescription xtd)
1981 + {
1982 + // Console.WriteLine ("get compound type {0}", xtd.Name);
1983 +
1984 + if (xtd.TypeClass == UnoTypeClass.Exception) {
1985 + if (xtd.Name.Equals ("com.sun.star.uno.Exception"))
1986 + return TypeException ();
1987 +
1988 + if (xtd.Name.Equals ("com.sun.star.uno.RuntimeException"))
1989 + return TypeRuntimeException ();
1990 + }
1991 +
1992 + string name = "unoidl." + xtd.Name;
1993 +
1994 + // if the struct is an instantiated polymorpic struct then we create the simple struct name
1995 + // For example:
1996 + // void func ([in] PolyStruct<boolean> arg);
1997 + // PolyStruct<boolean> will be converted to PolyStruct
1998 + name = PolymorphicStructNameToStructName (name);
1999 +
2000 + Type ret = GetType (name, false /* no exc */);
2001 + UnoXStructTypeDescription xsd = xtd as UnoXStructTypeDescription;
2002 +
2003 + if (ret == null) {
2004 + // Console.WriteLine ("create compound type {0}", name);
2005 + UnoXTypeDescription baseTD = xtd.BaseType;
2006 + Type baseType = baseTD != null ? GetType (baseTD) : typeof (object);
2007 + CustomAttributeBuilder attrBuilder;
2008 + TypeBuilder typeBuilder = mModuleBuilder.DefineType (name,
2009 + TypeAttributes.Public |
2010 + TypeAttributes.BeforeFieldInit |
2011 + TypeAttributes.AnsiClass,
2012 + baseType);
2013 + int i;
2014 +
2015 + // Polymorphic struct, define uno.TypeParametersAttribute
2016 + // A polymorphic struct cannot have a basetype.
2017 + // When we create the template of the struct then we have no exact types
2018 + // and the name does not contain a parameter list
2019 + if (xsd != null && xsd.TypeParameters > 0) {
2020 + object[] args = new object [xsd.TypeParameters];
2021 +
2022 + for (i = 0; i < xsd.TypeParameters; i ++)
2023 + args [i] = xsd.TypeParameter (i);
2024 + object[] aargs = { args };
2025 +
2026 + Type[] typesCtor = { typeof (string[]) };
2027 + attrBuilder = new CustomAttributeBuilder (typeof (uno.TypeParametersAttribute).GetConstructor (typesCtor), aargs);
2028 + typeBuilder.SetCustomAttribute (attrBuilder);
2029 + }
2030 +
2031 + // optional: lookup base type whether generated entry of this session
2032 + StructEntry baseTypeEntry = null;
2033 + if (baseType != null)
2034 + baseTypeEntry = (StructEntry) mGeneratedStructs [baseType.FullName];
2035 +
2036 + // members
2037 + for (i = 0; i < xtd.MemberTypes; i ++) {
2038 + if (xtd.MemberType (i) == null)
2039 + throw new Exception ("Missing type description . Check if you need to " +
2040 + "specify additional RDBs with the --extra option. Type missing for: " +
2041 + xtd.Name + "::" + xtd.MemberName (i));
2042 + }
2043 +
2044 + // collect base types; wrong order
2045 + ArrayList baseTypes = new ArrayList (3);
2046 + int allMembersLength = 0;
2047 + for (Type baseTypePos = baseType; !baseTypePos.Equals (typeof (object)); baseTypePos = baseTypePos.BaseType) {
2048 + baseTypes.Add (baseTypePos);
2049 + if (baseTypePos.Equals (typeof (System.Exception))) {
2050 + // special Message member
2051 + allMembersLength ++;
2052 + break; // don't include System.Exception base classes
2053 + } else {
2054 + allMembersLength += baseTypePos.GetFields (BindingFlags.Instance |
2055 + BindingFlags.Public |
2056 + BindingFlags.DeclaredOnly).Length;
2057 + }
2058 + }
2059 +
2060 + // create all_members arrays; right order
2061 + string[] allMemberNames = new string [allMembersLength + xtd.MemberTypes];
2062 + Type[] allParamTypes = new Type [allMembersLength + xtd.MemberTypes];
2063 + int memberPos = 0;
2064 + for (i = baseTypes.Count - 1; i >= 0; i--) {
2065 + Type type = baseTypes [i] as Type;
2066 +
2067 + if (type.Equals (typeof (System.Exception))) {
2068 + allMemberNames [memberPos] = "Message";
2069 + allParamTypes [memberPos] = typeof (string);
2070 + memberPos ++;
2071 + } else {
2072 + StructEntry baseEntry = mGeneratedStructs [type.FullName] as StructEntry;
2073 + if (baseEntry == null) {
2074 + // complete type
2075 + FieldInfo[] fields = type.GetFields (BindingFlags.Instance |
2076 + BindingFlags.Public |
2077 + BindingFlags.DeclaredOnly);
2078 + foreach (FieldInfo fieldInfo in fields) {
2079 + allMemberNames [memberPos] = fieldInfo.Name;
2080 + allParamTypes [memberPos] = fieldInfo.FieldType;
2081 + memberPos ++;
2082 + }
2083 + } else {
2084 + // generated during this session:
2085 + // members may be incomplete ifaces
2086 + int j;
2087 + for (j = 0; j < baseEntry.mParamTypes.Length; j ++) {
2088 + allMemberNames [memberPos] = baseEntry.mMemberNames [j];
2089 + allParamTypes [memberPos] = baseEntry.mParamTypes [j];
2090 + memberPos ++;
2091 + }
2092 + }
2093 + }
2094 + }
2095 + if (allMembersLength != memberPos)
2096 + throw new Exception ("something went wrong, allMembersLength != memberPos");
2097 +
2098 +
2099 + // build up entry
2100 + StructEntry entry = new StructEntry ();
2101 + entry.mMemberNames = new string [xtd.MemberTypes];
2102 + entry.mParamTypes = new Type [xtd.MemberTypes];
2103 +
2104 + // add members
2105 + FieldBuilder[] members = new FieldBuilder [xtd.MemberTypes];
2106 + int curParamIndex = 0;
2107 + int typeParamPos = 0;
2108 +
2109 + for (memberPos = 0; memberPos < xtd.MemberTypes; memberPos ++) {
2110 + string fieldName = xtd.MemberName (memberPos);
2111 + Type fieldType;
2112 +
2113 + //Special handling of struct parameter types
2114 + bool parameterizedType = false;
2115 + if (xtd.MemberType (memberPos).TypeClass == UnoTypeClass.Unknown) {
2116 + parameterizedType = true;
2117 + if (xsd != null && typeParamPos < xsd.TypeParameters) {
2118 + fieldType = typeof (object);
2119 + typeParamPos ++;
2120 + } else {
2121 + throw new Exception ("unexpected member type in " + xtd.Name);
2122 + }
2123 + } else {
2124 + fieldType = GetType (xtd.MemberType (memberPos));
2125 + }
2126 + members [memberPos] = typeBuilder.DefineField (fieldName, fieldType, FieldAttributes.Public);
2127 +
2128 + //parameterized type (polymorphic struct) ?
2129 + if (parameterizedType && xsd != null) {
2130 + object[] args = { xsd.TypeParameter (curParamIndex ++) };
2131 + Type[] ctorTypes = { typeof (string) };
2132 + attrBuilder = new CustomAttributeBuilder (typeof (uno.ParameterizedTypeAttribute).GetConstructor (ctorTypes), args);
2133 + members [memberPos].SetCustomAttribute (attrBuilder);
2134 + }
2135 +
2136 + // add to all_members
2137 + allMemberNames [allMembersLength + memberPos] = fieldName;
2138 + allParamTypes [allMembersLength + memberPos] = fieldType;
2139 +
2140 + // add to entry
2141 + entry.mMemberNames [memberPos] = fieldName;
2142 + entry.mParamTypes [memberPos] = fieldType;
2143 + }
2144 +
2145 + allMembersLength += xtd.MemberTypes;
2146 +
2147 + // default .ctor
2148 + ConstructorBuilder ctorBuilder = typeBuilder.DefineConstructor (cCtorMethodAttr, CallingConventions.Standard, new Type [0]);
2149 + ILGenerator code = ctorBuilder.GetILGenerator ();
2150 +
2151 + code.Emit (OpCodes.Ldarg_0);
2152 + // Console.WriteLine ("baseType: {0}", baseType);
2153 + code.Emit (OpCodes.Call, baseTypeEntry == null ? baseType.GetConstructor (new Type [0]) : baseTypeEntry.mDefaultConstructor);
2154 +
2155 + // default initialize members
2156 + for (memberPos = 0; memberPos < xtd.MemberTypes; memberPos ++) {
2157 + FieldInfo fieldInfo = members [memberPos];
2158 +
2159 + // default initialize
2160 + // string, type, enum, sequence, struct, exception, any
2161 + if (fieldInfo.FieldType.Equals (typeof (string))) {
2162 + code.Emit (OpCodes.Ldarg_0);
2163 + code.Emit (OpCodes.Ldstr, "");
2164 + code.Emit (OpCodes.Stfld, fieldInfo);
2165 + } else if (fieldInfo.FieldType.Equals (typeof (Type))) {
2166 + code.Emit (OpCodes.Ldarg_0);
2167 + code.Emit (OpCodes.Ldtoken, typeof (void));
2168 + code.Emit (OpCodes.Call, mMethodInfoTypeGetTypeFromHandle);
2169 + code.Emit (OpCodes.Stfld, fieldInfo);
2170 + } else if (fieldInfo.FieldType.IsArray) {
2171 + code.Emit (OpCodes.Ldarg_0);
2172 + code.Emit (OpCodes.Ldc_I4_0);
2173 + code.Emit (OpCodes.Newarr, fieldInfo.FieldType.GetElementType ());
2174 + code.Emit (OpCodes.Stfld, fieldInfo);
2175 + } else if (fieldInfo.FieldType.IsValueType) {
2176 + if (fieldInfo.FieldType.FullName.Equals ("uno.Any")) {
2177 + code.Emit (OpCodes.Ldarg_0);
2178 + code.Emit (OpCodes.Ldsfld, typeof (uno.Any).GetField ("VOID"));
2179 + code.Emit (OpCodes.Stfld, fieldInfo);
2180 + }
2181 + } else if (fieldInfo.FieldType.IsClass) {
2182 + // may be XInterface
2183 + if (!fieldInfo.FieldType.Equals (typeof (object))) {
2184 + code.Emit (OpCodes.Ldarg_0);
2185 + code.Emit (OpCodes.Newobj, fieldInfo.FieldType.GetConstructor (new Type [0]));
2186 + code.Emit (OpCodes.Stfld, fieldInfo);
2187 + }
2188 + }
2189 + }
2190 +
2191 + code.Emit (OpCodes.Ret);
2192 + entry.mDefaultConstructor = ctorBuilder;
2193 +
2194 + // parameterized .ctor including all base members
2195 + ctorBuilder = typeBuilder.DefineConstructor (cCtorMethodAttr, CallingConventions.Standard, allParamTypes);
2196 + for (memberPos = 0; memberPos < allMembersLength; memberPos ++)
2197 + ctorBuilder.DefineParameter (memberPos + 1, ParameterAttributes.In, allMemberNames [memberPos]);
2198 +
2199 + code = ctorBuilder.GetILGenerator ();
2200 + // call base .ctor
2201 + code.Emit (OpCodes.Ldarg_0); // push this
2202 + int baseMembersLength = allMembersLength - xtd.MemberTypes;
2203 + Type[] paramTypes = new Type [baseMembersLength];
2204 +
2205 + for (memberPos = 0; memberPos < baseMembersLength; memberPos ++) {
2206 + EmitLdarg (code, memberPos + 1);
2207 + paramTypes [memberPos] = allParamTypes [memberPos];
2208 + }
2209 +
2210 + code.Emit (OpCodes.Call, baseTypeEntry == null ? baseType.GetConstructor (paramTypes) : baseTypeEntry.mConstructor);
2211 +
2212 + // initialize members
2213 +
2214 + for (memberPos = 0; memberPos < xtd.MemberTypes; memberPos ++) {
2215 + code.Emit (OpCodes.Ldarg_0); // push this
2216 + EmitLdarg (code, memberPos + baseMembersLength + 1);
2217 + code.Emit (OpCodes.Stfld, members [memberPos]);
2218 + }
2219 +
2220 + code.Emit (OpCodes.Ret);
2221 + entry.mConstructor = ctorBuilder;
2222 +
2223 + if (mConfig.mVerbose)
2224 + Console.WriteLine ("> emitting {0} type {1}", xtd is UnoXStructTypeDescription ? "struct" : "exception", name);
2225 +
2226 + // new entry
2227 + mGeneratedStructs.Add (name, entry);
2228 + //Console.WriteLine ("added entry to mGeneratedStructs: {0}", name);
2229 + //if (baseTD != null)
2230 + //Console.WriteLine ("baseTD: {0}", baseTD.Name, GetType (baseTD).Name);
2231 + ret = typeBuilder.CreateType ();
2232 + }
2233 +
2234 + // In case of an instantiated polymorphic struct we want to return a
2235 + // uno.PolymorphicType (inherits Type) rather then Type.
2236 + if (xsd != null && xsd.TypeArguments > 0) {
2237 + //Console.WriteLine ("polymorphic struct: call uno.PolymorphicType.GetType ({0}, {1})", ret, xtd.Name);
2238 + ret = uno.PolymorphicType.GetType (ret, MapUnoTypeName (xtd.Name));
2239 + //Console.WriteLine ("polymorphic struct: {0} ({1})", ret, xtd.Name);
2240 + }
2241 +
2242 + return ret;
2243 + }
2244 +
2245 + public Type GetType (UnoXConstantTypeDescription xtd)
2246 + {
2247 + //Console.WriteLine ("get constant type {0}", xtd.Name);
2248 +
2249 + string name = "unoidl." + xtd.Name;
2250 +
2251 + Type ret = GetType (name, false /* no exc */);
2252 +
2253 + if (ret == null) {
2254 + object constant = xtd.ConstantValue;
2255 +
2256 + TypeBuilder typeBuilder = mModuleBuilder.DefineType (name,
2257 + TypeAttributes.Public |
2258 + TypeAttributes.Sealed |
2259 + TypeAttributes.BeforeFieldInit |
2260 + TypeAttributes.AnsiClass);
2261 + FieldBuilder field = typeBuilder.DefineField (name.Substring (name.LastIndexOf ('.') + 1),
2262 + constant.GetType (),
2263 + FieldAttributes.Public |
2264 + FieldAttributes.Static |
2265 + FieldAttributes.Literal);
2266 + field.SetConstant (constant);
2267 +
2268 + if (mConfig.mVerbose)
2269 + Console.WriteLine ("> emitting constant type {0}", name);
2270 +
2271 + ret = typeBuilder.CreateType ();
2272 + }
2273 +
2274 + return ret;
2275 + }
2276 +
2277 + public Type GetType (UnoXConstantsTypeDescription xtd)
2278 + {
2279 + //Console.WriteLine ("get constants type {0}", xtd.Name);
2280 +
2281 + string name = "unoidl." + xtd.Name;
2282 +
2283 + Type ret = GetType (name, false /* no exc */);
2284 +
2285 + if (ret == null) {
2286 + TypeBuilder typeBuilder = mModuleBuilder.DefineType (name,
2287 + TypeAttributes.Public |
2288 + TypeAttributes.Sealed |
2289 + TypeAttributes.BeforeFieldInit |
2290 + TypeAttributes.AnsiClass);
2291 + int i;
2292 + for (i = 0; i < xtd.Constants; i ++) {
2293 + UnoXConstantTypeDescription constantTD = xtd.Constant (i);
2294 + object constant = constantTD.ConstantValue;
2295 + FieldBuilder field = typeBuilder.DefineField (constantTD.Name.Substring (constantTD.Name.LastIndexOf ('.') + 1),
2296 + constant.GetType (),
2297 + FieldAttributes.Public |
2298 + FieldAttributes.Static |
2299 + FieldAttributes.Literal);
2300 + field.SetConstant (constant);
2301 + }
2302 +
2303 + if (mConfig.mVerbose)
2304 + Console.WriteLine ( "> emitting constants group type {0}", name);
2305 +
2306 + ret = typeBuilder.CreateType ();
2307 + }
2308 +
2309 + return ret;
2310 + }
2311 +
2312 + public Type GetType (UnoXSingletonTypeDescription xtd)
2313 + {
2314 + //Console.WriteLine ("get singleton {0}", xtd.Name);
2315 +
2316 + if (!xtd.IsInterfaceBased)
2317 + return null;
2318 +
2319 + //Console.WriteLine ("singleton {0} is interface based", xtd.Name);
2320 +
2321 + string name = "unoidl." + xtd.Name;
2322 +
2323 + Type ret = GetType (name, false /* no exc */);
2324 +
2325 + if (ret != null)
2326 + return ret;
2327 +
2328 + TypeAttributes attr =
2329 + TypeAttributes.Public |
2330 + TypeAttributes.Sealed |
2331 + TypeAttributes.BeforeFieldInit |
2332 + TypeAttributes.AnsiClass;
2333 +
2334 + // insert to be completed
2335 + SingletonEntry entry = new SingletonEntry ();
2336 + entry.mType = xtd;
2337 + entry.mTypeBuilder = mModuleBuilder.DefineType (name, attr);
2338 + mIncompleteSingletons.Add (name, entry);
2339 +
2340 + return entry.mTypeBuilder;
2341 + }
2342 +
2343 + public Type GetType (UnoXTypeDescription xtd)
2344 + {
2345 + UnoTypeClass tc = xtd.TypeClass;
2346 +
2347 + switch (tc) {
2348 + case UnoTypeClass.Void:
2349 + return typeof (void);
2350 + case UnoTypeClass.Char:
2351 + return typeof (char);
2352 + case UnoTypeClass.Boolean:
2353 + return typeof (bool);
2354 + case UnoTypeClass.Byte:
2355 + return typeof (byte);
2356 + case UnoTypeClass.Short:
2357 + return typeof (Int16);
2358 + case UnoTypeClass.UnsignedShort:
2359 + return typeof (UInt16);
2360 + case UnoTypeClass.Long:
2361 + return typeof (Int32);
2362 + case UnoTypeClass.UnsignedLong:
2363 + return typeof (UInt32);
2364 + case UnoTypeClass.Hyper:
2365 + return typeof (Int64);
2366 + case UnoTypeClass.UnsignedHyper:
2367 + return typeof (UInt64);
2368 + case UnoTypeClass.Float:
2369 + return typeof (Single);
2370 + case UnoTypeClass.Double:
2371 + return typeof (double);
2372 + case UnoTypeClass.String:
2373 + return typeof (string);
2374 + case UnoTypeClass.Type:
2375 + return typeof (Type);
2376 + case UnoTypeClass.Any:
2377 + return typeof (uno.Any);
2378 + case UnoTypeClass.Enum:
2379 + return GetType (xtd as UnoXEnumTypeDescription);
2380 + case UnoTypeClass.Interface:
2381 + return GetType (xtd as UnoXInterfaceTypeDescription);
2382 + case UnoTypeClass.Struct:
2383 + case UnoTypeClass.Exception:
2384 + return GetType (xtd as UnoXCompoundTypeDescription);
2385 + case UnoTypeClass.Module:
2386 + return null;
2387 + case UnoTypeClass.Sequence:
2388 + Type elementType = GetType ((xtd as UnoXIndirectTypeDescription).ReferencedType);
2389 + Type retType = GetType (elementType.FullName + "[]", true);
2390 + uno.PolymorphicType polyType = elementType as uno.PolymorphicType;
2391 + if (polyType != null) {
2392 + string name = polyType.PolymorphicName + "[]";
2393 + retType = uno.PolymorphicType.GetType (retType, name);
2394 + }
2395 + return retType;
2396 + case UnoTypeClass.Typedef:
2397 + return GetType ((xtd as UnoXIndirectTypeDescription).ReferencedType);
2398 + case UnoTypeClass.Constant:
2399 + return GetType (xtd as UnoXConstantTypeDescription);
2400 + case UnoTypeClass.Constants:
2401 + return GetType (xtd as UnoXConstantsTypeDescription);
2402 + case UnoTypeClass.Service:
2403 + return GetType (xtd as UnoXServiceTypeDescription);
2404 + case UnoTypeClass.Singleton:
2405 + return GetType (xtd as UnoXSingletonTypeDescription);
2406 + default:
2407 + // fixme, use double for unfinished types
2408 + //Console.WriteLine ("warning: unfinished type reached: {0}", xtd.Name);
2409 + return typeof (void);
2410 + }
2411 +
2412 + //throw new Exception (String.Format ("Unknown type requested {0}", tc));
2413 + }
2414 +
2415 + CustomAttributeBuilder IFaceMethodExceptionAttribute (UnoXInterfaceMethodTypeDescription method)
2416 + {
2417 + Type[] exceptionTypes = new Type [method.ExceptionTypes];
2418 + int i;
2419 +
2420 + for (i = 0; i < method.ExceptionTypes; i ++) {
2421 + exceptionTypes [i] = GetType (method.ExceptionType (i));
2422 + }
2423 +
2424 + return ExceptionAttribute (exceptionTypes);
2425 + }
2426 +
2427 + CustomAttributeBuilder ExceptionAttribute (Type[] exceptionTypes)
2428 + {
2429 + CustomAttributeBuilder attrBuilder = null;
2430 +
2431 + if (exceptionTypes.Length > 0) {
2432 + object[] args = { exceptionTypes };
2433 + Type[] arTypesCtor = { typeof (Type[]) };
2434 + ConstructorInfo ctorInfo = typeof (uno.ExceptionAttribute).GetConstructor (arTypesCtor);
2435 + attrBuilder = new CustomAttributeBuilder (ctorInfo, args);
2436 + }
2437 +
2438 + return attrBuilder;
2439 + }
2440 +
2441 + Type[] GetTypes (UnoXTypeDescription[] tds)
2442 + {
2443 + Type[] types = new Type [tds.Length];
2444 + int i;
2445 +
2446 + for (i = 0; i < tds.Length; i ++)
2447 + types [i] = GetType (tds [i]);
2448 +
2449 + return types;
2450 + }
2451 +
2452 + Type CompleteIFaceType (IFaceEntry entry)
2453 + {
2454 + //Console.WriteLine ("going to complete {0}", entry.mTypeBuilder.FullName);
2455 +
2456 + // complete base interfaces first
2457 + foreach (Type type in entry.mTypeBuilder.GetInterfaces ()) {
2458 + IFaceEntry baseEntry = mIncompleteIFaces [type.FullName] as IFaceEntry;
2459 + if (baseEntry != null)
2460 + CompleteIFaceType (baseEntry);
2461 + }
2462 +
2463 + // emit members
2464 + const MethodAttributes methodAttr =
2465 + MethodAttributes.Public |
2466 + MethodAttributes.Abstract |
2467 + MethodAttributes.Virtual |
2468 + MethodAttributes.NewSlot |
2469 + MethodAttributes.HideBySig;
2470 + int i;
2471 +
2472 + for (i = 0; i < entry.mType.Members; i ++) {
2473 + UnoXInterfaceMemberTypeDescription member = entry.mType.Member (i);
2474 + MethodBuilder methodBuilder;
2475 + CustomAttributeBuilder attrBuilder;
2476 +
2477 + if (member.TypeClass == UnoTypeClass.InterfaceMethod) {
2478 + UnoXInterfaceMethodTypeDescription method = new UnoXInterfaceMethodTypeDescription (member.Handle);
2479 + UnoXMethodParameter[] parameters = new UnoXMethodParameter [method.Parameters];
2480 + Type[] pTypes = new Type [method.Parameters];
2481 + int j;
2482 +
2483 + //Console.WriteLine ("method {0}.{1}", entry.mTypeBuilder.FullName, method.MemberName);
2484 +
2485 + // first determine all types
2486 + for (j = 0; j < method.Parameters; j ++) {
2487 + parameters [j] = method.Parameter (j);
2488 + pTypes [j] = GetType (parameters [j].Type);
2489 + if (parameters [j].IsOut)
2490 + pTypes [j] = GetType (pTypes [j].FullName + "&", true);
2491 + }
2492 +
2493 + // create method
2494 + methodBuilder = entry.mTypeBuilder.DefineMethod (method.MemberName,
2495 + methodAttr,
2496 + GetType (method.ReturnType),
2497 + pTypes);
2498 +
2499 + // then define parameter infos
2500 + for (j = 0; j < method.Parameters; j ++) {
2501 + ParameterAttributes attr = 0;
2502 + if (parameters [j].IsIn)
2503 + attr |= ParameterAttributes.In;
2504 + if (parameters [j].IsOut)
2505 + attr |= ParameterAttributes.Out;
2506 +
2507 + if (attr == 0)
2508 + throw new Exception ("wrong parameter attributes");
2509 +
2510 + methodBuilder.DefineParameter (parameters [j].Position + 1,
2511 + attr,
2512 + parameters [j].Name);
2513 + }
2514 +
2515 + if (method.ReturnsStruct) {
2516 + //Console.WriteLine ("returns struct");
2517 +
2518 + UnoXStructTypeDescription std = method.ReturnType as UnoXStructTypeDescription;
2519 + Type[] ats = new Type [std.TypeArguments];
2520 +
2521 + //Console.WriteLine ("type arguments: {0}", std.TypeArguments);
2522 +
2523 + for (j = 0; j < std.TypeArguments; j ++) {
2524 + ats [j] = GetType (std.TypeArgument (j));
2525 + //Console.WriteLine ("ats [{0}] = {1}", j, ats [j]);
2526 + }
2527 +
2528 + object[] atso = { ats };
2529 + Type[] ctor = { typeof (Type[]) };
2530 + attrBuilder = new CustomAttributeBuilder (typeof (uno.TypeArgumentsAttribute).GetConstructor (ctor),
2531 + atso);
2532 + methodBuilder.SetCustomAttribute (attrBuilder);
2533 + }
2534 +
2535 + // define UNO exception attribute (exceptions) --------------------------------------
2536 + attrBuilder = IFaceMethodExceptionAttribute (method);
2537 + if (attrBuilder != null)
2538 + methodBuilder.SetCustomAttribute (attrBuilder);
2539 +
2540 + // oneway attribute
2541 + if (method.IsOneway) {
2542 + Type[] arCtorOneway = new Type [0];
2543 + object[] arArgs = new object [0];
2544 + attrBuilder = new CustomAttributeBuilder (typeof (uno.OnewayAttribute).GetConstructor (arCtorOneway),
2545 + arArgs);
2546 + methodBuilder.SetCustomAttribute (attrBuilder);
2547 + }
2548 + } else {
2549 + // attribute
2550 + if (member.TypeClass != UnoTypeClass.InterfaceAttribute)
2551 + throw new Exception (String.Format ("Unknown member type class: {0} ", member.TypeClass));
2552 +
2553 + UnoXInterfaceAttributeTypeDescription attribute = new UnoXInterfaceAttributeTypeDescription (member.Handle);
2554 + const MethodAttributes propMethodAttr = methodAttr | MethodAttributes.SpecialName;
2555 +
2556 + Type attrType = GetType (attribute.Type);
2557 + //Console.WriteLine ("attribute {2} type: {0} => {1}", attribute.Type, attrType, attribute.Name);
2558 + Type[] parameters = new Type [0];
2559 +
2560 + PropertyBuilder propBuilder = entry.mTypeBuilder.DefineProperty (attribute.MemberName, PropertyAttributes.None, attrType, parameters);
2561 +
2562 + //set BoundAttribute, if necessary
2563 + if (attribute.IsBound) {
2564 + ConstructorInfo ctorBoundAttr = typeof (uno.BoundAttribute).GetConstructor (new Type [0]);
2565 + attrBuilder = new CustomAttributeBuilder (ctorBoundAttr, new object [0]);
2566 + propBuilder.SetCustomAttribute (attrBuilder);
2567 + }
2568 +
2569 + // getter
2570 + methodBuilder = entry.mTypeBuilder.DefineMethod ("get_" + attribute.MemberName,
2571 + propMethodAttr, attrType, parameters);
2572 +
2573 + attrBuilder = ExceptionAttribute (GetTypes (attribute.GetExceptionTypes));
2574 + if (attrBuilder != null)
2575 + methodBuilder.SetCustomAttribute (attrBuilder);
2576 +
2577 + propBuilder.SetGetMethod (methodBuilder);
2578 +
2579 + if (!attribute.IsReadOnly) {
2580 + // setter
2581 + parameters = new Type [1];
2582 + parameters [0] = attrType;
2583 + //parameters [0] = null;
2584 + //Console.WriteLine ("setter parameters: {0} ({1})", parameters, parameters [0]);
2585 + methodBuilder = entry.mTypeBuilder.DefineMethod ("set_" + attribute.MemberName,
2586 + propMethodAttr, typeof (void), parameters);
2587 + methodBuilder.DefineParameter (1, ParameterAttributes.In, "value");
2588 +
2589 + attrBuilder = ExceptionAttribute (GetTypes (attribute.SetExceptionTypes));
2590 + if (attrBuilder != null)
2591 + methodBuilder.SetCustomAttribute (attrBuilder);
2592 +
2593 + propBuilder.SetSetMethod (methodBuilder);
2594 + }
2595 + }
2596 + }
2597 + // cmm_x_interface_type_description_members_release (membersHandle);
2598 +
2599 + if (mConfig.mVerbose)
2600 + Console.WriteLine ("> emitting interface type {0}", "unoidl." + entry.mType.Name);
2601 +
2602 + mIncompleteIFaces.Remove (entry.mTypeBuilder.FullName);
2603 +
2604 + //Console.WriteLine ("completed {0}", entry.mTypeBuilder.FullName);
2605 +
2606 + return entry.mTypeBuilder.CreateType ();
2607 + }
2608 +
2609 + UnoXInterfaceTypeDescription ResolveInterfaceTypedef (UnoXTypeDescription xtd)
2610 + {
2611 + UnoXInterfaceTypeDescription xtdIface = xtd as UnoXInterfaceTypeDescription;
2612 +
2613 + if (xtdIface != null)
2614 + return xtdIface;
2615 +
2616 + UnoXIndirectTypeDescription xtdIndirect = xtd as UnoXIndirectTypeDescription;
2617 +
2618 + if (xtdIndirect != null)
2619 + return ResolveInterfaceTypedef (xtdIndirect.ReferencedType);;
2620 +
2621 + throw new Exception ("resolveInterfaceTypedef was called with an invalid argument");
2622 + }
2623 +
2624 + ArrayList GetServiceConstructorMethodExceptionsReduced (UnoXTypeDescription[] exceptionTypes)
2625 + {
2626 + if (exceptionTypes.Length == 0)
2627 + return new ArrayList ();
2628 +
2629 + ArrayList types = new ArrayList();
2630 + int i;
2631 +
2632 + for (i = 0; i < exceptionTypes.Length; i ++)
2633 + types.Add (GetType ("unoidl." + exceptionTypes [i].Name, true));
2634 +
2635 + int start = 0;
2636 + while (true) {
2637 + bool bRemove = false;
2638 +
2639 + for (i = start; i < types.Count; i ++) {
2640 + Type t = types [i] as Type;
2641 + int j;
2642 +
2643 + for (j = 0; j < types.Count; j ++) {
2644 + if (t.IsSubclassOf (types [j] as Type)) {
2645 + types.RemoveAt (i);
2646 + bRemove = true;
2647 + break;
2648 + }
2649 + }
2650 + if (bRemove)
2651 + break;
2652 + start ++;
2653 + }
2654 +
2655 + if (bRemove == false)
2656 + break;
2657 + }
2658 +
2659 + return types;
2660 + }
2661 +
2662 + Type CompleteServiceType (ServiceEntry entry)
2663 + {
2664 + // Create the private default constructor
2665 + ConstructorBuilder ctorBuilder = entry.mTypeBuilder.DefineConstructor (MethodAttributes.Private |
2666 + MethodAttributes.HideBySig |
2667 + MethodAttributes.SpecialName |
2668 + MethodAttributes.RTSpecialName,
2669 + CallingConventions.Standard,
2670 + null);
2671 +
2672 + ILGenerator ilGen = ctorBuilder.GetILGenerator ();
2673 + ilGen.Emit (OpCodes.Ldarg_0); // push this
2674 + ilGen.Emit (OpCodes.Call, entry.mTypeBuilder.BaseType.GetConstructor (new Type[0]));
2675 + ilGen.Emit (OpCodes.Ret);
2676 +
2677 + // Create the service constructors.
2678 + // obtain the interface which makes up this service, it is the return
2679 + // type of the constructor functions
2680 + UnoXInterfaceTypeDescription iface = entry.mType.Interface as UnoXInterfaceTypeDescription;
2681 +
2682 + if (iface == null)
2683 + iface = ResolveInterfaceTypedef (entry.mType.Interface);
2684 +
2685 + Type ret = GetType (iface);
2686 +
2687 + // Create the ConstructorInfo for a DeploymentException
2688 + Type typeDeploymentException = GetType ("unoidl.com.sun.star.uno.DeploymentException", true);
2689 + Type[] arTypeCtor = { typeof (string), typeof (object) };
2690 + ConstructorInfo ctorDeploymentException = typeDeploymentException.GetConstructor (arTypeCtor);
2691 +
2692 + Type typeUnoException = GetType ("unoidl.com.sun.star.uno.Exception", true);
2693 + int i, j;
2694 +
2695 + for (i = entry.mType.Constructors - 1; i >= 0; i --) {
2696 + bool bParameterArray = false;
2697 + UnoXServiceConstructorDescription ctorDesc = entry.mType.Constructor (i);
2698 + Type[] typeParameters = new Type [ctorDesc.Parameters + 1];
2699 + typeParameters [0] = GetType ("unoidl.com.sun.star.uno.XComponentContext", true);
2700 +
2701 + for (j = 0; j < ctorDesc.Parameters; j ++) {
2702 + UnoXParameter parameter = ctorDesc.Parameter (j);
2703 +
2704 + if (parameter.IsRest)
2705 + typeParameters [j + 1] = typeof (uno.Any[]);
2706 + else
2707 + typeParameters [j + 1] = GetType (parameter.Type);
2708 + }
2709 +
2710 + // The array typeParameters can contain:
2711 + // System.Type and uno.PolymorphicType.
2712 + // Passing PolymorphicType to MethodBuilder.DefineMethod will cause a problem.
2713 + // The exception will read something like no on information for parameter # d
2714 + // Maybe we need no override another Type method in PolymorphicType ...
2715 + // Until we have figured this out, we will create another array of System.Type which
2716 + // we pass on to DefineMethod.
2717 +
2718 + Type[] paramTypes = new Type [ctorDesc.Parameters + 1];
2719 +
2720 + for (j = 0; j < ctorDesc.Parameters + 1; j ++) {
2721 + if (typeParameters [j] is uno.PolymorphicType)
2722 + paramTypes [j] = (typeParameters [j] as uno.PolymorphicType).OriginalType;
2723 + else
2724 + paramTypes [j] = typeParameters [j];
2725 + }
2726 +
2727 + //define method
2728 + string ctorName;
2729 + if (ctorDesc.IsDefault)
2730 + ctorName = "create";
2731 + else
2732 + ctorName = ctorDesc.Name;
2733 +
2734 + MethodBuilder methodBuilder = entry.mTypeBuilder.DefineMethod (ctorName,
2735 + MethodAttributes.Public |
2736 + MethodAttributes.HideBySig |
2737 + MethodAttributes.Static,
2738 + ret,
2739 + paramTypes);
2740 +
2741 + //define UNO exception attribute (exceptions)--------------------------------------
2742 + CustomAttributeBuilder attrBuilder = ExceptionAttribute (GetTypes (ctorDesc.ExceptionTypes));
2743 + if (attrBuilder != null)
2744 + methodBuilder.SetCustomAttribute (attrBuilder);
2745 +
2746 + // define parameter attributes (paramarray), names etc.
2747 + // The first parameter is the XComponentContext, which cannot be obtained
2748 + // from reflection.
2749 + // The context is not part of the idl description
2750 +
2751 + methodBuilder.DefineParameter (1, ParameterAttributes.In, "the_context");
2752 +
2753 + ParameterBuilder[] parameterBuilder = new ParameterBuilder [ctorDesc.Parameters];
2754 + int iparam;
2755 +
2756 + for (iparam = 0; iparam < ctorDesc.Parameters; iparam ++) {
2757 + UnoXParameter parameter = ctorDesc.Parameter (iparam);
2758 +
2759 + parameterBuilder [iparam] = methodBuilder.DefineParameter (iparam + 2, ParameterAttributes.In, parameter.Name);
2760 +
2761 + if (parameter.IsRest) {
2762 + bParameterArray = true;
2763 + //set the ParameterArrayAttribute
2764 + ConstructorInfo ctorInfo = typeof (System.ParamArrayAttribute).GetConstructor (new Type [0]);
2765 + attrBuilder = new CustomAttributeBuilder (ctorInfo, new object [0]);
2766 +
2767 + parameterBuilder[iparam].SetCustomAttribute (attrBuilder);
2768 + break;
2769 + }
2770 + }
2771 +
2772 + ilGen = methodBuilder.GetILGenerator ();
2773 +
2774 + // Define locals ---------------------------------
2775 + // XMultiComponentFactory
2776 + LocalBuilder localFactory = ilGen.DeclareLocal (GetType ("unoidl.com.sun.star.lang.XMultiComponentFactory", true));
2777 +
2778 + // The return type
2779 + LocalBuilder localReturnVal = ilGen.DeclareLocal (ret);
2780 +
2781 + // Obtain the XMultiComponentFactory and throw an exception if we do not get one
2782 + ilGen.Emit (OpCodes.Ldarg_0);
2783 +
2784 + MethodInfo methodGetServiceManager = GetType ("unoidl.com.sun.star.uno.XComponentContext", true).GetMethod ("getServiceManager");
2785 + ilGen.Emit (OpCodes.Callvirt, methodGetServiceManager);
2786 + ilGen.Emit (OpCodes.Stloc, localFactory);
2787 + ilGen.Emit (OpCodes.Ldloc, localFactory);
2788 + Label label1 = ilGen.DefineLabel ();
2789 + ilGen.Emit (OpCodes.Brtrue, label1);
2790 +
2791 + // The string for the exception
2792 + System.Text.StringBuilder strBuilder = new System.Text.StringBuilder (256);
2793 +
2794 + strBuilder.Append ("The service ");
2795 + strBuilder.Append ("unoidl." + entry.mType.Name);
2796 + strBuilder.Append (" could not be created. The context failed to supply the service manager.");
2797 +
2798 + ilGen.Emit (OpCodes.Ldstr, strBuilder.ToString ());
2799 + ilGen.Emit (OpCodes.Ldarg_0);
2800 + ilGen.Emit (OpCodes.Newobj, ctorDeploymentException);
2801 + ilGen.Emit (OpCodes.Throw);
2802 + ilGen.MarkLabel (label1);
2803 +
2804 + // We create a try/ catch around the createInstanceWithContext, etc. functions
2805 + // There are 3 cases
2806 + // 1. function do not specify exceptions. Then RuntimeExceptions are retrhown and other
2807 + // exceptions produce a DeploymentException.
2808 + // 2. function specify Exception. Then all exceptions fly through
2809 + // 3. function specifies exceptions but no Exception. Then these are rethrown
2810 + // and other exceptions, except RuntimeException, produce a deployment exception.
2811 + // In case there are no parameters we call
2812 + // XMultiComponentFactory.createInstanceWithContext
2813 +
2814 + ArrayList exceptionTypes = GetServiceConstructorMethodExceptionsReduced (ctorDesc.ExceptionTypes);
2815 + if (!exceptionTypes.Contains (typeUnoException)) {
2816 + ilGen.BeginExceptionBlock ();
2817 + }
2818 +
2819 + if (ctorDesc.Parameters == 0) {
2820 + ilGen.Emit (OpCodes.Ldloc, localFactory);
2821 + ilGen.Emit (OpCodes.Ldstr, entry.mType.Name);
2822 + ilGen.Emit (OpCodes.Ldarg_0);
2823 +
2824 + MethodInfo methodCreate = localFactory.LocalType.GetMethod ("createInstanceWithContext");
2825 + ilGen.Emit (OpCodes.Callvirt, methodCreate);
2826 + } else if(bParameterArray) {
2827 + //Service constructor with parameter array
2828 + ilGen.Emit (OpCodes.Ldloc, localFactory);
2829 + ilGen.Emit (OpCodes.Ldstr, entry.mType.Name);
2830 + ilGen.Emit (OpCodes.Ldarg_1);
2831 + ilGen.Emit (OpCodes.Ldarg_0);
2832 + MethodInfo methodCreate = localFactory.LocalType.GetMethod ("createInstanceWithArgumentsAndContext");
2833 + ilGen.Emit(OpCodes.Callvirt, methodCreate);
2834 + } else {
2835 + // Any param1, Any param2, etc.
2836 + // For each parameter,except the component context, and parameter array
2837 + // and Any is created.
2838 + LocalBuilder[] localAny = new LocalBuilder [ctorDesc.Parameters];
2839 +
2840 + for (iparam = 0; iparam < ctorDesc.Parameters; iparam ++) {
2841 + localAny [iparam] = ilGen.DeclareLocal (typeof (uno.Any));
2842 + }
2843 +
2844 + // Any[]. This array is filled with the created Anys which contain the parameters
2845 + // and the values contained in the parameter array
2846 + LocalBuilder localAnyParams = ilGen.DeclareLocal (typeof (uno.Any []));
2847 +
2848 + // Create the Any for every argument, except for the parameter array
2849 + // arLocalAny contains the LocalBuilder for all these parameters.
2850 + // we call the ctor Any(Type, Object)
2851 + // If the parameter is an Any then the Any is created with Any(param.Type, param.Value);
2852 + Type[] typesCtorAny = { typeof (Type),
2853 + typeof (object) };
2854 + ConstructorInfo ctorAny = typeof (uno.Any).GetConstructor (typesCtorAny);
2855 + MethodInfo methodAnyGetType = typeof (uno.Any).GetProperty ("Type").GetGetMethod ();
2856 + MethodInfo methodAnyGetValue = typeof (uno.Any).GetProperty ("Value").GetGetMethod ();
2857 +
2858 + for (j = 0; j < localAny.Length; j ++) {
2859 + //check if the parameter is a polymorphic struct
2860 + if (typeParameters [j + 1] is uno.PolymorphicType) {
2861 + // It is a polymorphic struct
2862 + uno.PolymorphicType polyType = typeParameters [j + 1] as uno.PolymorphicType;
2863 +
2864 + // Load the uninitialized local Any on which we will call the ctor
2865 + ilGen.Emit (OpCodes.Ldloca, localAny [j]);
2866 +
2867 + // Call PolymorphicType PolymorphicType::GetType(Type t, String polyName)
2868 + // Prepare the first parameter
2869 + ilGen.Emit (OpCodes.Ldtoken, polyType.OriginalType);
2870 + Type[] typeParams = { typeof (System.RuntimeTypeHandle) };
2871 + ilGen.Emit (OpCodes.Call, typeof(Type).GetMethod ("GetTypeFromHandle", typeParams));
2872 +
2873 + // Prepare the second parameter
2874 + ilGen.Emit (OpCodes.Ldstr, polyType.PolymorphicName);
2875 +
2876 + // Make the actual call
2877 + Type[] typeParamGetType = { typeof (Type), typeof (string) };
2878 + ilGen.Emit (OpCodes.Call,
2879 + typeof (uno.PolymorphicType).GetMethod("GetType",
2880 + typeParamGetType));
2881 +
2882 + // Stack is: localAny, PolymorphicType
2883 + // Call Any::Any(Type, Object)
2884 + // Prepare the second parameter for the any ctor
2885 + ilGen.Emit (OpCodes.Ldarg, j + 1);
2886 +
2887 + // if the parameter is a value type then we need to box it, because
2888 + // the Any ctor takes an Object
2889 + if (typeParameters [j + 1].IsValueType)
2890 + ilGen.Emit (OpCodes.Box, typeParameters [j + 1]);
2891 + ilGen.Emit (OpCodes.Call, ctorAny);
2892 + } else if (typeParameters [j + 1] == typeof (uno.Any)) {
2893 + // Create the call new Any(param.Type,param,Value)
2894 + // Stack must be Any,Type,Value
2895 + // First load the Any which is to be constructed
2896 + ilGen.Emit (OpCodes.Ldloca, localAny [j]);
2897 +
2898 + //Load the Type, which is obtained by calling param.Type
2899 + ilGen.Emit (OpCodes.Ldarga, j + 1);
2900 + ilGen.Emit (OpCodes.Call, methodAnyGetType);
2901 +
2902 + //Load the Value, which is obtained by calling param.Value
2903 + ilGen.Emit (OpCodes.Ldarga, j + 1);
2904 + ilGen.Emit (OpCodes.Call, methodAnyGetValue);
2905 +
2906 + //Call the Any ctor.
2907 + ilGen.Emit (OpCodes.Call, ctorAny);
2908 + } else {
2909 + ilGen.Emit (OpCodes.Ldloca, localAny [j]);
2910 + ilGen.Emit (OpCodes.Ldtoken, typeParameters [j + 1]);
2911 +
2912 + Type[] typeParams = { typeof (System.RuntimeTypeHandle) };
2913 + ilGen.Emit (OpCodes.Call, typeof (Type).GetMethod ("GetTypeFromHandle", typeParams));
2914 + ilGen.Emit(OpCodes.Ldarg, j + 1);
2915 +
2916 + // if the parameter is a value type then we need to box it, because
2917 + // the Any ctor takes an Object
2918 + if (typeParameters [j + 1].IsValueType)
2919 + ilGen.Emit (OpCodes.Box, typeParameters [j + 1]);
2920 + ilGen.Emit(OpCodes.Call, ctorAny);
2921 + }
2922 + }
2923 +
2924 +
2925 + // Create the Any[] that is passed to the
2926 + // createInstanceWithContext[AndArguments] function
2927 + ilGen.Emit (OpCodes.Ldc_I4, localAny.Length);
2928 + ilGen.Emit (OpCodes.Newarr, typeof (uno.Any));
2929 + ilGen.Emit (OpCodes.Stloc, localAnyParams);
2930 +
2931 + // Assign all anys created from the parameters
2932 + // array to the Any[]
2933 + for (j = 0; j < localAny.Length; j ++) {
2934 + ilGen.Emit (OpCodes.Ldloc, localAnyParams);
2935 + ilGen.Emit (OpCodes.Ldc_I4, j);
2936 + ilGen.Emit (OpCodes.Ldelema, typeof (uno.Any));
2937 + ilGen.Emit (OpCodes.Ldloc, localAny [j]);
2938 + ilGen.Emit (OpCodes.Stobj, typeof (uno.Any));
2939 + }
2940 +
2941 + // call createInstanceWithContextAndArguments
2942 + ilGen.Emit (OpCodes.Ldloc, localFactory);
2943 + ilGen.Emit (OpCodes.Ldstr, entry.mType.Name);
2944 + ilGen.Emit (OpCodes.Ldloc, localAnyParams);
2945 + ilGen.Emit (OpCodes.Ldarg_0);
2946 + MethodInfo methodCreate = localFactory.LocalType.GetMethod ("createInstanceWithArgumentsAndContext");
2947 + ilGen.Emit (OpCodes.Callvirt, methodCreate);
2948 + }
2949 +
2950 + // cast the object returned by the functions createInstanceWithContext or
2951 + // createInstanceWithArgumentsAndContext to the interface type
2952 + ilGen.Emit (OpCodes.Castclass, ret);
2953 + ilGen.Emit (OpCodes.Stloc, localReturnVal);
2954 +
2955 + //catch exceptions thrown by createInstanceWithArgumentsAndContext and createInstanceWithContext
2956 + if (!exceptionTypes.Contains (typeUnoException)) {
2957 + // catch (unoidl.com.sun.star.uno.RuntimeException) {throw;}
2958 + ilGen.BeginCatchBlock (GetType ("unoidl.com.sun.star.uno.RuntimeException", true));
2959 + ilGen.Emit (OpCodes.Pop);
2960 + ilGen.Emit (OpCodes.Rethrow);
2961 +
2962 + //catch and rethrow all other defined Exceptions
2963 + for (j = 0; j < exceptionTypes.Count; j ++) {
2964 + Type excType = exceptionTypes [j] as Type;
2965 + if (excType.IsInstanceOfType (GetType ("unoidl.com.sun.star.uno.RuntimeException", true))) {
2966 + // we have a catch for RuntimeException already defined
2967 + continue;
2968 + }
2969 +
2970 + //catch Exception and rethrow
2971 + ilGen.BeginCatchBlock (excType);
2972 + ilGen.Emit (OpCodes.Pop);
2973 + ilGen.Emit (OpCodes.Rethrow);
2974 + }
2975 +
2976 + //catch (unoidl.com.sun.star.uno.Exception) {throw DeploymentException...}
2977 + ilGen.BeginCatchBlock (typeUnoException);
2978 +
2979 + //Define the local variabe that keeps the exception
2980 + LocalBuilder localException = ilGen.DeclareLocal (typeUnoException);
2981 +
2982 + //Store the exception
2983 + ilGen.Emit (OpCodes.Stloc, localException);
2984 +
2985 + //prepare the construction of the exception
2986 + strBuilder = new System.Text.StringBuilder (256);
2987 + strBuilder.Append ("The context (com.sun.star.uno.XComponentContext) failed to supply the service ");
2988 + strBuilder.Append ("unoidl." + entry.mType.Name);
2989 + strBuilder.Append (": ");
2990 +
2991 + ilGen.Emit (OpCodes.Ldstr, strBuilder.ToString());
2992 +
2993 + // add to the string the Exception.Message
2994 + ilGen.Emit (OpCodes.Ldloc, localException);
2995 + //Console.WriteLine ("get message property of type: {0}", typeUnoException);
2996 + ilGen.Emit (OpCodes.Callvirt, typeUnoException.GetProperty ("Message").GetGetMethod ());
2997 + Type[] concatParams = { typeof (string), typeof (string)};
2998 + ilGen.Emit (OpCodes.Call, typeof (string).GetMethod ("Concat", concatParams));
2999 +
3000 + //load contex argument
3001 + ilGen.Emit (OpCodes.Ldarg_0);
3002 + ilGen.Emit (OpCodes.Newobj, ctorDeploymentException);
3003 + ilGen.Emit (OpCodes.Throw); //Exception(typeDeploymentExc);
3004 +
3005 + ilGen.EndExceptionBlock();
3006 + }
3007 +
3008 +
3009 + // Check if the service instance was create and throw a exception if not.
3010 + Label labelServiceCreated = ilGen.DefineLabel ();
3011 + ilGen.Emit (OpCodes.Ldloc, localReturnVal);
3012 + ilGen.Emit (OpCodes.Brtrue_S, labelServiceCreated);
3013 +
3014 + strBuilder = new System.Text.StringBuilder(256);
3015 + strBuilder.Append ("The context (com.sun.star.uno.XComponentContext) failed to supply the service ");
3016 + strBuilder.Append ("unoidl." + entry.mType.Name);
3017 + strBuilder.Append (".");
3018 + ilGen.Emit (OpCodes.Ldstr, strBuilder.ToString());
3019 + ilGen.Emit (OpCodes.Ldarg_0);
3020 + ilGen.Emit (OpCodes.Newobj, ctorDeploymentException);
3021 + ilGen.Emit (OpCodes.Throw); //Exception(typeDeploymentExc);
3022 +
3023 + ilGen.MarkLabel (labelServiceCreated);
3024 + ilGen.Emit (OpCodes.Ldloc, localReturnVal);
3025 + ilGen.Emit (OpCodes.Ret);
3026 + }
3027 +
3028 + mIncompleteServices.Remove (entry.mTypeBuilder.FullName);
3029 +
3030 + if (mConfig.mVerbose)
3031 + Console.WriteLine("> emitting service type {0}", "unoidl." + entry.mType.Name);
3032 +
3033 + //Console.WriteLine ("completed service {0}", entry.mTypeBuilder.FullName);
3034 +
3035 + return entry.mTypeBuilder.CreateType ();
3036 + }
3037 +
3038 + Type CompleteSingletonType (SingletonEntry entry)
3039 + {
3040 + string name = "unoidl." + entry.mType.Name;
3041 +
3042 + // Create the private default constructor
3043 + ConstructorBuilder ctorBuilder = entry.mTypeBuilder.DefineConstructor (MethodAttributes.Private |
3044 + MethodAttributes.HideBySig |
3045 + MethodAttributes.SpecialName |
3046 + MethodAttributes.RTSpecialName,
3047 + CallingConventions.Standard, null);
3048 +
3049 + ILGenerator ilGen = ctorBuilder.GetILGenerator ();
3050 + ilGen.Emit (OpCodes.Ldarg_0); // push this
3051 + ilGen.Emit (OpCodes.Call, entry.mTypeBuilder.BaseType.GetConstructor (new Type [0]));
3052 + ilGen.Emit (OpCodes.Ret);
3053 +
3054 + // obtain the interface which makes up this service, it is the return
3055 + // type of the constructor functions
3056 + UnoXTypeDescription ifaceTD = entry.mType.Interface;
3057 + if (!(ifaceTD is UnoXInterfaceTypeDescription))
3058 + ifaceTD = ResolveInterfaceTypedef (ifaceTD);
3059 + Type retType = GetType (ifaceTD);
3060 +
3061 + //define method
3062 + Type[] typeParameters = { GetType ("unoidl.com.sun.star.uno.XComponentContext", true) };
3063 + MethodBuilder methodBuilder = entry.mTypeBuilder.DefineMethod ("get", MethodAttributes.Public |
3064 + MethodAttributes.HideBySig |
3065 + MethodAttributes.Static,
3066 + retType,
3067 + typeParameters);
3068 +
3069 + // The first parameter is the XComponentContext, which cannot be obtained
3070 + // from reflection.
3071 + // The context is not part of the idl description
3072 + methodBuilder.DefineParameter (1, ParameterAttributes.In, "the_context");
3073 +
3074 + ilGen = methodBuilder.GetILGenerator();
3075 + // Define locals ---------------------------------
3076 + // Any, returned by XComponentContext.getValueByName
3077 + LocalBuilder localAny = ilGen.DeclareLocal (typeof (uno.Any));
3078 +
3079 + // Call XContext.getValueByName
3080 + ilGen.Emit (OpCodes.Ldarg_0);
3081 +
3082 + // build the singleton name : /singleton/unoidl.com.sun.star.XXX
3083 + ilGen.Emit(OpCodes.Ldstr, "/singletons/" + name);
3084 +
3085 + MethodInfo methodGetValueByName = GetType ("unoidl.com.sun.star.uno.XComponentContext", true).GetMethod ("getValueByName");
3086 + ilGen.Emit(OpCodes.Callvirt, methodGetValueByName);
3087 + ilGen.Emit(OpCodes.Stloc_0);
3088 +
3089 + //Contains the returned Any a value?
3090 + ilGen.Emit(OpCodes.Ldloca_S, localAny);
3091 + MethodInfo methodHasValue = typeof (uno.Any).GetMethod ("hasValue");
3092 + ilGen.Emit (OpCodes.Call, methodHasValue);
3093 +
3094 + //If not, then throw an DeploymentException
3095 + Label labelSingletonExists = ilGen.DefineLabel ();
3096 + ilGen.Emit (OpCodes.Brtrue_S, labelSingletonExists);
3097 + ilGen.Emit (OpCodes.Ldstr, "Component context fails to supply singleton " + name + " of type " + retType.FullName + ".");
3098 + ilGen.Emit (OpCodes.Ldarg_0);
3099 + Type[] typesCtorDeploymentException = { typeof (string), typeof (object) };
3100 + ilGen.Emit (OpCodes.Newobj, GetType ("unoidl.com.sun.star.uno.DeploymentException", true).GetConstructor (typesCtorDeploymentException));
3101 + ilGen.Emit (OpCodes.Throw);
3102 + ilGen.MarkLabel (labelSingletonExists);
3103 +
3104 + //Cast the singleton contained in the Any to the expected interface and return it.
3105 + ilGen.Emit (OpCodes.Ldloca_S, localAny);
3106 + ilGen.Emit (OpCodes.Call, typeof (uno.Any).GetProperty ("Value").GetGetMethod ());
3107 + ilGen.Emit (OpCodes.Castclass, retType);
3108 + ilGen.Emit (OpCodes.Ret);
3109 +
3110 + if (mConfig.mVerbose)
3111 + Console.WriteLine ("> emitting singleton type {0}", name);
3112 +
3113 + mIncompleteSingletons.Remove (entry.mTypeBuilder.FullName);
3114 +
3115 + //Console.WriteLine ("completed singleton {0}", entry.mTypeBuilder.FullName);
3116 +
3117 + return entry.mTypeBuilder.CreateType ();
3118 + }
3119 +
3120 + public void Dispose ()
3121 + {
3122 + while (mIncompleteIFaces.Count > 0) {
3123 + IDictionaryEnumerator e = mIncompleteIFaces.GetEnumerator ();
3124 + e.MoveNext ();
3125 + CompleteIFaceType (e.Value as IFaceEntry);
3126 + }
3127 +
3128 + while (mIncompleteServices.Count > 0) {
3129 + IDictionaryEnumerator e = mIncompleteServices.GetEnumerator ();
3130 + e.MoveNext ();
3131 + CompleteServiceType (e.Value as ServiceEntry);
3132 + }
3133 +
3134 + while (mIncompleteSingletons.Count > 0) {
3135 + IDictionaryEnumerator e = mIncompleteSingletons.GetEnumerator ();
3136 + e.MoveNext ();
3137 + CompleteSingletonType (e.Value as SingletonEntry);
3138 + }
3139 + }
3140 +}
3141 +
3142 +class Config
3143 +{
3144 + public ArrayList mMandatoryRegistries = new ArrayList ();
3145 + public ArrayList mExplicitTypes = new ArrayList ();
3146 + public ArrayList mExtraAssemblies = new ArrayList ();
3147 + public ArrayList mExtraRegistries = new ArrayList ();
3148 + public bool mVerbose = false;
3149 + public string
3150 + mOutput = null,
3151 + mVersion = null,
3152 + mDescription = null,
3153 + mProduct = null,
3154 + mCompany = null,
3155 + mCopyright = null,
3156 + mTrademark = null,
3157 + mKeyfile = null,
3158 + mDelaySign = null;
3159 +}
3160 +
3161 +class CliMaker
3162 +{
3163 + IntPtr mUnoHelper;
3164 +
3165 +// string mOutputDir = "./";
3166 +// string mOutputFile = "cli_uretypes.dll";
3167 +// string mName = "cli_uretypes";
3168 +
3169 + string mOutputDir;
3170 + string mOutputFile;
3171 + string mName;
3172 +
3173 + Config mConfig;
3174 +
3175 + AssemblyBuilder mAssemblyBuilder;
3176 + ResolveEventHandler mTypeResolver = null;
3177 +
3178 + public CliMaker (Config config)
3179 + {
3180 + mConfig = config;
3181 + mUnoHelper = cmm_uno_helper_new ();
3182 + }
3183 +
3184 + ~CliMaker ()
3185 + {
3186 + cmm_uno_helper_delete (mUnoHelper);
3187 + }
3188 +
3189 + public void OpenRegistries ()
3190 + {
3191 + if (mConfig.mExplicitTypes.Count > 0)
3192 + foreach (string typeName in mConfig.mExplicitTypes)
3193 + cmm_uno_helper_add_explicit_type (mUnoHelper, typeName);
3194 +
3195 + foreach (string registry in mConfig.mMandatoryRegistries)
3196 + cmm_uno_helper_add_mandatory_registry (mUnoHelper, registry);
3197 +
3198 + foreach (string registry in mConfig.mExtraRegistries)
3199 + cmm_uno_helper_add_extra_registry (mUnoHelper, registry);
3200 +
3201 + cmm_uno_helper_open_registries (mUnoHelper);
3202 + }
3203 +
3204 + public void PrepareAssembly ()
3205 + {
3206 + // Get the key pair for making a strong name
3207 + StrongNameKeyPair kp = null;
3208 + if (mConfig.mKeyfile != null) {
3209 + try {
3210 + System.IO.FileStream fs = new System.IO.FileStream (mConfig.mKeyfile, System.IO.FileMode.Open);
3211 + kp = new StrongNameKeyPair (fs);
3212 + fs.Close ();
3213 + } catch (System.IO.FileNotFoundException) {
3214 + throw new Exception ("Could not find the keyfile. Verify the --keyfile argument!");
3215 + }
3216 + } else {
3217 + if (mConfig.mVerbose)
3218 + Console.WriteLine ("> no key file specified. Cannot create strong name!");
3219 + }
3220 +
3221 + mOutputFile = System.IO.Path.GetFileName (mConfig.mOutput);
3222 + mOutputDir = System.IO.Path.GetDirectoryName (mConfig.mOutput);
3223 + mName = System.IO.Path.GetFileNameWithoutExtension (mConfig.mOutput);
3224 +// int idx = mOutputFile.LastIndexOf (System.IO.Path.DirectorySeparatorChar);
3225 +// if (idx >= 0)
3226 +// mOutputDir = mOutputFile.Substring (0, idx);
3227 +// else
3228 +// mOutputDir = System.IO.Path.CurrentDirectory;
3229 +// idx = mOutputFile.LastIndexOf (".dll");
3230 +// mName = mOutputFile.Substring (0, idx);
3231 + //Console.WriteLine ("file {0}\ndir {1}\nname {2}", mOutputFile, mOutputDir, mName);
3232 +
3233 + // setup assembly info: xxx todo set more? e.g. avoid strong versioning
3234 + AssemblyName assemblyName = new AssemblyName();
3235 + assemblyName.CodeBase = mOutputDir;
3236 + assemblyName.Name = mName;
3237 +
3238 + if (kp != null)
3239 + assemblyName.KeyPair = kp;
3240 +
3241 + if (mConfig.mVersion != null)
3242 + assemblyName.Version = new System.Version (mConfig.mVersion);
3243 +
3244 + // target assembly
3245 + mAssemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly (assemblyName, AssemblyBuilderAccess.Save, mOutputDir);
3246 +
3247 + if (mConfig.mProduct != null) {
3248 + Type[] paramTypes = { typeof (string) };
3249 + object[] args = { mConfig.mProduct };
3250 + mAssemblyBuilder.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyProductAttribute).GetConstructor (paramTypes), args));
3251 + }
3252 +
3253 + if (mConfig.mDescription != null) {
3254 + Type[] paramTypes = { typeof (string) };
3255 + object[] args = { mConfig.mDescription };
3256 + mAssemblyBuilder.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyDescriptionAttribute).GetConstructor (paramTypes), args));
3257 + }
3258 +
3259 + if (mConfig.mCompany != null) {
3260 + Type[] paramTypes = { typeof (string) };
3261 + object[] args = { mConfig.mCompany };
3262 + mAssemblyBuilder.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyCompanyAttribute).GetConstructor (paramTypes), args));
3263 + }
3264 +
3265 + if (mConfig.mCopyright != null) {
3266 + Type[] paramTypes = { typeof (string) };
3267 + object[] args = { mConfig.mCopyright };
3268 + mAssemblyBuilder.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyCopyrightAttribute).GetConstructor (paramTypes), args));
3269 + }
3270 +
3271 + if (mConfig.mTrademark != null) {
3272 + Type[] paramTypes = { typeof (string) };
3273 + object[] args = { mConfig.mTrademark };
3274 + mAssemblyBuilder.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyTrademarkAttribute).GetConstructor (paramTypes), args));
3275 + }
3276 + }
3277 +
3278 + public UnoXTypeDescription NextType ()
3279 + {
3280 + IntPtr handle = cmm_uno_helper_next_type (mUnoHelper);
3281 +
3282 + if (handle != IntPtr.Zero) {
3283 + return UnoXTypeDescription.Create (handle);
3284 + }
3285 +
3286 + return null;
3287 + }
3288 +
3289 + public void Emit ()
3290 + {
3291 + TypeEmitter mTypeEmitter = new TypeEmitter (mConfig, mAssemblyBuilder.DefineDynamicModule( mOutputFile ));
3292 +
3293 + AppDomain.CurrentDomain.TypeResolve += mTypeEmitter.ResolveEventHandler;
3294 +
3295 + UnoXTypeDescription type;
3296 +
3297 + while ((type = NextType ()) != null)
3298 + mTypeEmitter.GetType (type);
3299 +
3300 + mTypeEmitter.Dispose ();
3301 + }
3302 +
3303 + public void Save ()
3304 + {
3305 + if (mConfig.mVerbose)
3306 + Console.Write ("> saving assembly {0}{1}{2}...",
3307 + mOutputDir,
3308 + System.IO.Path.DirectorySeparatorChar,
3309 + mOutputFile);
3310 +
3311 + mAssemblyBuilder.Save (mOutputFile);
3312 +
3313 + if (mConfig.mVerbose)
3314 + Console.WriteLine ("ok.");
3315 +
3316 + AppDomain.CurrentDomain.TypeResolve -= mTypeResolver;
3317 + }
3318 +
3319 + [DllImport("climaker")]
3320 + private static extern IntPtr cmm_uno_helper_new ();
3321 +
3322 + [DllImport("climaker")]
3323 + private static extern void cmm_uno_helper_delete (IntPtr handle);
3324 +
3325 + [DllImport("climaker")]
3326 + private static extern void cmm_uno_helper_add_mandatory_registry (IntPtr handle, string registry);
3327 +
3328 + [DllImport("climaker")]
3329 + private static extern void cmm_uno_helper_add_extra_registry (IntPtr handle, string registry);
3330 +
3331 + [DllImport("climaker")]
3332 + private static extern void cmm_uno_helper_add_explicit_type (IntPtr handle, string typeName);
3333 +
3334 + [DllImport("climaker")]
3335 + private static extern void cmm_uno_helper_open_registries (IntPtr handle);
3336 +
3337 + [DllImport("climaker")]
3338 + private static extern IntPtr cmm_uno_helper_next_type (IntPtr handle);
3339 +}
3340 +
3341 +class UnoObject
3342 +{
3343 + protected IntPtr mHandle;
3344 +
3345 + protected UnoObject (IntPtr handle)
3346 + {
3347 + mHandle = handle;
3348 + }
3349 +
3350 + public IntPtr Handle
3351 + {
3352 + get
3353 + {
3354 + return mHandle;
3355 + }
3356 + }
3357 +}
3358 +
3359 +class UnoXTypeDescription : UnoObject
3360 +{
3361 + protected UnoXTypeDescription (IntPtr handle) : base (handle)
3362 + {
3363 + }
3364 +
3365 + public static UnoXTypeDescription Create (IntPtr handle)
3366 + {
3367 + //Console.WriteLine ("Create {0}", handle);
3368 + if (handle == IntPtr.Zero)
3369 + return null;
3370 +
3371 + UnoTypeClass tc = cmm_x_type_description_get_type_class (handle);
3372 + switch (tc) {
3373 + case UnoTypeClass.Enum:
3374 + return new UnoXEnumTypeDescription (handle);
3375 + case UnoTypeClass.Interface:
3376 + return new UnoXInterfaceTypeDescription (handle);
3377 + case UnoTypeClass.Struct:
3378 + return new UnoXStructTypeDescription (handle);
3379 + case UnoTypeClass.Exception:
3380 + return new UnoXExceptionTypeDescription (handle);
3381 + case UnoTypeClass.Sequence:
3382 + case UnoTypeClass.Typedef:
3383 + return new UnoXIndirectTypeDescription (handle);
3384 + case UnoTypeClass.Constant:
3385 + return new UnoXConstantTypeDescription (handle);
3386 + case UnoTypeClass.Constants:
3387 + return new UnoXConstantsTypeDescription (handle);
3388 + case UnoTypeClass.Service:
3389 + return new UnoXServiceTypeDescription (handle);
3390 + case UnoTypeClass.Singleton:
3391 + return new UnoXSingletonTypeDescription (handle);
3392 + }
3393 +
3394 + //Console.WriteLine ("unknown type {0}", tc);
3395 +
3396 + return new UnoXTypeDescription (handle);
3397 + }
3398 +
3399 + public string Name
3400 + {
3401 + get
3402 + {
3403 + return cmm_x_type_description_get_name (mHandle);
3404 + }
3405 + }
3406 +
3407 + public UnoTypeClass TypeClass
3408 + {
3409 + get
3410 + {
3411 + return cmm_x_type_description_get_type_class (mHandle);
3412 + }
3413 + }
3414 +
3415 + [DllImport("climaker")]
3416 + private static extern string cmm_x_type_description_get_name (IntPtr handle);
3417 +
3418 + [DllImport("climaker")]
3419 + private static extern UnoTypeClass cmm_x_type_description_get_type_class (IntPtr handle);
3420 +}
3421 +
3422 +class UnoXEnumTypeDescription : UnoXTypeDescription
3423 +{
3424 + public UnoXEnumTypeDescription (IntPtr mHandle) : base (mHandle)
3425 + {
3426 + }
3427 +
3428 + public int Length
3429 + {
3430 + get
3431 + {
3432 + return cmm_x_enum_type_description_get_length (mHandle);
3433 + }
3434 + }
3435 +
3436 + public string ValueName (int idx)
3437 + {
3438 + return cmm_x_enum_type_description_get_name (mHandle, idx);
3439 + }
3440 +
3441 + public int Value (int idx)
3442 + {
3443 + return cmm_x_enum_type_description_get_value (mHandle, idx);
3444 + }
3445 +
3446 + [DllImport("climaker")]
3447 + private static extern int cmm_x_enum_type_description_get_length (IntPtr handle);
3448 +
3449 + [DllImport("climaker")]
3450 + private static extern int cmm_x_enum_type_description_get_value (IntPtr handle, int idx);
3451 +
3452 + [DllImport("climaker")]
3453 + private static extern string cmm_x_enum_type_description_get_name (IntPtr handle, int idx);
3454 +}
3455 +
3456 +class UnoXInterfaceTypeDescription : UnoXTypeDescription
3457 +{
3458 + int mMembers = 0;
3459 + IntPtr mMembersHandle = IntPtr.Zero;
3460 +
3461 + public UnoXInterfaceTypeDescription (IntPtr mHandle) : base (mHandle)
3462 + {
3463 + }
3464 +
3465 + public int BaseTypes
3466 + {
3467 + get
3468 + {
3469 + return cmm_x_interface_type_description_get_length (mHandle);
3470 + }
3471 + }
3472 +
3473 + public UnoXInterfaceTypeDescription BaseType (int idx)
3474 + {
3475 + return new UnoXInterfaceTypeDescription (cmm_x_interface_type_description_get_base_type (mHandle, idx));
3476 + }
3477 +
3478 + void AssureMembers ()
3479 + {
3480 + if (mMembersHandle == IntPtr.Zero)
3481 + mMembers = cmm_x_interface_type_description_get_members (mHandle, out mMembersHandle);
3482 + }
3483 +
3484 + public int Members
3485 + {
3486 + get
3487 + {
3488 + AssureMembers ();
3489 +
3490 + return mMembers;
3491 + }
3492 + }
3493 +
3494 + public UnoXInterfaceMemberTypeDescription Member (int idx)
3495 + {
3496 + AssureMembers ();
3497 +
3498 + if (idx < 0 || idx >= mMembers)
3499 + return null;
3500 +
3501 + return new UnoXInterfaceMemberTypeDescription (cmm_x_interface_type_description_get_member (mMembersHandle, idx));
3502 + }
3503 +
3504 + [DllImport("climaker")]
3505 + private static extern int cmm_x_interface_type_description_get_length (IntPtr handle);
3506 +
3507 + [DllImport("climaker")]
3508 + private static extern IntPtr cmm_x_interface_type_description_get_base_type (IntPtr handle, int idx);
3509 +
3510 + [DllImport("climaker")]
3511 + private static extern int cmm_x_interface_type_description_get_members (IntPtr handle, out IntPtr membersHandle);
3512 +
3513 + [DllImport("climaker")]
3514 + private static extern IntPtr cmm_x_interface_type_description_get_member (IntPtr membersArrayHandle, int idx);
3515 +}
3516 +
3517 +class UnoXInterfaceMemberTypeDescription : UnoXTypeDescription
3518 +{
3519 + public UnoXInterfaceMemberTypeDescription (IntPtr handle) : base (handle)
3520 + {
3521 + }
3522 +
3523 + public string MemberName
3524 + {
3525 + get
3526 + {
3527 + return cmm_x_interface_member_type_description_get_member_name (mHandle);
3528 + }
3529 + }
3530 +
3531 + [DllImport("climaker")]
3532 + private static extern string cmm_x_interface_member_type_description_get_member_name (IntPtr handle);
3533 +}
3534 +
3535 +class UnoXInterfaceAttributeTypeDescription : UnoXInterfaceMemberTypeDescription
3536 +{
3537 + public UnoXInterfaceAttributeTypeDescription (IntPtr handle) : base (handle)
3538 + {
3539 + }
3540 +
3541 + public UnoXTypeDescription Type
3542 + {
3543 + get
3544 + {
3545 + return UnoXTypeDescription.Create (cmm_x_interface_attribute_type_description_get_type (mHandle));
3546 + }
3547 + }
3548 +
3549 + public bool IsBound
3550 + {
3551 + get
3552 + {
3553 + return cmm_x_interface_attribute_type_description_is_bound (mHandle);
3554 + }
3555 + }
3556 +
3557 + public bool IsReadOnly
3558 + {
3559 + get
3560 + {
3561 + return cmm_x_interface_attribute_type_description_is_read_only (mHandle);
3562 + }
3563 + }
3564 +
3565 + UnoXTypeDescription[] ExceptionTypes (IntPtr handle, int count)
3566 + {
3567 + int i;
3568 +
3569 + UnoXTypeDescription[] types = new UnoXTypeDescription [count];
3570 + for (i = 0; i < count; i ++) {
3571 + types [i] = UnoXTypeDescription.Create (cmm_x_interface_attribute_type_description_get_exception_type (handle, i));
3572 + }
3573 +
3574 + return types;
3575 + }
3576 +
3577 + public UnoXTypeDescription[] GetExceptionTypes
3578 + {
3579 + get
3580 + {
3581 + IntPtr handle;
3582 + int count;
3583 +
3584 + count = cmm_x_interface_attribute_type_description_get_get_exception_types (mHandle, out handle);
3585 + UnoXTypeDescription[] types = ExceptionTypes (handle, count);
3586 +
3587 + if (count > 0)
3588 + cmm_x_interface_attribute_type_description_free_exception_types (handle, count);
3589 +
3590 + return types;
3591 + }
3592 + }
3593 +
3594 + public UnoXTypeDescription[] SetExceptionTypes
3595 + {
3596 + get
3597 + {
3598 + IntPtr handle;
3599 + int count;
3600 +
3601 + count = cmm_x_interface_attribute_type_description_get_set_exception_types (mHandle, out handle);
3602 + UnoXTypeDescription[] types = ExceptionTypes (handle, count);
3603 +
3604 + if (count > 0)
3605 + cmm_x_interface_attribute_type_description_free_exception_types (handle, count);
3606 +
3607 + return types;
3608 + }
3609 + }
3610 +
3611 + [DllImport("climaker")]
3612 + private static extern IntPtr cmm_x_interface_attribute_type_description_get_type (IntPtr handle);
3613 +
3614 + [DllImport("climaker")]
3615 + private static extern bool cmm_x_interface_attribute_type_description_is_bound (IntPtr handle);
3616 +
3617 + [DllImport("climaker")]
3618 + private static extern bool cmm_x_interface_attribute_type_description_is_read_only (IntPtr handle);
3619 +
3620 + [DllImport("climaker")]
3621 + private static extern int cmm_x_interface_attribute_type_description_get_get_exception_types (IntPtr handle, out IntPtr exceptionTypesHandle);
3622 +
3623 + [DllImport("climaker")]
3624 + private static extern int cmm_x_interface_attribute_type_description_get_set_exception_types (IntPtr handle, out IntPtr exceptionTypesHandle);
3625 +
3626 + [DllImport("climaker")]
3627 + private static extern IntPtr cmm_x_interface_attribute_type_description_get_exception_type (IntPtr handle, int index);
3628 +
3629 + [DllImport("climaker")]
3630 + private static extern void cmm_x_interface_attribute_type_description_free_exception_types (IntPtr handle, int count);
3631 +}
3632 +
3633 +class UnoXInterfaceMethodTypeDescription : UnoXInterfaceMemberTypeDescription
3634 +{
3635 + int mParameters = 0;
3636 + IntPtr mParametersHandle = IntPtr.Zero;
3637 + IntPtr mParametersArrayHandle = IntPtr.Zero;
3638 +
3639 + bool mGotExceptionTypes = false;
3640 + int mExceptionTypes = 0;
3641 + IntPtr mExceptionTypesHandle = IntPtr.Zero;
3642 + IntPtr mExceptionTypesArrayHandle = IntPtr.Zero;
3643 +
3644 + public UnoXInterfaceMethodTypeDescription (IntPtr handle) : base (handle)
3645 + {
3646 + }
3647 +
3648 + public UnoXTypeDescription ReturnType
3649 + {
3650 + get
3651 + {
3652 + return UnoXTypeDescription.Create (cmm_x_interface_method_type_description_get_return_type (mHandle));
3653 + }
3654 + }
3655 +
3656 + public bool ReturnsStruct
3657 + {
3658 + get
3659 + {
3660 + return cmm_x_interface_method_type_description_returns_struct (mHandle);
3661 + }
3662 + }
3663 +
3664 + void AssureParameters ()
3665 + {
3666 + if (mParametersHandle == IntPtr.Zero)
3667 + mParameters = cmm_x_interface_method_type_description_get_parameters (mHandle, out mParametersHandle, out mParametersArrayHandle);
3668 + }
3669 +
3670 + public int Parameters
3671 + {
3672 + get
3673 + {
3674 + AssureParameters ();
3675 +
3676 + return mParameters;
3677 + }
3678 + }
3679 +
3680 + public UnoXMethodParameter Parameter (int idx)
3681 + {
3682 + AssureParameters ();
3683 +
3684 + if (idx < 0 || idx >= mParameters)
3685 + return null;
3686 +
3687 + return new UnoXMethodParameter (cmm_x_interface_method_type_description_get_parameter (mParametersArrayHandle, idx));
3688 + }
3689 +
3690 + void AssureExceptionTypes ()
3691 + {
3692 + if (!mGotExceptionTypes) {
3693 + mExceptionTypes = cmm_x_interface_method_type_description_get_exception_types (mHandle, out mExceptionTypesHandle, out mExceptionTypesArrayHandle);
3694 + mGotExceptionTypes = true;
3695 + }
3696 + }
3697 +
3698 + public int ExceptionTypes
3699 + {
3700 + get
3701 + {
3702 + AssureExceptionTypes ();
3703 +
3704 + return mExceptionTypes;
3705 + }
3706 + }
3707 +
3708 + public UnoXCompoundTypeDescription ExceptionType (int idx)
3709 + {
3710 + AssureExceptionTypes ();
3711 +
3712 + if (idx < 0 || idx >= mExceptionTypes)
3713 + return null;
3714 +
3715 + return UnoXTypeDescription.Create (cmm_x_interface_method_type_description_get_exception_type (mExceptionTypesArrayHandle, idx)) as UnoXCompoundTypeDescription;
3716 + }
3717 +
3718 + public bool IsOneway
3719 + {
3720 + get
3721 + {
3722 + return cmm_x_interface_method_type_description_is_oneway (mHandle);
3723 + }
3724 + }
3725 +
3726 + [DllImport("climaker")]
3727 + private static extern int cmm_x_interface_method_type_description_get_parameters (IntPtr handle, out IntPtr parametersHandle, out IntPtr parametersArrayHandle);
3728 +
3729 + [DllImport("climaker")]
3730 + private static extern IntPtr cmm_x_interface_method_type_description_get_parameter (IntPtr parametersArrayHandle, int idx);
3731 +
3732 + [DllImport("climaker")]
3733 + private static extern int cmm_x_interface_method_type_description_get_exception_types (IntPtr handle, out IntPtr exceptionTypesHandle, out IntPtr exceptionTypesArrayHandle);
3734 +
3735 + [DllImport("climaker")]
3736 + private static extern IntPtr cmm_x_interface_method_type_description_get_exception_type (IntPtr exceptionTypesArrayHandle, int idx);
3737 +
3738 + [DllImport("climaker")]
3739 + private static extern IntPtr cmm_x_interface_method_type_description_get_return_type (IntPtr handle);
3740 +
3741 + [DllImport("climaker")]
3742 + private static extern bool cmm_x_interface_method_type_description_returns_struct (IntPtr handle);
3743 +
3744 + [DllImport("climaker")]
3745 + private static extern bool cmm_x_interface_method_type_description_is_oneway (IntPtr handle);
3746 +}
3747 +
3748 +class UnoXCompoundTypeDescription : UnoXTypeDescription
3749 +{
3750 + int mMemberNames = 0;
3751 + IntPtr mMemberNamesHandle = IntPtr.Zero;
3752 +
3753 + int mMemberTypes = 0;
3754 + IntPtr mMemberTypesHandle = IntPtr.Zero;
3755 +
3756 + public UnoXCompoundTypeDescription (IntPtr handle) : base (handle)
3757 + {
3758 + }
3759 +
3760 + public UnoXTypeDescription BaseType
3761 + {
3762 + get
3763 + {
3764 + return UnoXTypeDescription.Create (cmm_x_compound_type_description_get_base_type (mHandle));
3765 + }
3766 + }
3767 +
3768 + void AssureMemberNames ()
3769 + {
3770 + if (mMemberNamesHandle == IntPtr.Zero)
3771 + mMemberNames = cmm_x_compound_type_description_get_member_names (mHandle, out mMemberNamesHandle);
3772 + }
3773 +
3774 + public string MemberName (int idx)
3775 + {
3776 + AssureMemberNames ();
3777 +
3778 + if (idx < 0 || idx >= mMemberNames)
3779 + return null;
3780 +
3781 + return cmm_x_compound_type_description_get_member_name (mMemberNamesHandle, idx);
3782 + }
3783 +
3784 + public int MemberNames
3785 + {
3786 + get
3787 + {
3788 + AssureMemberNames ();
3789 +
3790 + return mMemberNames;
3791 + }
3792 + }
3793 +
3794 + void AssureMemberTypes ()
3795 + {
3796 + if (mMemberTypesHandle == IntPtr.Zero)
3797 + mMemberTypes = cmm_x_compound_type_description_get_member_types (mHandle, out mMemberTypesHandle);
3798 + }
3799 +
3800 + public UnoXTypeDescription MemberType (int idx)
3801 + {
3802 + AssureMemberTypes ();
3803 +
3804 + if (idx < 0 || idx >= mMemberTypes)
3805 + return null;
3806 +
3807 + return UnoXTypeDescription.Create (cmm_x_compound_type_description_get_member_type (mMemberTypesHandle, idx));
3808 + }
3809 +
3810 + public int MemberTypes
3811 + {
3812 + get
3813 + {
3814 + AssureMemberTypes ();
3815 +
3816 + return mMemberTypes;
3817 + }
3818 + }
3819 +
3820 + [DllImport("climaker")]
3821 + private static extern IntPtr cmm_x_compound_type_description_get_base_type (IntPtr handle);
3822 +
3823 + [DllImport("climaker")]
3824 + private static extern int cmm_x_compound_type_description_get_member_names (IntPtr handle, out IntPtr memberNamesHandle);
3825 +
3826 + [DllImport("climaker")]
3827 + private static extern string cmm_x_compound_type_description_get_member_name (IntPtr handle, int idx);
3828 +
3829 + [DllImport("climaker")]
3830 + private static extern int cmm_x_compound_type_description_get_member_types (IntPtr handle, out IntPtr memberTypesHandle);
3831 +
3832 + [DllImport("climaker")]
3833 + private static extern IntPtr cmm_x_compound_type_description_get_member_type (IntPtr handle, int idx);
3834 +}
3835 +
3836 +class UnoXExceptionTypeDescription : UnoXCompoundTypeDescription
3837 +{
3838 + public UnoXExceptionTypeDescription (IntPtr handle) : base (handle)
3839 + {
3840 + }
3841 +}
3842 +
3843 +class UnoXStructTypeDescription : UnoXCompoundTypeDescription
3844 +{
3845 + int mTypeArguments = 0;
3846 + IntPtr mTypeArgumentsHandle = IntPtr.Zero;
3847 + IntPtr mTypeArgumentsArrayHandle = IntPtr.Zero;
3848 +
3849 + int mTypeParameters = 0;
3850 + IntPtr mTypeParametersHandle = IntPtr.Zero;
3851 +
3852 + public UnoXStructTypeDescription (IntPtr handle) : base (handle)
3853 + {
3854 + }
3855 +
3856 + void AssureTypeParameters ()
3857 + {
3858 + if (mTypeParametersHandle == IntPtr.Zero)
3859 + mTypeParameters = cmm_x_struct_type_description_get_type_parameters (mHandle, out mTypeParametersHandle);
3860 + }
3861 +
3862 + public string TypeParameter (int idx)
3863 + {
3864 + AssureTypeParameters ();
3865 +
3866 + if (idx < 0 || idx >= mTypeParameters)
3867 + return null;
3868 +
3869 + return cmm_x_struct_type_description_get_type_parameter (mTypeParametersHandle, idx);
3870 + }
3871 +
3872 + public int TypeParameters
3873 + {
3874 + get
3875 + {
3876 + AssureTypeParameters ();
3877 +
3878 + return mTypeParameters;
3879 + }
3880 + }
3881 +
3882 + void AssureTypeArguments ()
3883 + {
3884 + if (mTypeArgumentsHandle == IntPtr.Zero)
3885 + mTypeArguments = cmm_x_struct_type_description_get_type_arguments (mHandle, out mTypeArgumentsHandle, out mTypeArgumentsArrayHandle);
3886 + }
3887 +
3888 + public int TypeArguments
3889 + {
3890 + get
3891 + {
3892 + AssureTypeArguments ();
3893 +
3894 + return mTypeArguments;
3895 + }
3896 + }
3897 +
3898 + public UnoXTypeDescription TypeArgument (int idx)
3899 + {
3900 + AssureTypeArguments ();
3901 +
3902 + if (idx < 0 || idx >= mTypeArguments)
3903 + return null;
3904 +
3905 + return UnoXTypeDescription.Create (cmm_x_struct_type_description_get_type_argument (mTypeArgumentsArrayHandle, idx));
3906 + }
3907 +
3908 + [DllImport("climaker")]
3909 + private static extern int cmm_x_struct_type_description_get_type_parameters (IntPtr handle, out IntPtr typeParametersHandle);
3910 +
3911 + [DllImport("climaker")]
3912 + private static extern string cmm_x_struct_type_description_get_type_parameter (IntPtr typeParametersHandle, int idx);
3913 +
3914 + [DllImport("climaker")]
3915 + private static extern int cmm_x_struct_type_description_get_type_arguments (IntPtr handle, out IntPtr typeArgumentsHandle, out IntPtr typeArgumentsArrayHandle);
3916 +
3917 + [DllImport("climaker")]
3918 + private static extern IntPtr cmm_x_struct_type_description_get_type_argument (IntPtr typeArgumentsArrayHandle, int idx);
3919 +}
3920 +
3921 +class UnoXMethodParameter : UnoObject
3922 +{
3923 + public UnoXMethodParameter (IntPtr handle) : base (handle)
3924 + {
3925 + }
3926 +
3927 + public bool IsOut
3928 + {
3929 + get
3930 + {
3931 + return cmm_x_method_parameter_is_out (mHandle);
3932 + }
3933 + }
3934 +
3935 + public bool IsIn
3936 + {
3937 + get
3938 + {
3939 + return cmm_x_method_parameter_is_in (mHandle);
3940 + }
3941 + }
3942 +
3943 + public string Name
3944 + {
3945 + get
3946 + {
3947 + return cmm_x_method_parameter_name (mHandle);
3948 + }
3949 + }
3950 +
3951 + public int Position
3952 + {
3953 + get
3954 + {
3955 + return cmm_x_method_parameter_position (mHandle);
3956 + }
3957 + }
3958 +
3959 + public UnoXTypeDescription Type
3960 + {
3961 + get
3962 + {
3963 + return UnoXTypeDescription.Create (cmm_x_method_parameter_type (mHandle));
3964 + }
3965 + }
3966 +
3967 + [DllImport("climaker")]
3968 + private static extern bool cmm_x_method_parameter_is_out (IntPtr handle);
3969 +
3970 + [DllImport("climaker")]
3971 + private static extern bool cmm_x_method_parameter_is_in (IntPtr handle);
3972 +
3973 + [DllImport("climaker")]
3974 + private static extern int cmm_x_method_parameter_position (IntPtr handle);
3975 +
3976 + [DllImport("climaker")]
3977 + private static extern string cmm_x_method_parameter_name (IntPtr handle);
3978 +
3979 + [DllImport("climaker")]
3980 + private static extern IntPtr cmm_x_method_parameter_type (IntPtr handle);
3981 +}
3982 +
3983 +class UnoXParameter : UnoXMethodParameter
3984 +{
3985 + public UnoXParameter (IntPtr handle) : base (handle)
3986 + {
3987 + }
3988 +
3989 + public bool IsRest
3990 + {
3991 + get
3992 + {
3993 + return cmm_x_parameter_is_rest (mHandle);
3994 + }
3995 + }
3996 +
3997 + [DllImport("climaker")]
3998 + private static extern bool cmm_x_parameter_is_rest (IntPtr handle);
3999 +}
4000 +
4001 +class UnoXIndirectTypeDescription : UnoXTypeDescription
4002 +{
4003 + public UnoXIndirectTypeDescription (IntPtr handle) : base (handle)
4004 + {
4005 + }
4006 +
4007 + public UnoXTypeDescription ReferencedType
4008 + {
4009 + get
4010 + {
4011 + return UnoXTypeDescription.Create (cmm_x_indirect_type_description_get_referenced_type (mHandle));
4012 + }
4013 + }
4014 +
4015 + [DllImport("climaker")]
4016 + private static extern IntPtr cmm_x_indirect_type_description_get_referenced_type (IntPtr handle);
4017 +}
4018 +
4019 +class UnoXServiceTypeDescription : UnoXTypeDescription
4020 +{
4021 + int mConstructors = 0;
4022 + IntPtr mConstructorsHandle = IntPtr.Zero;
4023 +
4024 + public UnoXServiceTypeDescription (IntPtr handle) : base (handle)
4025 + {
4026 + }
4027 +
4028 + public bool IsSingleInterfaceBased
4029 + {
4030 + get
4031 + {
4032 + return cmm_x_service_type_description_is_single_interface_based (mHandle);
4033 + }
4034 + }
4035 +
4036 + public UnoXTypeDescription Interface
4037 + {
4038 + get
4039 + {
4040 + return UnoXTypeDescription.Create (cmm_x_service_type_description_get_interface (mHandle));
4041 + }
4042 + }
4043 +
4044 + void AssureConstructors ()
4045 + {
4046 + if (mConstructorsHandle == IntPtr.Zero)
4047 + mConstructors = cmm_x_service_type_description_get_constructors (mHandle, out mConstructorsHandle);
4048 + }
4049 +
4050 + public int Constructors
4051 + {
4052 + get
4053 + {
4054 + AssureConstructors ();
4055 +
4056 + return mConstructors;
4057 + }
4058 + }
4059 +
4060 + public UnoXServiceConstructorDescription Constructor (int idx)
4061 + {
4062 + AssureConstructors ();
4063 +
4064 + if (idx < 0 || idx >= mConstructors)
4065 + return null;
4066 +
4067 + return new UnoXServiceConstructorDescription (cmm_x_service_type_description_get_constructor (mConstructorsHandle, idx));
4068 + }
4069 +
4070 + [DllImport("climaker")]
4071 + private static extern int cmm_x_service_type_description_get_constructors (IntPtr handle, out IntPtr constructorssHandle);
4072 +
4073 + [DllImport("climaker")]
4074 + private static extern IntPtr cmm_x_service_type_description_get_constructor (IntPtr constructorsHandle, int idx);
4075 +
4076 + [DllImport("climaker")]
4077 + private static extern bool cmm_x_service_type_description_is_single_interface_based (IntPtr handle);
4078 +
4079 + [DllImport("climaker")]
4080 + private static extern IntPtr cmm_x_service_type_description_get_interface (IntPtr handle);
4081 +}
4082 +
4083 +class UnoXSingletonTypeDescription : UnoXTypeDescription
4084 +{
4085 + public UnoXSingletonTypeDescription (IntPtr handle) : base (handle)
4086 + {
4087 + }
4088 +
4089 + public bool IsInterfaceBased
4090 + {
4091 + get
4092 + {
4093 + return cmm_x_singleton_type_description_is_interface_based (mHandle);
4094 + }
4095 + }
4096 +
4097 + public UnoXTypeDescription Interface
4098 + {
4099 + get
4100 + {
4101 + return UnoXTypeDescription.Create (cmm_x_singleton_type_description_get_interface (mHandle));
4102 + }
4103 + }
4104 +
4105 + [DllImport("climaker")]
4106 + private static extern IntPtr cmm_x_singleton_type_description_get_interface (IntPtr handle);
4107 +
4108 + [DllImport("climaker")]
4109 + private static extern bool cmm_x_singleton_type_description_is_interface_based (IntPtr handle);
4110 +}
4111 +
4112 +class UnoXConstantTypeDescription : UnoXTypeDescription
4113 +{
4114 + public UnoXConstantTypeDescription (IntPtr handle) : base (handle)
4115 + {
4116 + }
4117 +
4118 + public object ConstantValue
4119 + {
4120 + get
4121 + {
4122 + char tChar;
4123 + bool tBool;
4124 + byte tByte;
4125 + Int16 tInt16;
4126 + System.UInt16 tUInt16;
4127 + Int32 tInt32;
4128 + System.UInt32 tUInt32;
4129 + Int16 tInt64;
4130 + System.UInt64 tUInt64;
4131 + System.Single tFloat;
4132 + double tDouble;
4133 +
4134 + UnoTypeClass tc = cmm_any_to_cli_constant (mHandle,
4135 + out tChar, out tBool,
4136 + out tByte,
4137 + out tInt16, out tUInt16,
4138 + out tInt32, out tUInt32,
4139 + out tInt64, out tUInt64,
4140 + out tFloat, out tDouble);
4141 + switch (tc) {
4142 + case UnoTypeClass.Char:
4143 + return tChar;
4144 + case UnoTypeClass.Boolean:
4145 + return tBool;
4146 + case UnoTypeClass.Byte:
4147 + return tByte;
4148 + case UnoTypeClass.Short:
4149 + return tInt16;
4150 + case UnoTypeClass.UnsignedShort:
4151 + return tUInt16;
4152 + case UnoTypeClass.Long:
4153 + return tInt32;
4154 + case UnoTypeClass.UnsignedLong:
4155 + return tUInt32;
4156 + case UnoTypeClass.Hyper:
4157 + return tInt64;
4158 + case UnoTypeClass.UnsignedHyper:
4159 + return tUInt64;
4160 + case UnoTypeClass.Float:
4161 + return tFloat;
4162 + case UnoTypeClass.Double:
4163 + return tDouble;
4164 + }
4165 +
4166 + throw new Exception (String.Format ("Unexpected type {0} for XConstantTypeDescription", tc));
4167 + }
4168 + }
4169 +
4170 + [DllImport("climaker")]
4171 + private static extern UnoTypeClass cmm_any_to_cli_constant (IntPtr handle,
4172 + out char tChar, out bool tBool,
4173 + out byte tByte,
4174 + out Int16 tInt16, out System.UInt16 tUInt16,
4175 + out Int32 tInt32, out System.UInt32 tUInt32,
4176 + out Int16 tInt64, out System.UInt64 tUInt64,
4177 + out System.Single tFloat, out double tDouble);
4178 +}
4179 +
4180 +class UnoXConstantsTypeDescription : UnoXTypeDescription
4181 +{
4182 + int mConstants = 0;
4183 + IntPtr mConstantsHandle = IntPtr.Zero;
4184 +
4185 + public UnoXConstantsTypeDescription (IntPtr handle) : base (handle)
4186 + {
4187 + }
4188 +
4189 + void AssureConstants ()
4190 + {
4191 + if (mConstantsHandle == IntPtr.Zero)
4192 + mConstants = cmm_x_constants_type_description_get_constants (mHandle, out mConstantsHandle);
4193 + }
4194 +
4195 + public int Constants
4196 + {
4197 + get
4198 + {
4199 + AssureConstants ();
4200 +
4201 + return mConstants;
4202 + }
4203 + }
4204 +
4205 + public UnoXConstantTypeDescription Constant (int idx)
4206 + {
4207 + AssureConstants ();
4208 +
4209 + if (idx < 0 || idx >= mConstants)
4210 + return null;
4211 +
4212 + return UnoXTypeDescription.Create (cmm_x_constants_type_description_get_constant (mConstantsHandle, idx)) as UnoXConstantTypeDescription;
4213 + }
4214 +
4215 + [DllImport("climaker")]
4216 + private static extern int cmm_x_constants_type_description_get_constants (IntPtr handle, out IntPtr constantssHandle);
4217 +
4218 + [DllImport("climaker")]
4219 + private static extern IntPtr cmm_x_constants_type_description_get_constant (IntPtr constantsHandle, int idx);
4220 +}
4221 +
4222 +class UnoXServiceConstructorDescription : UnoObject
4223 +{
4224 + int mParameters = 0;
4225 + IntPtr mParametersHandle = IntPtr.Zero;
4226 +
4227 + public UnoXServiceConstructorDescription (IntPtr handle) : base (handle)
4228 + {
4229 + }
4230 +
4231 + void AssureParameters ()
4232 + {
4233 + if (mParametersHandle == IntPtr.Zero)
4234 + mParameters = cmm_x_service_constructor_description_get_parameters (mHandle, out mParametersHandle);
4235 + }
4236 +
4237 + public int Parameters
4238 + {
4239 + get
4240 + {
4241 + AssureParameters ();
4242 +
4243 + return mParameters;
4244 + }
4245 + }
4246 +
4247 + public UnoXParameter Parameter (int idx)
4248 + {
4249 + AssureParameters ();
4250 +
4251 + if (idx < 0 || idx >= mParameters)
4252 + return null;
4253 +
4254 + return new UnoXParameter (cmm_x_service_constructor_description_get_parameter (mParametersHandle, idx));
4255 + }
4256 +
4257 + public string Name
4258 + {
4259 + get
4260 + {
4261 + return cmm_x_service_constructor_description_get_name (mHandle);
4262 + }
4263 + }
4264 +
4265 + public bool IsDefault
4266 + {
4267 + get
4268 + {
4269 + return cmm_x_service_constructor_description_is_default_constructor (mHandle);
4270 + }
4271 + }
4272 +
4273 + public UnoXTypeDescription[] ExceptionTypes
4274 + {
4275 + get
4276 + {
4277 + IntPtr handle;
4278 + int i, count;
4279 +
4280 + count = cmm_x_service_constructor_description_get_exception_types (mHandle, out handle);
4281 + UnoXTypeDescription[] types = new UnoXTypeDescription [count];
4282 +
4283 + for (i = 0; i < count; i ++) {
4284 + types [i] = UnoXTypeDescription.Create (cmm_x_service_constructor_description_get_exception_type (handle, i));
4285 + }
4286 +
4287 + if (count > 0)
4288 + cmm_x_service_constructor_description_free_exception_types (handle, count);
4289 +
4290 + return types;
4291 + }
4292 + }
4293 +
4294 + [DllImport("climaker")]
4295 + private static extern int cmm_x_service_constructor_description_get_parameters (IntPtr handle, out IntPtr parameterssHandle);
4296 +
4297 + [DllImport("climaker")]
4298 + private static extern IntPtr cmm_x_service_constructor_description_get_parameter (IntPtr parametersHandle, int idx);
4299 +
4300 + [DllImport("climaker")]
4301 + private static extern string cmm_x_service_constructor_description_get_name (IntPtr handle);
4302 +
4303 + [DllImport("climaker")]
4304 + private static extern bool cmm_x_service_constructor_description_is_default_constructor (IntPtr handle);
4305 +
4306 + [DllImport("climaker")]
4307 + private static extern int cmm_x_service_constructor_description_get_exception_types (IntPtr handle, out IntPtr exceptionTypesHandle);
4308 +
4309 + [DllImport("climaker")]
4310 + private static extern IntPtr cmm_x_service_constructor_description_get_exception_type (IntPtr handle, int index);
4311 +
4312 + [DllImport("climaker")]
4313 + private static extern void cmm_x_service_constructor_description_free_exception_types (IntPtr handle, int count);
4314 +}
4315 +
4316 +
4317 +public class MainClass
4318 +{
4319 + class OptionInfo
4320 + {
4321 + public string mName;
4322 + public char mShortOption;
4323 + public bool mHasArgument;
4324 +
4325 + public OptionInfo (string name, char shortOption, bool hasArgument)
4326 + {
4327 + mName = name;
4328 + mShortOption = shortOption;
4329 + mHasArgument = hasArgument;
4330 + }
4331 + }
4332 +
4333 + static OptionInfo[] sOptionInfos = {
4334 + new OptionInfo ("out", 'O', true ),
4335 + new OptionInfo ("types", 'T', true),
4336 + new OptionInfo ("extra", 'X', true),
4337 + new OptionInfo ("reference", 'r', true),
4338 + new OptionInfo ("keyfile", 'k', true),
4339 + new OptionInfo ("delaySign", 'd', true),
4340 + new OptionInfo ("assembly-version", '\0', true),
4341 + new OptionInfo ("assembly-description", '\0', true),
4342 + new OptionInfo ("assembly-product", '\0', true),
4343 + new OptionInfo ("assembly-company", '\0', true),
4344 + new OptionInfo ("assembly-copyright", '\0', true),
4345 + new OptionInfo ("assembly-trademark", '\0', true),
4346 + new OptionInfo ("verbose", 'v', false),
4347 + new OptionInfo ("help", 'h', false)
4348 + };
4349 +
4350 + static string sUsingText =
4351 + "\n" +
4352 + "using: climaker <switches> [registry-file-1 registry-file-2 ...]\n" +
4353 + "\n" +
4354 + "switches:\n" +
4355 + " -O, --out <output-file> output assembly file;\n" +
4356 + " defaults to cli_unotypes.dll if more than one\n" +
4357 + " registry-file is given, else <registry-file>.dll\n" +
4358 + " -T, --types types to be generated (if none is given,\n" +
4359 + " <type1[;type2;...]> then all types of given registries are emitted\n" +
4360 + " -X, --extra <rdb-file> additional rdb to saturate referenced types in\n" +
4361 + " given registry file(s); these types will not be\n" +
4362 + " emitted into the output assembly file\n" +
4363 + " -r, --reference reference metadata from assembly file\n" +
4364 + " <assembly-file>\n" +
4365 + " -k, --keyfile keyfile needed for strong name\n" +
4366 + " --assembly-version <version> sets assembly version\n" +
4367 + " --assembly-description <text> sets assembly description text\n" +
4368 + " --assembly-product <text> sets assembly product name\n" +
4369 + " --assembly-company <text> sets assembly company\n" +
4370 + " --assembly-copyright <text> sets assembly copyright\n" +
4371 + " --assembly-trademark <text> sets assembly trademark\n" +
4372 + " -v, --verbose verbose output to stdout\n" +
4373 + " -h, --help this message\n" +
4374 + "\n" +
4375 + "example: climaker --out cli_mytypes.dll \\\n" +
4376 + " --reference cli_uretypes.dll \\\n" +
4377 + " --extra types.rdb \\\n" +
4378 + " mytypes.rdb\n" +
4379 + "\n";
4380 +
4381 + static OptionInfo GetOptionInfo (string opt)
4382 + {
4383 + return GetOptionInfo (opt, '\0');
4384 + }
4385 +
4386 + static OptionInfo GetOptionInfo (string opt, char shortOpt)
4387 + {
4388 + int pos;
4389 +
4390 + for (pos = 0; pos < sOptionInfos.Length; pos ++) {
4391 + if (opt.Length > 0) {
4392 + if (opt.Equals (sOptionInfos [pos].mName))
4393 + return sOptionInfos [pos];
4394 + } else {
4395 + if (sOptionInfos [pos].mShortOption == shortOpt)
4396 + return sOptionInfos [pos];
4397 + }
4398 + }
4399 +
4400 + return null;
4401 + }
4402 +
4403 + static bool IsOption (OptionInfo optionInfo, ref int pIndex)
4404 + {
4405 + if (sArgs.Length <= pIndex)
4406 + return false;
4407 + string arg = sArgs [pIndex];
4408 +
4409 + if (arg.Length < 2 || arg [0] != '-')
4410 + return false;
4411 +
4412 + if (arg.Length == 2 && arg[ 1 ] == optionInfo.mShortOption) {
4413 + pIndex ++;
4414 +
4415 + return true;
4416 + }
4417 +
4418 + if (arg [1] == '-' && arg.Substring (2).Equals (optionInfo.mName)) {
4419 + pIndex ++;
4420 +
4421 + return true;
4422 + }
4423 +
4424 + return false;
4425 + }
4426 +
4427 + static bool ReadOption (ref bool flag, OptionInfo optionInfo, ref int pIndex)
4428 + {
4429 + bool ret = IsOption (optionInfo, ref pIndex);
4430 + if (ret)
4431 + flag = true;
4432 +
4433 + return ret;
4434 + }
4435 +
4436 + static bool ReadArgument (ref string pValue, OptionInfo optionInfo, ref int pIndex)
4437 + {
4438 + if (IsOption (optionInfo, ref pIndex)) {
4439 + if (pIndex < sArgs.Length) {
4440 + pValue = sArgs [pIndex];
4441 + pIndex ++;
4442 +
4443 + return true;
4444 + }
4445 + pIndex --;
4446 + }
4447 +
4448 + return false;
4449 + }
4450 +
4451 + static string[] sArgs;
4452 +
4453 + public static int Main (string[] args)
4454 + {
4455 + if (args.Length <= 0) {
4456 + Console.Write (sUsingText);
4457 + return 0;
4458 + }
4459 +
4460 + int ret = 0;
4461 +
4462 + try {
4463 + sArgs = args;
4464 + Config config = new Config ();
4465 +
4466 + OptionInfo infoHelp = GetOptionInfo ("help");
4467 + OptionInfo infoVerbose = GetOptionInfo ("verbose");
4468 + OptionInfo infoOut = GetOptionInfo ("out");
4469 + OptionInfo infoTypes = GetOptionInfo ("types");
4470 + OptionInfo infoReference = GetOptionInfo ("reference");
4471 + OptionInfo infoExtra = GetOptionInfo ("extra");
4472 + OptionInfo infoKeyfile = GetOptionInfo ("keyfile");
4473 + OptionInfo infoDelaysign = GetOptionInfo ("delaySign");
4474 + OptionInfo infoVersion = GetOptionInfo ("assembly-version");
4475 + OptionInfo infoProduct = GetOptionInfo ("assembly-product");
4476 + OptionInfo infoDescription = GetOptionInfo ("assembly-description");
4477 + OptionInfo infoCompany = GetOptionInfo ("assembly-company");
4478 + OptionInfo infoCopyright = GetOptionInfo ("assembly-copyright");
4479 + OptionInfo infoTrademark = GetOptionInfo ("assembly-trademark");
4480 +
4481 + int pos;
4482 + string cmdArg = null;
4483 +
4484 + for (pos = 0; pos < sArgs.Length; ) {
4485 + // options
4486 + if (IsOption (infoHelp, ref pos )) {
4487 + Console.Write (sUsingText);
4488 + return 0;
4489 + } else if (ReadArgument (ref cmdArg, infoTypes, ref pos )) {
4490 + config.mExplicitTypes.AddRange (cmdArg.Split (new char[] {';'}));
4491 + } else if (ReadArgument (ref cmdArg, infoExtra, ref pos )) {
4492 + config.mExtraRegistries.Add (cmdArg);
4493 + } else if (ReadArgument (ref cmdArg, infoReference, ref pos )) {
4494 + config.mExtraAssemblies.Add (cmdArg);
4495 + } else if (!ReadOption (ref config.mVerbose, infoVerbose, ref pos) &&
4496 + !ReadArgument (ref config.mOutput, infoOut, ref pos) &&
4497 + !ReadArgument (ref config.mVersion, infoVersion, ref pos) &&
4498 + !ReadArgument (ref config.mDescription, infoDescription, ref pos) &&
4499 + !ReadArgument (ref config.mProduct, infoProduct, ref pos) &&
4500 + !ReadArgument (ref config.mCompany, infoCompany, ref pos) &&
4501 + !ReadArgument (ref config.mCopyright, infoCopyright, ref pos) &&
4502 + !ReadArgument (ref config.mTrademark, infoTrademark, ref pos) &&
4503 + !ReadArgument (ref config.mKeyfile, infoKeyfile, ref pos) &&
4504 + !ReadArgument (ref config.mDelaySign, infoDelaysign, ref pos)) {
4505 + cmdArg = args [pos];
4506 + pos ++;
4507 + cmdArg = cmdArg.Trim();
4508 +
4509 + if (cmdArg.Length > 0) {
4510 + if (cmdArg [0] == '-') { // is option
4511 + OptionInfo optionInfo = null;
4512 +
4513 + if (cmdArg.Length > 2 && cmdArg [1] == '-') {
4514 + // long option
4515 + optionInfo = GetOptionInfo (cmdArg.Substring (2));
4516 + } else if (cmdArg.Length == 2 && cmdArg [1] != '-') {
4517 + // short option
4518 + optionInfo = GetOptionInfo ("", cmdArg [1]);
4519 + }
4520 +
4521 + if (optionInfo == null) {
4522 + Console.WriteLine ("unknown option " + cmdArg + "! Use climaker --help\nto print all options.");
4523 + return 1;
4524 + } else {
4525 + Console.WriteLine ("unhandled valid option?! " + cmdArg);
4526 + if (optionInfo.mHasArgument)
4527 + pos ++;
4528 + }
4529 + } else {
4530 + config.mMandatoryRegistries.Add (cmdArg);
4531 + }
4532 + }
4533 + }
4534 + }
4535 +
4536 + CliMaker cliMaker = new CliMaker (config);
4537 +
4538 + cliMaker.OpenRegistries ();
4539 + cliMaker.PrepareAssembly ();
4540 + cliMaker.Emit ();
4541 + cliMaker.Save ();
4542 + } catch (Exception e) {
4543 + Console.WriteLine ("\n> error: " + e + "\n> dying abnormally...");
4544 + ret = 1;
4545 + }
4546 +
4547 + return ret;
4548 + }
4549 +}