Branch data Line data Source code
1 : : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : : /*
3 : : * This file is part of the LibreOffice project.
4 : : *
5 : : * This Source Code Form is subject to the terms of the Mozilla Public
6 : : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : : *
9 : : * This file incorporates work covered by the following license notice:
10 : : *
11 : : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : : * contributor license agreements. See the NOTICE file distributed
13 : : * with this work for additional information regarding copyright
14 : : * ownership. The ASF licenses this file to you under the Apache
15 : : * License, Version 2.0 (the "License"); you may not use this file
16 : : * except in compliance with the License. You may obtain a copy of
17 : : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : : */
19 : :
20 : : #include <string.h>
21 : :
22 : : #include "rtl/alloc.h"
23 : : #include "registry/writer.hxx"
24 : :
25 : : #include "com/sun/star/beans/PropertyAttribute.hpp"
26 : : #include "com/sun/star/container/XHierarchicalNameAccess.hpp"
27 : : #include "com/sun/star/reflection/XPublished.hpp"
28 : : #include "com/sun/star/reflection/XInterfaceTypeDescription2.hpp"
29 : : #include "com/sun/star/reflection/XSingletonTypeDescription2.hpp"
30 : : #include "com/sun/star/reflection/XServiceTypeDescription2.hpp"
31 : : #include "com/sun/star/reflection/XStructTypeDescription.hpp"
32 : : #include "com/sun/star/reflection/XConstantsTypeDescription.hpp"
33 : : #include "com/sun/star/reflection/XConstantTypeDescription.hpp"
34 : : #include "com/sun/star/reflection/XModuleTypeDescription.hpp"
35 : : #include "com/sun/star/reflection/XInterfaceMethodTypeDescription.hpp"
36 : : #include "com/sun/star/reflection/XInterfaceAttributeTypeDescription2.hpp"
37 : : #include "com/sun/star/reflection/XMethodParameter.hpp"
38 : : #include "com/sun/star/reflection/XCompoundTypeDescription.hpp"
39 : : #include "com/sun/star/reflection/XIndirectTypeDescription.hpp"
40 : : #include "com/sun/star/reflection/XEnumTypeDescription.hpp"
41 : :
42 : : #include "codemaker/generatedtypeset.hxx"
43 : :
44 : : using namespace com::sun::star::uno;
45 : : using namespace com::sun::star::beans;
46 : : using namespace com::sun::star::container;
47 : : using namespace com::sun::star::reflection;
48 : : using namespace codemaker;
49 : :
50 : : using ::rtl::OUString;
51 : : using ::rtl::OString;
52 : : using ::rtl::OStringToOUString;
53 : : using ::rtl::OUStringToOString;
54 : :
55 : : namespace unodevtools {
56 : :
57 : 0 : void writeConstantData(typereg::Writer& rWriter, sal_uInt16 fieldIndex,
58 : : const Reference< XConstantTypeDescription >& xConstant)
59 : :
60 : : {
61 : 0 : RTConstValue constValue;
62 : 0 : OUString uConstTypeName;
63 : 0 : OUString uConstName = xConstant->getName();
64 : 0 : Any aConstantAny = xConstant->getConstantValue();
65 : :
66 : 0 : switch ( aConstantAny.getValueTypeClass() )
67 : : {
68 : : case TypeClass_BOOLEAN:
69 : : {
70 : 0 : uConstTypeName = OUString(RTL_CONSTASCII_USTRINGPARAM("boolean"));
71 : 0 : constValue.m_type = RT_TYPE_BOOL;
72 : 0 : aConstantAny >>= constValue.m_value.aBool;
73 : : }
74 : 0 : break;
75 : : case TypeClass_BYTE:
76 : : {
77 : 0 : uConstTypeName = OUString(RTL_CONSTASCII_USTRINGPARAM("byte"));
78 : 0 : constValue.m_type = RT_TYPE_BYTE;
79 : 0 : aConstantAny >>= constValue.m_value.aByte;
80 : : }
81 : 0 : break;
82 : : case TypeClass_SHORT:
83 : : {
84 : 0 : uConstTypeName = OUString(RTL_CONSTASCII_USTRINGPARAM("short"));
85 : 0 : constValue.m_type = RT_TYPE_INT16;
86 : 0 : aConstantAny >>= constValue.m_value.aShort;
87 : : }
88 : 0 : break;
89 : : case TypeClass_UNSIGNED_SHORT:
90 : : {
91 : 0 : uConstTypeName = OUString(RTL_CONSTASCII_USTRINGPARAM("unsigned short"));
92 : 0 : constValue.m_type = RT_TYPE_UINT16;
93 : 0 : aConstantAny >>= constValue.m_value.aUShort;
94 : : }
95 : 0 : break;
96 : : case TypeClass_LONG:
97 : : {
98 : 0 : uConstTypeName = OUString(RTL_CONSTASCII_USTRINGPARAM("long"));
99 : 0 : constValue.m_type = RT_TYPE_INT32;
100 : 0 : aConstantAny >>= constValue.m_value.aLong;
101 : : }
102 : 0 : break;
103 : : case TypeClass_UNSIGNED_LONG:
104 : : {
105 : 0 : uConstTypeName = OUString(RTL_CONSTASCII_USTRINGPARAM("unsigned long"));
106 : 0 : constValue.m_type = RT_TYPE_UINT32;
107 : 0 : aConstantAny >>= constValue.m_value.aULong;
108 : : }
109 : 0 : break;
110 : : case TypeClass_FLOAT:
111 : : {
112 : 0 : uConstTypeName = OUString(RTL_CONSTASCII_USTRINGPARAM("float"));
113 : 0 : constValue.m_type = RT_TYPE_FLOAT;
114 : 0 : aConstantAny >>= constValue.m_value.aFloat;
115 : : }
116 : 0 : break;
117 : : case TypeClass_DOUBLE:
118 : : {
119 : 0 : uConstTypeName = OUString(RTL_CONSTASCII_USTRINGPARAM("double"));
120 : 0 : constValue.m_type = RT_TYPE_DOUBLE;
121 : 0 : aConstantAny >>= constValue.m_value.aDouble;
122 : : }
123 : 0 : break;
124 : : case TypeClass_STRING:
125 : : {
126 : 0 : uConstTypeName = OUString(RTL_CONSTASCII_USTRINGPARAM("string"));
127 : 0 : constValue.m_type = RT_TYPE_STRING;
128 : 0 : constValue.m_value.aString = ((OUString*)aConstantAny.getValue())->getStr();
129 : : }
130 : 0 : break;
131 : : default:
132 : : OSL_FAIL( "unsupported constant type" );
133 : 0 : break;
134 : : }
135 : :
136 : : rWriter.setFieldData(fieldIndex, OUString(), OUString(), RT_ACCESS_CONST,
137 : 0 : uConstName, uConstTypeName, constValue);
138 : 0 : }
139 : :
140 : 0 : sal_uInt32 getInheritedMemberCount(
141 : : GeneratedTypeSet& checkedTypes,
142 : : Sequence< Reference< XTypeDescription > >& superTypes)
143 : : {
144 : 0 : sal_uInt32 memberCount = 0;
145 : :
146 : 0 : sal_uInt16 count = (sal_uInt16)superTypes.getLength();
147 : 0 : OString name;
148 : 0 : for (sal_uInt16 i=0; i < count; i++) {
149 : 0 : name = OString(OUStringToOString(superTypes[i]->getName(),
150 : 0 : RTL_TEXTENCODING_UTF8));
151 : 0 : if (!checkedTypes.contains(name)) {
152 : 0 : checkedTypes.add(name);
153 : :
154 : : Reference< XInterfaceTypeDescription2 > xIFace(
155 : 0 : superTypes[i], UNO_QUERY);
156 : :
157 : : Sequence< Reference< XTypeDescription> > baseTypes =
158 : 0 : xIFace->getBaseTypes();
159 : 0 : if ( baseTypes.getLength() > 0)
160 : 0 : memberCount += getInheritedMemberCount(checkedTypes, baseTypes);
161 : :
162 : 0 : memberCount += xIFace->getMembers().getLength();
163 : : }
164 : : }
165 : :
166 : 0 : return memberCount;
167 : : }
168 : :
169 : 0 : void writeMethodData( typereg::Writer& rWriter, sal_uInt32 calculatedMemberOffset,
170 : : const Reference< XInterfaceMethodTypeDescription >& xMethod )
171 : : {
172 : 0 : RTMethodMode methodMode = RT_MODE_TWOWAY;
173 : 0 : if ( xMethod->isOneway() )
174 : 0 : methodMode = RT_MODE_ONEWAY;
175 : :
176 : 0 : Sequence< Reference< XMethodParameter > > parameters(xMethod->getParameters());
177 : 0 : Sequence< Reference< XTypeDescription > > exceptions(xMethod->getExceptions());
178 : :
179 : 0 : OUString name(xMethod->getMemberName());
180 : 0 : sal_uInt16 methodIndex = (sal_uInt16)(xMethod->getPosition()
181 : 0 : - calculatedMemberOffset);
182 : 0 : sal_uInt16 paramCount = (sal_uInt16)parameters.getLength();
183 : 0 : sal_uInt16 exceptionCount = (sal_uInt16)exceptions.getLength();
184 : :
185 : : rWriter.setMethodData(methodIndex, OUString(), methodMode,
186 : 0 : xMethod->getMemberName(),
187 : 0 : xMethod->getReturnType()->getName().replace('.', '/'),
188 : 0 : paramCount, exceptionCount);
189 : :
190 : 0 : RTParamMode paramMode = RT_PARAM_IN;
191 : : sal_uInt16 i;
192 : :
193 : 0 : for ( i=0; i < paramCount; i++) {
194 : 0 : Reference< XMethodParameter > xParam = parameters[i];
195 : 0 : if ( xParam->isIn() && xParam->isOut())
196 : 0 : paramMode = RT_PARAM_INOUT;
197 : 0 : else if ( xParam->isIn() )
198 : 0 : paramMode = RT_PARAM_IN;
199 : 0 : else if ( xParam->isOut() )
200 : 0 : paramMode = RT_PARAM_OUT;
201 : :
202 : : rWriter.setMethodParameterData(methodIndex,
203 : 0 : (sal_uInt16)xParam->getPosition(),
204 : 0 : paramMode, xParam->getName(),
205 : 0 : xParam->getType()->
206 : 0 : getName().replace('.', '/'));
207 : 0 : }
208 : :
209 : 0 : for (i=0; i < exceptionCount; i++) {
210 : : rWriter.setMethodExceptionTypeName(
211 : 0 : methodIndex, i, exceptions[i]->getName().replace('.', '/'));
212 : 0 : }
213 : 0 : }
214 : :
215 : 0 : void writeAttributeMethodData(
216 : : typereg::Writer& rWriter, sal_uInt16& methodindex, RTMethodMode methodmode,
217 : : const Reference<XInterfaceAttributeTypeDescription2>& xAttr)
218 : : {
219 : 0 : Sequence<Reference<XCompoundTypeDescription> > seqExcp;
220 : 0 : if (methodmode == RT_MODE_ATTRIBUTE_GET)
221 : 0 : seqExcp = xAttr->getGetExceptions();
222 : : else
223 : 0 : seqExcp = xAttr->getSetExceptions();
224 : :
225 : 0 : if (seqExcp.getLength() > 0) {
226 : : rWriter.setMethodData(methodindex, OUString(), methodmode,
227 : 0 : xAttr->getMemberName(),
228 : : rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("void")),
229 : 0 : 0, (sal_uInt16)seqExcp.getLength());
230 : :
231 : 0 : for (sal_Int32 i=0; i < seqExcp.getLength(); i++) {
232 : : rWriter.setMethodExceptionTypeName(
233 : : methodindex, (sal_uInt16)i,
234 : 0 : seqExcp[i]->getName().replace('.', '/'));
235 : : }
236 : 0 : ++methodindex;
237 : 0 : }
238 : 0 : }
239 : :
240 : 0 : RTFieldAccess checkParameterizedTypeFlag(const Sequence< OUString >& typeParams,
241 : : const OUString & memberType)
242 : : {
243 : 0 : for (sal_uInt16 i=0; i < typeParams.getLength(); i++) {
244 : 0 : if (typeParams[i].equals(memberType))
245 : 0 : return RT_ACCESS_PARAMETERIZED_TYPE;
246 : : }
247 : :
248 : 0 : return RT_ACCESS_READWRITE;
249 : : }
250 : :
251 : 0 : RTFieldAccess checkPropertyFlags(short flags) {
252 : 0 : RTFieldAccess propertyFlags=RT_ACCESS_INVALID;
253 : 0 : switch(flags) {
254 : : case PropertyAttribute::MAYBEVOID:
255 : 0 : propertyFlags |= RT_ACCESS_MAYBEVOID;
256 : : case PropertyAttribute::BOUND:
257 : 0 : propertyFlags |= RT_ACCESS_BOUND;
258 : : case PropertyAttribute::CONSTRAINED:
259 : 0 : propertyFlags |= RT_ACCESS_CONSTRAINED;
260 : : case PropertyAttribute::TRANSIENT:
261 : 0 : propertyFlags |= RT_ACCESS_TRANSIENT;
262 : : case PropertyAttribute::READONLY :
263 : 0 : propertyFlags |= RT_ACCESS_READONLY;
264 : : case PropertyAttribute::MAYBEAMBIGUOUS:
265 : 0 : propertyFlags |= RT_ACCESS_MAYBEAMBIGUOUS;
266 : : case PropertyAttribute::MAYBEDEFAULT:
267 : 0 : propertyFlags |= RT_ACCESS_MAYBEDEFAULT;
268 : : case PropertyAttribute::REMOVEABLE:
269 : 0 : propertyFlags |= RT_ACCESS_REMOVEABLE;
270 : : case PropertyAttribute::OPTIONAL:
271 : 0 : propertyFlags |= RT_ACCESS_OPTIONAL;
272 : : }
273 : 0 : return propertyFlags;
274 : : }
275 : :
276 : 0 : void* getTypeBlob(Reference< XHierarchicalNameAccess > xTDmgr,
277 : : const OString& typeName, sal_uInt32* blobsize)
278 : : {
279 : 0 : if ( typeName.isEmpty() )
280 : 0 : return NULL;
281 : :
282 : : OUString uTypeName(OStringToOUString(typeName, RTL_TEXTENCODING_UTF8)
283 : 0 : .replace('/', '.'));
284 : :
285 : 0 : Any aTypeAny( xTDmgr->getByHierarchicalName( uTypeName ) );
286 : :
287 : 0 : if ( !aTypeAny.hasValue() )
288 : 0 : return NULL;
289 : :
290 : 0 : Reference< XTypeDescription > xType;
291 : 0 : aTypeAny >>= xType;
292 : :
293 : 0 : if ( !xType.is() )
294 : 0 : return NULL;
295 : :
296 : 0 : Reference< XPublished > xPublished(xType, UNO_QUERY);
297 : 0 : void* pBlob = NULL;
298 : 0 : switch (xType->getTypeClass())
299 : : {
300 : : case TypeClass_CONSTANTS:
301 : : {
302 : 0 : Reference< XConstantsTypeDescription > xCFace(xType, UNO_QUERY);
303 : :
304 : 0 : if ( !xCFace.is() )
305 : 0 : return NULL;
306 : :
307 : : Sequence< Reference< XConstantTypeDescription > > constTypes(
308 : 0 : xCFace->getConstants());
309 : 0 : sal_uInt16 constCount = (sal_uInt16)constTypes.getLength();
310 : :
311 : : typereg::Writer writer(TYPEREG_VERSION_1, OUString(), OUString(),
312 : 0 : RT_TYPE_CONSTANTS, xPublished->isPublished(),
313 : : uTypeName.replace('.', '/'),
314 : 0 : 0, constCount, 0, 0);
315 : :
316 : 0 : for (sal_uInt16 i=0; i < constCount; i++)
317 : 0 : writeConstantData(writer, i, constTypes[i]);
318 : :
319 : 0 : const void* p = writer.getBlob(blobsize);
320 : 0 : pBlob = (sal_uInt8*)rtl_allocateMemory(*blobsize);
321 : 0 : memcpy(pBlob, p, *blobsize);
322 : : }
323 : 0 : break;
324 : : case TypeClass_MODULE:
325 : : {
326 : 0 : Reference< XModuleTypeDescription > xMFace(xType, UNO_QUERY);
327 : :
328 : 0 : if ( !xMFace.is() )
329 : 0 : return NULL;
330 : :
331 : : Sequence< Reference< XTypeDescription > > memberTypes(
332 : 0 : xMFace->getMembers());
333 : :
334 : 0 : sal_uInt16 memberCount = (sal_uInt16)memberTypes.getLength();
335 : 0 : sal_uInt16 constCount = 0;
336 : : sal_Int16 i;
337 : :
338 : 0 : for ( i=0; i < memberCount; i++) {
339 : 0 : if ( TypeClass_CONSTANT == memberTypes[i]->getTypeClass() )
340 : 0 : constCount++;
341 : : }
342 : :
343 : : typereg::Writer writer(TYPEREG_VERSION_1, OUString(), OUString(),
344 : 0 : RT_TYPE_MODULE, xPublished->isPublished(),
345 : : uTypeName.replace('.', '/'),
346 : 0 : 0, constCount, 0, 0);
347 : :
348 : 0 : if ( 0 < constCount ) {
349 : 0 : Reference< XConstantTypeDescription > xConst;
350 : 0 : sal_uInt16 fieldIndex = 0;
351 : 0 : for (i=0; i < memberCount; i++) {
352 : 0 : if ( TypeClass_CONSTANT == memberTypes[i]->getTypeClass() ) {
353 : : xConst = Reference< XConstantTypeDescription >(
354 : 0 : memberTypes[i], UNO_QUERY);
355 : :
356 : 0 : writeConstantData(writer, ++fieldIndex, xConst);
357 : : }
358 : 0 : }
359 : : }
360 : :
361 : 0 : const void* p = writer.getBlob(blobsize);
362 : 0 : pBlob = (sal_uInt8*)rtl_allocateMemory(*blobsize);
363 : 0 : memcpy(pBlob, p, *blobsize);
364 : : }
365 : 0 : break;
366 : : case TypeClass_INTERFACE:
367 : : {
368 : 0 : Reference< XInterfaceTypeDescription2 > xIFace(xType, UNO_QUERY);
369 : :
370 : 0 : if ( !xIFace.is() )
371 : 0 : return NULL;
372 : :
373 : 0 : Reference< XInterfaceAttributeTypeDescription2 > xAttr;
374 : 0 : Reference< XInterfaceMethodTypeDescription > xMethod;
375 : : Sequence< Reference< XInterfaceMemberTypeDescription > > memberTypes(
376 : 0 : xIFace->getMembers());
377 : : Sequence< Reference< XTypeDescription > > baseTypes =
378 : 0 : xIFace->getBaseTypes();
379 : : Sequence< Reference< XTypeDescription > > optBaseTypes =
380 : 0 : xIFace->getOptionalBaseTypes();
381 : :
382 : 0 : sal_uInt16 baseCount = (sal_uInt16)baseTypes.getLength();
383 : 0 : sal_uInt16 optBaseCount = (sal_uInt16)optBaseTypes.getLength();
384 : 0 : sal_uInt16 memberCount = (sal_uInt16)memberTypes.getLength();
385 : 0 : sal_uInt16 attrCount = 0, attrmethods = 0;
386 : 0 : sal_uInt16 inheritedMemberCount = 0;
387 : : sal_uInt16 i;
388 : :
389 : 0 : for (i=0; i < memberCount; i++) {
390 : : xAttr = Reference< XInterfaceAttributeTypeDescription2 >(
391 : 0 : memberTypes[i], UNO_QUERY);
392 : 0 : if ( xAttr.is() ) {
393 : 0 : attrCount++;
394 : :
395 : 0 : if (xAttr->getGetExceptions().getLength() > 0)
396 : 0 : attrmethods++;
397 : :
398 : 0 : if (xAttr->getSetExceptions().getLength() > 0)
399 : 0 : attrmethods++;
400 : : }
401 : : }
402 : :
403 : : // check inherited members count
404 : 0 : if (baseCount > 0) {
405 : 0 : GeneratedTypeSet checkedTypes;
406 : : inheritedMemberCount = (sal_uInt16)getInheritedMemberCount(
407 : 0 : checkedTypes, baseTypes );
408 : : }
409 : :
410 : : typereg::Writer writer(TYPEREG_VERSION_1, OUString(), OUString(),
411 : 0 : RT_TYPE_INTERFACE, xPublished->isPublished(),
412 : : uTypeName.replace('.', '/'),
413 : : baseCount, attrCount, memberCount-attrCount+attrmethods,
414 : 0 : (sal_uInt16)optBaseTypes.getLength());
415 : :
416 : : // set super types
417 : 0 : for (i=0; i < baseCount; i++) {
418 : 0 : writer.setSuperTypeName(i, baseTypes[i]->
419 : 0 : getName().replace('.', '/'));
420 : : }
421 : :
422 : : // set optional super types
423 : 0 : RTReferenceType referenceType = RT_REF_SUPPORTS;
424 : 0 : RTFieldAccess fieldAccess = RT_ACCESS_OPTIONAL;
425 : 0 : for (i=0; i < optBaseCount; i++) {
426 : : writer.setReferenceData(i, OUString(), referenceType,
427 : 0 : fieldAccess, optBaseTypes[i]->
428 : 0 : getName().replace('.', '/'));
429 : : }
430 : :
431 : 0 : fieldAccess = RT_ACCESS_READWRITE;
432 : : // reset attrCount, used for method index calculation
433 : 0 : attrCount = 0;
434 : 0 : attrmethods = 0;
435 : 0 : for (i=0; i < memberCount; i++) {
436 : : xAttr = Reference< XInterfaceAttributeTypeDescription2 >(
437 : 0 : memberTypes[i], UNO_QUERY);
438 : 0 : if ( xAttr.is() ) {
439 : 0 : ++attrCount;
440 : 0 : if (xAttr->isReadOnly())
441 : 0 : fieldAccess = RT_ACCESS_READONLY;
442 : : else
443 : 0 : fieldAccess = RT_ACCESS_READWRITE;
444 : :
445 : 0 : if (xAttr->isBound())
446 : 0 : fieldAccess |= RT_ACCESS_BOUND;
447 : :
448 : 0 : writer.setFieldData((sal_uInt16)memberTypes[i]->getPosition()
449 : : - inheritedMemberCount,
450 : : OUString(), OUString(), fieldAccess,
451 : 0 : memberTypes[i]->getMemberName(),
452 : 0 : xAttr->getType()->getName().replace('.','/'),
453 : 0 : RTConstValue());
454 : :
455 : : writeAttributeMethodData(writer, attrmethods,
456 : 0 : RT_MODE_ATTRIBUTE_GET, xAttr);
457 : 0 : if (!xAttr->isReadOnly()) {
458 : : writeAttributeMethodData(writer, attrmethods,
459 : 0 : RT_MODE_ATTRIBUTE_SET, xAttr);
460 : : }
461 : :
462 : 0 : continue;
463 : : }
464 : :
465 : : xMethod = Reference< XInterfaceMethodTypeDescription >(
466 : 0 : memberTypes[i], UNO_QUERY);
467 : 0 : if ( xMethod.is() ) {
468 : : writeMethodData(writer, attrCount+inheritedMemberCount-attrmethods,
469 : 0 : xMethod);
470 : : }
471 : : }
472 : :
473 : 0 : const void* p = writer.getBlob(blobsize);
474 : 0 : pBlob = (sal_uInt8*)rtl_allocateMemory(*blobsize);
475 : 0 : memcpy(pBlob, p, *blobsize);
476 : : }
477 : 0 : break;
478 : : case TypeClass_STRUCT:
479 : : {
480 : 0 : Reference< XStructTypeDescription > xStruct(xType, UNO_QUERY);
481 : :
482 : 0 : if ( !xStruct.is() )
483 : 0 : return NULL;
484 : :
485 : 0 : if ( xStruct->getTypeArguments().getLength() > 0)
486 : 0 : return NULL;
487 : :
488 : :
489 : 0 : Sequence< OUString > typeParams( xStruct->getTypeParameters());
490 : 0 : Sequence< OUString > memberNames( xStruct->getMemberNames());
491 : : Sequence< Reference< XTypeDescription > > memberTypes(
492 : 0 : xStruct->getMemberTypes());
493 : 0 : sal_uInt16 memberCount = (sal_uInt16)memberNames.getLength();
494 : :
495 : 0 : OUString uSuperType;
496 : 0 : sal_uInt16 superCount=0;
497 : 0 : if ( typeParams.getLength() == 0) {
498 : 0 : Reference< XTypeDescription > xSuperType = xStruct->getBaseType();
499 : 0 : if ( xSuperType.is() ) {
500 : 0 : ++superCount;
501 : 0 : uSuperType = xSuperType->getName().replace('.','/');
502 : 0 : }
503 : : }
504 : : typereg::Writer writer(TYPEREG_VERSION_1, OUString(), OUString(),
505 : 0 : RT_TYPE_STRUCT, xPublished->isPublished(),
506 : : uTypeName.replace('.', '/'),
507 : : superCount, memberCount, 0,
508 : 0 : (sal_uInt16)typeParams.getLength());
509 : :
510 : : // set super type
511 : 0 : if (superCount > 0) {
512 : 0 : writer.setSuperTypeName(0, uSuperType);
513 : : }
514 : :
515 : 0 : sal_uInt16 i=0;
516 : 0 : for (i=0; i < memberCount; i++) {
517 : 0 : RTFieldAccess fieldAccess = RT_ACCESS_READWRITE;
518 : 0 : if (typeParams.getLength() > 0)
519 : : fieldAccess |= checkParameterizedTypeFlag(
520 : 0 : typeParams, memberTypes[i]->getName());
521 : :
522 : : writer.setFieldData(i, OUString(), OUString(), fieldAccess,
523 : 0 : memberNames[i],
524 : 0 : memberTypes[i]->getName().replace('.', '/'),
525 : 0 : RTConstValue());
526 : : }
527 : :
528 : 0 : for (i=0; i < typeParams.getLength(); i++) {
529 : : writer.setReferenceData(i, OUString(), RT_REF_TYPE_PARAMETER,
530 : 0 : RT_ACCESS_INVALID, typeParams[i]);
531 : : }
532 : :
533 : 0 : const void* p = writer.getBlob(blobsize);
534 : 0 : pBlob = (sal_uInt8*)rtl_allocateMemory(*blobsize);
535 : 0 : memcpy(pBlob, p, *blobsize);
536 : : }
537 : 0 : break;
538 : : case TypeClass_EXCEPTION:
539 : : {
540 : 0 : Reference< XCompoundTypeDescription > xComp(xType, UNO_QUERY);
541 : :
542 : 0 : if ( !xComp.is() )
543 : 0 : return NULL;
544 : :
545 : 0 : Sequence< OUString > memberNames( xComp->getMemberNames());
546 : : Sequence< Reference< XTypeDescription > > memberTypes(
547 : 0 : xComp->getMemberTypes());
548 : 0 : sal_uInt16 memberCount = (sal_uInt16)memberNames.getLength();
549 : :
550 : 0 : OUString uSuperType;
551 : 0 : sal_uInt16 superCount=0;
552 : 0 : Reference< XTypeDescription > xSuperType = xComp->getBaseType();
553 : 0 : if ( xSuperType.is() ) {
554 : 0 : ++superCount;
555 : 0 : uSuperType = xSuperType->getName().replace('.','/');
556 : : }
557 : :
558 : : typereg::Writer writer(TYPEREG_VERSION_1, OUString(), OUString(),
559 : 0 : RT_TYPE_EXCEPTION, xPublished->isPublished(),
560 : : uTypeName.replace('.', '/'),
561 : 0 : superCount, memberCount, 0, 0);
562 : :
563 : : // set super type
564 : 0 : if (superCount > 0) {
565 : 0 : writer.setSuperTypeName(0, uSuperType);
566 : : }
567 : :
568 : 0 : for (sal_Int16 i=0; i < memberCount; i++) {
569 : : writer.setFieldData(i, OUString(), OUString(), RT_ACCESS_READWRITE,
570 : 0 : memberNames[i],
571 : 0 : memberTypes[i]->getName().replace('.', '/'),
572 : 0 : RTConstValue());
573 : : }
574 : :
575 : 0 : const void* p = writer.getBlob(blobsize);
576 : 0 : pBlob = (sal_uInt8*)rtl_allocateMemory(*blobsize);
577 : 0 : memcpy(pBlob, p, *blobsize);
578 : : }
579 : 0 : break;
580 : : case TypeClass_ENUM:
581 : : {
582 : 0 : Reference< XEnumTypeDescription > xEnum(xType, UNO_QUERY);
583 : :
584 : 0 : if ( !xEnum.is() )
585 : 0 : return NULL;
586 : :
587 : 0 : Sequence< OUString > enumNames( xEnum->getEnumNames());
588 : 0 : Sequence< sal_Int32 > enumValues( xEnum->getEnumValues());
589 : 0 : sal_uInt16 enumCount = (sal_uInt16)enumNames.getLength();
590 : :
591 : : typereg::Writer writer(TYPEREG_VERSION_1, OUString(), OUString(),
592 : 0 : RT_TYPE_ENUM, xPublished->isPublished(),
593 : : uTypeName.replace('.', '/'),
594 : 0 : 0, enumCount, 0, 0);
595 : :
596 : 0 : RTConstValue constValue;
597 : 0 : for (sal_Int16 i=0; i < enumCount; i++) {
598 : 0 : constValue.m_type = RT_TYPE_INT32;
599 : 0 : constValue.m_value.aLong = enumValues[i];
600 : :
601 : : writer.setFieldData(i, OUString(), OUString(),
602 : 0 : RT_ACCESS_CONST, enumNames[i],
603 : 0 : OUString(), constValue);
604 : : }
605 : :
606 : 0 : const void* p = writer.getBlob(blobsize);
607 : 0 : pBlob = (sal_uInt8*)rtl_allocateMemory(*blobsize);
608 : 0 : memcpy(pBlob, p, *blobsize);
609 : : }
610 : 0 : break;
611 : : case TypeClass_TYPEDEF:
612 : : {
613 : 0 : Reference< XIndirectTypeDescription > xTD(xType, UNO_QUERY);
614 : :
615 : 0 : if ( !xTD.is() )
616 : 0 : return NULL;
617 : :
618 : : typereg::Writer writer(TYPEREG_VERSION_1, OUString(), OUString(),
619 : 0 : RT_TYPE_TYPEDEF, xPublished->isPublished(),
620 : : uTypeName.replace('.', '/'),
621 : 0 : 1, 0, 0, 0);
622 : :
623 : 0 : writer.setSuperTypeName(0, xTD->getReferencedType()
624 : 0 : ->getName().replace('.','/'));
625 : :
626 : 0 : const void* p = writer.getBlob(blobsize);
627 : 0 : pBlob = (sal_uInt8*)rtl_allocateMemory(*blobsize);
628 : 0 : memcpy(pBlob, p, *blobsize);
629 : : }
630 : 0 : break;
631 : : case TypeClass_SERVICE:
632 : : {
633 : 0 : Reference< XServiceTypeDescription2 > xService(xType, UNO_QUERY);
634 : :
635 : 0 : if ( !xService.is() )
636 : 0 : return NULL;
637 : :
638 : : Sequence<Reference<XServiceConstructorDescription> > constructors(
639 : 0 : xService->getConstructors());
640 : 0 : Sequence<Reference<XPropertyTypeDescription> > properties;
641 : 0 : Sequence<Reference<XServiceTypeDescription> > mandatoryServices;
642 : 0 : Sequence<Reference<XServiceTypeDescription> > optionalServices;
643 : 0 : Sequence<Reference<XInterfaceTypeDescription> > mandatoryInterfaces;
644 : 0 : Sequence<Reference<XInterfaceTypeDescription> > optionalInterfaces;
645 : 0 : sal_uInt16 methodCount = (sal_uInt16)constructors.getLength();
646 : 0 : sal_uInt16 referenceCount = 0;
647 : 0 : sal_uInt16 propertyCount = 0;
648 : :
649 : 0 : if ( !xService->isSingleInterfaceBased() ) {
650 : 0 : mandatoryServices = xService->getMandatoryServices();
651 : 0 : optionalServices = xService->getOptionalServices();
652 : 0 : mandatoryInterfaces = xService->getMandatoryInterfaces();
653 : 0 : optionalInterfaces = xService->getOptionalInterfaces();
654 : 0 : properties = xService->getProperties();
655 : : referenceCount = (sal_uInt16)(
656 : 0 : mandatoryServices.getLength()+
657 : 0 : optionalServices.getLength()+
658 : 0 : mandatoryInterfaces.getLength()+
659 : 0 : optionalInterfaces.getLength());
660 : 0 : propertyCount = (sal_uInt16)properties.getLength();
661 : : }
662 : :
663 : : typereg::Writer writer(TYPEREG_VERSION_1, OUString(), OUString(),
664 : 0 : RT_TYPE_SERVICE, xPublished->isPublished(),
665 : : uTypeName.replace('.', '/'),
666 : 0 : (xService->isSingleInterfaceBased() ? 1 : 0),
667 : 0 : propertyCount, methodCount, referenceCount);
668 : :
669 : 0 : sal_uInt16 i=0;
670 : 0 : if ( xService->isSingleInterfaceBased() ) {
671 : 0 : writer.setSuperTypeName(0, xService->getInterface()
672 : 0 : ->getName().replace('.','/'));
673 : :
674 : 0 : sal_uInt16 j=0;
675 : 0 : for ( i=0; i<methodCount; i++ ) {
676 : : Reference<XServiceConstructorDescription> xConstructor(
677 : 0 : constructors[i], UNO_QUERY);
678 : 0 : Sequence<Reference<XParameter> > parameters;
679 : 0 : Sequence<Reference<XCompoundTypeDescription> > exceptions;
680 : 0 : sal_uInt16 parameterCount=0;
681 : 0 : sal_uInt16 exceptionCount=0;
682 : 0 : if ( !xConstructor->isDefaultConstructor() ) {
683 : 0 : parameters = xConstructor->getParameters();
684 : 0 : parameterCount = (sal_uInt16)parameters.getLength();
685 : : }
686 : :
687 : : writer.setMethodData(i, OUString(), RT_MODE_TWOWAY,
688 : 0 : xConstructor->getName(),
689 : : OUString(
690 : : RTL_CONSTASCII_USTRINGPARAM("void")),
691 : 0 : parameterCount, exceptionCount);
692 : :
693 : 0 : if ( !xConstructor->isDefaultConstructor() ) {
694 : 0 : for ( j=0; j<parameterCount; j++ ) {
695 : 0 : Reference<XParameter> xParam(parameters[j], UNO_QUERY);
696 : 0 : RTParamMode paramMode = RT_PARAM_IN;
697 : 0 : if (xParam->isRestParameter())
698 : 0 : paramMode = RT_PARAM_REST;
699 : :
700 : : writer.setMethodParameterData(
701 : 0 : i, (sal_uInt16)xParam->getPosition(),
702 : 0 : paramMode, xParam->getName(),
703 : 0 : xParam->getType()->getName().replace('.', '/'));
704 : 0 : }
705 : :
706 : 0 : for (j=0; j<exceptionCount; j++) {
707 : : Reference<XCompoundTypeDescription> xExcp(
708 : 0 : exceptions[j], UNO_QUERY);
709 : :
710 : : writer.setMethodExceptionTypeName(
711 : 0 : i, j, xExcp->getName().replace('.', '/'));
712 : 0 : }
713 : : }
714 : 0 : }
715 : : } else
716 : : {
717 : 0 : for (i=0; i<propertyCount; i++) {
718 : : Reference<XPropertyTypeDescription> xProp(
719 : 0 : properties[i], UNO_QUERY);
720 : :
721 : : RTFieldAccess propertyFlags = checkPropertyFlags(
722 : 0 : xProp->getPropertyFlags());
723 : :
724 : : writer.setFieldData(i, OUString(), OUString(),
725 : : propertyFlags,
726 : 0 : xProp->getName().copy(xProp->getName().lastIndexOf('.')+1),
727 : 0 : xProp->getPropertyTypeDescription()
728 : 0 : ->getName().replace('.', '/'),
729 : 0 : RTConstValue());
730 : 0 : }
731 : :
732 : 0 : sal_uInt16 refIndex = 0;
733 : 0 : sal_uInt16 length = (sal_uInt16)mandatoryServices.getLength();
734 : 0 : for (i=0; i < length; i++) {
735 : : writer.setReferenceData(refIndex++, OUString(),
736 : : RT_REF_EXPORTS, RT_ACCESS_INVALID,
737 : 0 : mandatoryServices[i]->getName()
738 : 0 : .replace('.', '/'));
739 : : }
740 : 0 : length = (sal_uInt16)optionalServices.getLength();
741 : 0 : for (i=0; i < length; i++) {
742 : : writer.setReferenceData(refIndex++, OUString(),
743 : : RT_REF_EXPORTS, RT_ACCESS_OPTIONAL,
744 : 0 : optionalServices[i]->getName()
745 : 0 : .replace('.', '/'));
746 : : }
747 : 0 : length = (sal_uInt16)mandatoryInterfaces.getLength();
748 : 0 : for (i=0; i < length; i++) {
749 : : writer.setReferenceData(refIndex++, OUString(),
750 : : RT_REF_SUPPORTS, RT_ACCESS_INVALID,
751 : 0 : mandatoryInterfaces[i]->getName()
752 : 0 : .replace('.', '/'));
753 : : }
754 : 0 : length = (sal_uInt16)optionalInterfaces.getLength();
755 : 0 : for (i=0; i < length; i++) {
756 : : writer.setReferenceData(refIndex++, OUString(),
757 : : RT_REF_SUPPORTS, RT_ACCESS_OPTIONAL,
758 : 0 : optionalInterfaces[i]->getName()
759 : 0 : .replace('.', '/'));
760 : : }
761 : : }
762 : :
763 : 0 : const void* p = writer.getBlob(blobsize);
764 : 0 : pBlob = (sal_uInt8*)rtl_allocateMemory(*blobsize);
765 : 0 : memcpy(pBlob, p, *blobsize);
766 : : }
767 : 0 : break;
768 : : case TypeClass_SINGLETON:
769 : : {
770 : 0 : Reference<XSingletonTypeDescription2> xSingleton(xType, UNO_QUERY);
771 : :
772 : 0 : if ( !xSingleton.is() )
773 : 0 : return NULL;
774 : :
775 : : typereg::Writer writer(TYPEREG_VERSION_1, OUString(), OUString(),
776 : 0 : RT_TYPE_SINGLETON, xPublished->isPublished(),
777 : : uTypeName.replace('.', '/'),
778 : 0 : 1, 0, 0, 0);
779 : :
780 : 0 : if (xSingleton->isInterfaceBased()) {
781 : 0 : writer.setSuperTypeName(0, xSingleton->getInterface()
782 : 0 : ->getName().replace('.','/'));
783 : : } else {
784 : 0 : writer.setSuperTypeName(0, xSingleton->getService()
785 : 0 : ->getName().replace('.','/'));
786 : : }
787 : :
788 : 0 : const void* p = writer.getBlob(blobsize);
789 : 0 : pBlob = (sal_uInt8*)rtl_allocateMemory(*blobsize);
790 : 0 : memcpy(pBlob, p, *blobsize);
791 : : }
792 : 0 : break;
793 : : default:
794 : : OSL_FAIL( "unsupported type" );
795 : 0 : break;
796 : : }
797 : :
798 : 0 : return pBlob;
799 : : }
800 : :
801 : : } // end of namespace unodevtools
802 : :
803 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
