| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| #include "rtl/alloc.h" |
| #include "registry/writer.hxx" |
| |
| #include "com/sun/star/beans/PropertyAttribute.hpp" |
| #include "com/sun/star/container/XHierarchicalNameAccess.hpp" |
| #include "com/sun/star/reflection/XPublished.hpp" |
| #include "com/sun/star/reflection/XInterfaceTypeDescription2.hpp" |
| #include "com/sun/star/reflection/XSingletonTypeDescription2.hpp" |
| #include "com/sun/star/reflection/XServiceTypeDescription2.hpp" |
| #include "com/sun/star/reflection/XStructTypeDescription.hpp" |
| #include "com/sun/star/reflection/XConstantsTypeDescription.hpp" |
| #include "com/sun/star/reflection/XConstantTypeDescription.hpp" |
| #include "com/sun/star/reflection/XModuleTypeDescription.hpp" |
| #include "com/sun/star/reflection/XInterfaceMethodTypeDescription.hpp" |
| #include "com/sun/star/reflection/XInterfaceAttributeTypeDescription2.hpp" |
| #include "com/sun/star/reflection/XMethodParameter.hpp" |
| #include "com/sun/star/reflection/XCompoundTypeDescription.hpp" |
| #include "com/sun/star/reflection/XIndirectTypeDescription.hpp" |
| #include "com/sun/star/reflection/XEnumTypeDescription.hpp" |
| |
| #include "codemaker/generatedtypeset.hxx" |
| |
| using namespace com::sun::star::uno; |
| using namespace com::sun::star::beans; |
| using namespace com::sun::star::container; |
| using namespace com::sun::star::reflection; |
| using namespace rtl; |
| using namespace codemaker; |
| |
| namespace unodevtools { |
| |
| void writeConstantData(typereg::Writer& rWriter, sal_uInt16 fieldIndex, |
| const Reference< XConstantTypeDescription >& xConstant) |
| |
| { |
| RTConstValue constValue; |
| OUString uConstTypeName; |
| OUString uConstName = xConstant->getName(); |
| Any aConstantAny = xConstant->getConstantValue(); |
| |
| switch ( aConstantAny.getValueTypeClass() ) |
| { |
| case TypeClass_BOOLEAN: |
| { |
| uConstTypeName = OUString(RTL_CONSTASCII_USTRINGPARAM("boolean")); |
| constValue.m_type = RT_TYPE_BOOL; |
| aConstantAny >>= constValue.m_value.aBool; |
| } |
| break; |
| case TypeClass_BYTE: |
| { |
| uConstTypeName = OUString(RTL_CONSTASCII_USTRINGPARAM("byte")); |
| constValue.m_type = RT_TYPE_BYTE; |
| aConstantAny >>= constValue.m_value.aByte; |
| } |
| break; |
| case TypeClass_SHORT: |
| { |
| uConstTypeName = OUString(RTL_CONSTASCII_USTRINGPARAM("short")); |
| constValue.m_type = RT_TYPE_INT16; |
| aConstantAny >>= constValue.m_value.aShort; |
| } |
| break; |
| case TypeClass_UNSIGNED_SHORT: |
| { |
| uConstTypeName = OUString(RTL_CONSTASCII_USTRINGPARAM("unsigned short")); |
| constValue.m_type = RT_TYPE_UINT16; |
| aConstantAny >>= constValue.m_value.aUShort; |
| } |
| break; |
| case TypeClass_LONG: |
| { |
| uConstTypeName = OUString(RTL_CONSTASCII_USTRINGPARAM("long")); |
| constValue.m_type = RT_TYPE_INT32; |
| aConstantAny >>= constValue.m_value.aLong; |
| } |
| break; |
| case TypeClass_UNSIGNED_LONG: |
| { |
| uConstTypeName = OUString(RTL_CONSTASCII_USTRINGPARAM("unsigned long")); |
| constValue.m_type = RT_TYPE_UINT32; |
| aConstantAny >>= constValue.m_value.aULong; |
| } |
| break; |
| case TypeClass_FLOAT: |
| { |
| uConstTypeName = OUString(RTL_CONSTASCII_USTRINGPARAM("float")); |
| constValue.m_type = RT_TYPE_FLOAT; |
| aConstantAny >>= constValue.m_value.aFloat; |
| } |
| break; |
| case TypeClass_DOUBLE: |
| { |
| uConstTypeName = OUString(RTL_CONSTASCII_USTRINGPARAM("double")); |
| constValue.m_type = RT_TYPE_DOUBLE; |
| aConstantAny >>= constValue.m_value.aDouble; |
| } |
| break; |
| case TypeClass_STRING: |
| { |
| uConstTypeName = OUString(RTL_CONSTASCII_USTRINGPARAM("string")); |
| constValue.m_type = RT_TYPE_STRING; |
| constValue.m_value.aString = ((OUString*)aConstantAny.getValue())->getStr(); |
| } |
| break; |
| default: |
| OSL_ENSURE( 0, "unsupported constant type" ); |
| break; |
| } |
| |
| rWriter.setFieldData(fieldIndex, OUString(), OUString(), RT_ACCESS_CONST, |
| uConstName, uConstTypeName, constValue); |
| } |
| |
| sal_uInt32 getInheritedMemberCount( |
| GeneratedTypeSet& checkedTypes, |
| Sequence< Reference< XTypeDescription > >& superTypes) |
| { |
| sal_uInt32 memberCount = 0; |
| |
| sal_uInt16 count = (sal_uInt16)superTypes.getLength(); |
| OString name; |
| for (sal_uInt16 i=0; i < count; i++) { |
| name = OString(OUStringToOString(superTypes[i]->getName(), |
| RTL_TEXTENCODING_UTF8)); |
| if (!checkedTypes.contains(name)) { |
| checkedTypes.add(name); |
| |
| Reference< XInterfaceTypeDescription2 > xIFace( |
| superTypes[i], UNO_QUERY); |
| |
| Sequence< Reference< XTypeDescription> > baseTypes = |
| xIFace->getBaseTypes(); |
| if ( baseTypes.getLength() > 0) |
| memberCount += getInheritedMemberCount(checkedTypes, baseTypes); |
| |
| memberCount += xIFace->getMembers().getLength(); |
| } |
| } |
| |
| return memberCount; |
| } |
| |
| void writeMethodData( typereg::Writer& rWriter, sal_uInt32 calculatedMemberOffset, |
| const Reference< XInterfaceMethodTypeDescription >& xMethod ) |
| { |
| RTMethodMode methodMode = RT_MODE_TWOWAY; |
| if ( xMethod->isOneway() ) |
| methodMode = RT_MODE_ONEWAY; |
| |
| Sequence< Reference< XMethodParameter > > parameters(xMethod->getParameters()); |
| Sequence< Reference< XTypeDescription > > exceptions(xMethod->getExceptions()); |
| |
| OUString name(xMethod->getMemberName()); |
| sal_uInt16 methodIndex = (sal_uInt16)(xMethod->getPosition() |
| - calculatedMemberOffset); |
| sal_uInt16 paramCount = (sal_uInt16)parameters.getLength(); |
| sal_uInt16 exceptionCount = (sal_uInt16)exceptions.getLength(); |
| |
| rWriter.setMethodData(methodIndex, OUString(), methodMode, |
| xMethod->getMemberName(), |
| xMethod->getReturnType()->getName().replace('.', '/'), |
| paramCount, exceptionCount); |
| |
| RTParamMode paramMode = RT_PARAM_IN; |
| sal_uInt16 i; |
| |
| for ( i=0; i < paramCount; i++) { |
| Reference< XMethodParameter > xParam = parameters[i]; |
| if ( xParam->isIn() && xParam->isOut()) |
| paramMode = RT_PARAM_INOUT; |
| else if ( xParam->isIn() ) |
| paramMode = RT_PARAM_IN; |
| else if ( xParam->isOut() ) |
| paramMode = RT_PARAM_OUT; |
| |
| rWriter.setMethodParameterData(methodIndex, |
| (sal_uInt16)xParam->getPosition(), |
| paramMode, xParam->getName(), |
| xParam->getType()-> |
| getName().replace('.', '/')); |
| } |
| |
| for (i=0; i < exceptionCount; i++) { |
| rWriter.setMethodExceptionTypeName( |
| methodIndex, i, exceptions[i]->getName().replace('.', '/')); |
| } |
| } |
| |
| void writeAttributeMethodData( |
| typereg::Writer& rWriter, sal_uInt16& methodindex, RTMethodMode methodmode, |
| const Reference<XInterfaceAttributeTypeDescription2>& xAttr) |
| { |
| Sequence<Reference<XCompoundTypeDescription> > seqExcp; |
| if (methodmode == RT_MODE_ATTRIBUTE_GET) |
| seqExcp = xAttr->getGetExceptions(); |
| else |
| seqExcp = xAttr->getSetExceptions(); |
| |
| if (seqExcp.getLength() > 0) { |
| rWriter.setMethodData(methodindex, OUString(), methodmode, |
| xAttr->getMemberName(), |
| rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("void")), |
| 0, (sal_uInt16)seqExcp.getLength()); |
| |
| for (sal_Int32 i=0; i < seqExcp.getLength(); i++) { |
| rWriter.setMethodExceptionTypeName( |
| methodindex, (sal_uInt16)i, |
| seqExcp[i]->getName().replace('.', '/')); |
| } |
| ++methodindex; |
| } |
| } |
| |
| RTFieldAccess checkParameterizedTypeFlag(const Sequence< OUString >& typeParams, |
| const OUString & memberType) |
| { |
| for (sal_uInt16 i=0; i < typeParams.getLength(); i++) { |
| if (typeParams[i].equals(memberType)) |
| return RT_ACCESS_PARAMETERIZED_TYPE; |
| } |
| |
| return RT_ACCESS_READWRITE; |
| } |
| |
| RTFieldAccess checkPropertyFlags(short flags) { |
| RTFieldAccess propertyFlags=RT_ACCESS_INVALID; |
| switch(flags) { |
| case PropertyAttribute::MAYBEVOID: |
| propertyFlags |= RT_ACCESS_MAYBEVOID; |
| case PropertyAttribute::BOUND: |
| propertyFlags |= RT_ACCESS_BOUND; |
| case PropertyAttribute::CONSTRAINED: |
| propertyFlags |= RT_ACCESS_CONSTRAINED; |
| case PropertyAttribute::TRANSIENT: |
| propertyFlags |= RT_ACCESS_TRANSIENT; |
| case PropertyAttribute::READONLY : |
| propertyFlags |= RT_ACCESS_READONLY; |
| case PropertyAttribute::MAYBEAMBIGUOUS: |
| propertyFlags |= RT_ACCESS_MAYBEAMBIGUOUS; |
| case PropertyAttribute::MAYBEDEFAULT: |
| propertyFlags |= RT_ACCESS_MAYBEDEFAULT; |
| case PropertyAttribute::REMOVEABLE: |
| propertyFlags |= RT_ACCESS_REMOVEABLE; |
| case PropertyAttribute::OPTIONAL: |
| propertyFlags |= RT_ACCESS_OPTIONAL; |
| } |
| return propertyFlags; |
| } |
| |
| void* getTypeBlob(Reference< XHierarchicalNameAccess > xTDmgr, |
| const OString& typeName, sal_uInt32* blobsize) |
| { |
| if ( typeName.getLength() == 0 ) |
| return NULL; |
| |
| OUString uTypeName(OStringToOUString(typeName, RTL_TEXTENCODING_UTF8) |
| .replace('/', '.')); |
| |
| Any aTypeAny( xTDmgr->getByHierarchicalName( uTypeName ) ); |
| |
| if ( !aTypeAny.hasValue() ) |
| return NULL; |
| |
| Reference< XTypeDescription > xType; |
| aTypeAny >>= xType; |
| |
| if ( !xType.is() ) |
| return NULL; |
| |
| Reference< XPublished > xPublished(xType, UNO_QUERY); |
| void* pBlob = NULL; |
| switch (xType->getTypeClass()) |
| { |
| case TypeClass_CONSTANTS: |
| { |
| Reference< XConstantsTypeDescription > xCFace(xType, UNO_QUERY); |
| |
| if ( !xCFace.is() ) |
| return NULL; |
| |
| Sequence< Reference< XConstantTypeDescription > > constTypes( |
| xCFace->getConstants()); |
| sal_uInt16 constCount = (sal_uInt16)constTypes.getLength(); |
| |
| typereg::Writer writer(TYPEREG_VERSION_1, OUString(), OUString(), |
| RT_TYPE_CONSTANTS, xPublished->isPublished(), |
| uTypeName.replace('.', '/'), |
| 0, constCount, 0, 0); |
| |
| for (sal_uInt16 i=0; i < constCount; i++) |
| writeConstantData(writer, i, constTypes[i]); |
| |
| const void* p = writer.getBlob(blobsize); |
| pBlob = (sal_uInt8*)rtl_allocateMemory(*blobsize); |
| rtl_copyMemory(pBlob, p, *blobsize); |
| } |
| break; |
| case TypeClass_MODULE: |
| { |
| Reference< XModuleTypeDescription > xMFace(xType, UNO_QUERY); |
| |
| if ( !xMFace.is() ) |
| return NULL; |
| |
| Sequence< Reference< XTypeDescription > > memberTypes( |
| xMFace->getMembers()); |
| |
| sal_uInt16 memberCount = (sal_uInt16)memberTypes.getLength(); |
| sal_uInt16 constCount = 0; |
| sal_Int16 i; |
| |
| for ( i=0; i < memberCount; i++) { |
| if ( TypeClass_CONSTANT == memberTypes[i]->getTypeClass() ) |
| constCount++; |
| } |
| |
| typereg::Writer writer(TYPEREG_VERSION_1, OUString(), OUString(), |
| RT_TYPE_MODULE, xPublished->isPublished(), |
| uTypeName.replace('.', '/'), |
| 0, constCount, 0, 0); |
| |
| if ( 0 < constCount ) { |
| Reference< XConstantTypeDescription > xConst; |
| sal_uInt16 fieldIndex = 0; |
| for (i=0; i < memberCount; i++) { |
| if ( TypeClass_CONSTANT == memberTypes[i]->getTypeClass() ) { |
| xConst = Reference< XConstantTypeDescription >( |
| memberTypes[i], UNO_QUERY); |
| |
| writeConstantData(writer, ++fieldIndex, xConst); |
| } |
| } |
| } |
| |
| const void* p = writer.getBlob(blobsize); |
| pBlob = (sal_uInt8*)rtl_allocateMemory(*blobsize); |
| rtl_copyMemory(pBlob, p, *blobsize); |
| } |
| break; |
| case TypeClass_INTERFACE: |
| { |
| Reference< XInterfaceTypeDescription2 > xIFace(xType, UNO_QUERY); |
| |
| if ( !xIFace.is() ) |
| return NULL; |
| |
| Reference< XInterfaceAttributeTypeDescription2 > xAttr; |
| Reference< XInterfaceMethodTypeDescription > xMethod; |
| Sequence< Reference< XInterfaceMemberTypeDescription > > memberTypes( |
| xIFace->getMembers()); |
| Sequence< Reference< XTypeDescription > > baseTypes = |
| xIFace->getBaseTypes(); |
| Sequence< Reference< XTypeDescription > > optBaseTypes = |
| xIFace->getOptionalBaseTypes(); |
| |
| sal_uInt16 baseCount = (sal_uInt16)baseTypes.getLength(); |
| sal_uInt16 optBaseCount = (sal_uInt16)optBaseTypes.getLength(); |
| sal_uInt16 memberCount = (sal_uInt16)memberTypes.getLength(); |
| sal_uInt16 attrCount = 0, attrmethods = 0; |
| sal_uInt16 inheritedMemberCount = 0; |
| sal_uInt16 i; |
| |
| for (i=0; i < memberCount; i++) { |
| xAttr = Reference< XInterfaceAttributeTypeDescription2 >( |
| memberTypes[i], UNO_QUERY); |
| if ( xAttr.is() ) { |
| attrCount++; |
| |
| if (xAttr->getGetExceptions().getLength() > 0) |
| attrmethods++; |
| |
| if (xAttr->getSetExceptions().getLength() > 0) |
| attrmethods++; |
| } |
| } |
| |
| // check inherited members count |
| if (baseCount > 0) { |
| GeneratedTypeSet checkedTypes; |
| inheritedMemberCount = (sal_uInt16)getInheritedMemberCount( |
| checkedTypes, baseTypes ); |
| } |
| |
| typereg::Writer writer(TYPEREG_VERSION_1, OUString(), OUString(), |
| RT_TYPE_INTERFACE, xPublished->isPublished(), |
| uTypeName.replace('.', '/'), |
| baseCount, attrCount, memberCount-attrCount+attrmethods, |
| (sal_uInt16)optBaseTypes.getLength()); |
| |
| // set super types |
| for (i=0; i < baseCount; i++) { |
| writer.setSuperTypeName(i, baseTypes[i]-> |
| getName().replace('.', '/')); |
| } |
| |
| // set optional super types |
| RTReferenceType referenceType = RT_REF_SUPPORTS; |
| RTFieldAccess fieldAccess = RT_ACCESS_OPTIONAL; |
| for (i=0; i < optBaseCount; i++) { |
| writer.setReferenceData(i, OUString(), referenceType, |
| fieldAccess, optBaseTypes[i]-> |
| getName().replace('.', '/')); |
| } |
| |
| fieldAccess = RT_ACCESS_READWRITE; |
| // reset attrCount, used for method index calculation |
| attrCount = 0; |
| attrmethods = 0; |
| for (i=0; i < memberCount; i++) { |
| xAttr = Reference< XInterfaceAttributeTypeDescription2 >( |
| memberTypes[i], UNO_QUERY); |
| if ( xAttr.is() ) { |
| ++attrCount; |
| if (xAttr->isReadOnly()) |
| fieldAccess = RT_ACCESS_READONLY; |
| else |
| fieldAccess = RT_ACCESS_READWRITE; |
| |
| if (xAttr->isBound()) |
| fieldAccess |= RT_ACCESS_BOUND; |
| |
| writer.setFieldData((sal_uInt16)memberTypes[i]->getPosition() |
| - inheritedMemberCount, |
| OUString(), OUString(), fieldAccess, |
| memberTypes[i]->getMemberName(), |
| xAttr->getType()->getName().replace('.','/'), |
| RTConstValue()); |
| |
| writeAttributeMethodData(writer, attrmethods, |
| RT_MODE_ATTRIBUTE_GET, xAttr); |
| if (!xAttr->isReadOnly()) { |
| writeAttributeMethodData(writer, attrmethods, |
| RT_MODE_ATTRIBUTE_SET, xAttr); |
| } |
| |
| continue; |
| } |
| |
| xMethod = Reference< XInterfaceMethodTypeDescription >( |
| memberTypes[i], UNO_QUERY); |
| if ( xMethod.is() ) { |
| writeMethodData(writer, attrCount+inheritedMemberCount-attrmethods, |
| xMethod); |
| } |
| } |
| |
| const void* p = writer.getBlob(blobsize); |
| pBlob = (sal_uInt8*)rtl_allocateMemory(*blobsize); |
| rtl_copyMemory(pBlob, p, *blobsize); |
| } |
| break; |
| case TypeClass_STRUCT: |
| { |
| Reference< XStructTypeDescription > xStruct(xType, UNO_QUERY); |
| |
| if ( !xStruct.is() ) |
| return NULL; |
| |
| if ( xStruct->getTypeArguments().getLength() > 0) |
| return NULL; |
| |
| |
| Sequence< OUString > typeParams( xStruct->getTypeParameters()); |
| Sequence< OUString > memberNames( xStruct->getMemberNames()); |
| Sequence< Reference< XTypeDescription > > memberTypes( |
| xStruct->getMemberTypes()); |
| sal_uInt16 memberCount = (sal_uInt16)memberNames.getLength(); |
| |
| OUString uSuperType; |
| sal_uInt16 superCount=0; |
| if ( typeParams.getLength() == 0) { |
| Reference< XTypeDescription > xSuperType = xStruct->getBaseType(); |
| if ( xSuperType.is() ) { |
| ++superCount; |
| uSuperType = xSuperType->getName().replace('.','/'); |
| } |
| } |
| typereg::Writer writer(TYPEREG_VERSION_1, OUString(), OUString(), |
| RT_TYPE_STRUCT, xPublished->isPublished(), |
| uTypeName.replace('.', '/'), |
| superCount, memberCount, 0, |
| (sal_uInt16)typeParams.getLength()); |
| |
| // set super type |
| if (superCount > 0) { |
| writer.setSuperTypeName(0, uSuperType); |
| } |
| |
| sal_uInt16 i=0; |
| for (i=0; i < memberCount; i++) { |
| RTFieldAccess fieldAccess = RT_ACCESS_READWRITE; |
| if (typeParams.getLength() > 0) |
| fieldAccess |= checkParameterizedTypeFlag( |
| typeParams, memberTypes[i]->getName()); |
| |
| writer.setFieldData(i, OUString(), OUString(), fieldAccess, |
| memberNames[i], |
| memberTypes[i]->getName().replace('.', '/'), |
| RTConstValue()); |
| } |
| |
| for (i=0; i < typeParams.getLength(); i++) { |
| writer.setReferenceData(i, OUString(), RT_REF_TYPE_PARAMETER, |
| RT_ACCESS_INVALID, typeParams[i]); |
| } |
| |
| const void* p = writer.getBlob(blobsize); |
| pBlob = (sal_uInt8*)rtl_allocateMemory(*blobsize); |
| rtl_copyMemory(pBlob, p, *blobsize); |
| } |
| break; |
| case TypeClass_EXCEPTION: |
| { |
| Reference< XCompoundTypeDescription > xComp(xType, UNO_QUERY); |
| |
| if ( !xComp.is() ) |
| return NULL; |
| |
| Sequence< OUString > memberNames( xComp->getMemberNames()); |
| Sequence< Reference< XTypeDescription > > memberTypes( |
| xComp->getMemberTypes()); |
| sal_uInt16 memberCount = (sal_uInt16)memberNames.getLength(); |
| |
| OUString uSuperType; |
| sal_uInt16 superCount=0; |
| Reference< XTypeDescription > xSuperType = xComp->getBaseType(); |
| if ( xSuperType.is() ) { |
| ++superCount; |
| uSuperType = xSuperType->getName().replace('.','/'); |
| } |
| |
| typereg::Writer writer(TYPEREG_VERSION_1, OUString(), OUString(), |
| RT_TYPE_EXCEPTION, xPublished->isPublished(), |
| uTypeName.replace('.', '/'), |
| superCount, memberCount, 0, 0); |
| |
| // set super type |
| if (superCount > 0) { |
| writer.setSuperTypeName(0, uSuperType); |
| } |
| |
| for (sal_Int16 i=0; i < memberCount; i++) { |
| writer.setFieldData(i, OUString(), OUString(), RT_ACCESS_READWRITE, |
| memberNames[i], |
| memberTypes[i]->getName().replace('.', '/'), |
| RTConstValue()); |
| } |
| |
| const void* p = writer.getBlob(blobsize); |
| pBlob = (sal_uInt8*)rtl_allocateMemory(*blobsize); |
| rtl_copyMemory(pBlob, p, *blobsize); |
| } |
| break; |
| case TypeClass_ENUM: |
| { |
| Reference< XEnumTypeDescription > xEnum(xType, UNO_QUERY); |
| |
| if ( !xEnum.is() ) |
| return NULL; |
| |
| Sequence< OUString > enumNames( xEnum->getEnumNames()); |
| Sequence< sal_Int32 > enumValues( xEnum->getEnumValues()); |
| sal_uInt16 enumCount = (sal_uInt16)enumNames.getLength(); |
| |
| typereg::Writer writer(TYPEREG_VERSION_1, OUString(), OUString(), |
| RT_TYPE_ENUM, xPublished->isPublished(), |
| uTypeName.replace('.', '/'), |
| 0, enumCount, 0, 0); |
| |
| RTConstValue constValue; |
| for (sal_Int16 i=0; i < enumCount; i++) { |
| constValue.m_type = RT_TYPE_INT32; |
| constValue.m_value.aLong = enumValues[i]; |
| |
| writer.setFieldData(i, OUString(), OUString(), |
| RT_ACCESS_CONST, enumNames[i], |
| OUString(), constValue); |
| } |
| |
| const void* p = writer.getBlob(blobsize); |
| pBlob = (sal_uInt8*)rtl_allocateMemory(*blobsize); |
| rtl_copyMemory(pBlob, p, *blobsize); |
| } |
| break; |
| case TypeClass_TYPEDEF: |
| { |
| Reference< XIndirectTypeDescription > xTD(xType, UNO_QUERY); |
| |
| if ( !xTD.is() ) |
| return NULL; |
| |
| typereg::Writer writer(TYPEREG_VERSION_1, OUString(), OUString(), |
| RT_TYPE_TYPEDEF, xPublished->isPublished(), |
| uTypeName.replace('.', '/'), |
| 1, 0, 0, 0); |
| |
| writer.setSuperTypeName(0, xTD->getReferencedType() |
| ->getName().replace('.','/')); |
| |
| const void* p = writer.getBlob(blobsize); |
| pBlob = (sal_uInt8*)rtl_allocateMemory(*blobsize); |
| rtl_copyMemory(pBlob, p, *blobsize); |
| } |
| break; |
| case TypeClass_SERVICE: |
| { |
| Reference< XServiceTypeDescription2 > xService(xType, UNO_QUERY); |
| |
| if ( !xService.is() ) |
| return NULL; |
| |
| Sequence<Reference<XServiceConstructorDescription> > constructors( |
| xService->getConstructors()); |
| Sequence<Reference<XPropertyTypeDescription> > properties; |
| Sequence<Reference<XServiceTypeDescription> > mandatoryServices; |
| Sequence<Reference<XServiceTypeDescription> > optionalServices; |
| Sequence<Reference<XInterfaceTypeDescription> > mandatoryInterfaces; |
| Sequence<Reference<XInterfaceTypeDescription> > optionalInterfaces; |
| sal_uInt16 methodCount = (sal_uInt16)constructors.getLength(); |
| sal_uInt16 referenceCount = 0; |
| sal_uInt16 propertyCount = 0; |
| |
| if ( !xService->isSingleInterfaceBased() ) { |
| mandatoryServices = xService->getMandatoryServices(); |
| optionalServices = xService->getOptionalServices(); |
| mandatoryInterfaces = xService->getMandatoryInterfaces(); |
| optionalInterfaces = xService->getOptionalInterfaces(); |
| properties = xService->getProperties(); |
| referenceCount = (sal_uInt16)( |
| mandatoryServices.getLength()+ |
| optionalServices.getLength()+ |
| mandatoryInterfaces.getLength()+ |
| optionalInterfaces.getLength()); |
| propertyCount = (sal_uInt16)properties.getLength(); |
| } |
| |
| typereg::Writer writer(TYPEREG_VERSION_1, OUString(), OUString(), |
| RT_TYPE_SERVICE, xPublished->isPublished(), |
| uTypeName.replace('.', '/'), |
| (xService->isSingleInterfaceBased() ? 1 : 0), |
| propertyCount, methodCount, referenceCount); |
| |
| sal_uInt16 i=0; |
| if ( xService->isSingleInterfaceBased() ) { |
| writer.setSuperTypeName(0, xService->getInterface() |
| ->getName().replace('.','/')); |
| |
| sal_uInt16 j=0; |
| for ( i=0; i<methodCount; i++ ) { |
| Reference<XServiceConstructorDescription> xConstructor( |
| constructors[i], UNO_QUERY); |
| Sequence<Reference<XParameter> > parameters; |
| Sequence<Reference<XCompoundTypeDescription> > exceptions; |
| sal_uInt16 parameterCount=0; |
| sal_uInt16 exceptionCount=0; |
| if ( !xConstructor->isDefaultConstructor() ) { |
| parameters = xConstructor->getParameters(); |
| parameterCount = (sal_uInt16)parameters.getLength(); |
| } |
| |
| writer.setMethodData(i, OUString(), RT_MODE_TWOWAY, |
| xConstructor->getName(), |
| OUString( |
| RTL_CONSTASCII_USTRINGPARAM("void")), |
| parameterCount, exceptionCount); |
| |
| if ( !xConstructor->isDefaultConstructor() ) { |
| for ( j=0; j<parameterCount; j++ ) { |
| Reference<XParameter> xParam(parameters[j], UNO_QUERY); |
| RTParamMode paramMode = RT_PARAM_IN; |
| if (xParam->isRestParameter()) |
| paramMode = RT_PARAM_REST; |
| |
| writer.setMethodParameterData( |
| i, (sal_uInt16)xParam->getPosition(), |
| paramMode, xParam->getName(), |
| xParam->getType()->getName().replace('.', '/')); |
| } |
| |
| for (j=0; j<exceptionCount; j++) { |
| Reference<XCompoundTypeDescription> xExcp( |
| exceptions[j], UNO_QUERY); |
| |
| writer.setMethodExceptionTypeName( |
| i, j, xExcp->getName().replace('.', '/')); |
| } |
| } |
| } |
| } else |
| { |
| for (i=0; i<propertyCount; i++) { |
| Reference<XPropertyTypeDescription> xProp( |
| properties[i], UNO_QUERY); |
| |
| RTFieldAccess propertyFlags = checkPropertyFlags( |
| xProp->getPropertyFlags()); |
| |
| writer.setFieldData(i, OUString(), OUString(), |
| propertyFlags, |
| xProp->getName().copy(xProp->getName().lastIndexOf('.')+1), |
| xProp->getPropertyTypeDescription() |
| ->getName().replace('.', '/'), |
| RTConstValue()); |
| } |
| |
| sal_uInt16 refIndex = 0; |
| sal_uInt16 length = (sal_uInt16)mandatoryServices.getLength(); |
| for (i=0; i < length; i++) { |
| writer.setReferenceData(refIndex++, OUString(), |
| RT_REF_EXPORTS, RT_ACCESS_INVALID, |
| mandatoryServices[i]->getName() |
| .replace('.', '/')); |
| } |
| length = (sal_uInt16)optionalServices.getLength(); |
| for (i=0; i < length; i++) { |
| writer.setReferenceData(refIndex++, OUString(), |
| RT_REF_EXPORTS, RT_ACCESS_OPTIONAL, |
| optionalServices[i]->getName() |
| .replace('.', '/')); |
| } |
| length = (sal_uInt16)mandatoryInterfaces.getLength(); |
| for (i=0; i < length; i++) { |
| writer.setReferenceData(refIndex++, OUString(), |
| RT_REF_SUPPORTS, RT_ACCESS_INVALID, |
| mandatoryInterfaces[i]->getName() |
| .replace('.', '/')); |
| } |
| length = (sal_uInt16)optionalInterfaces.getLength(); |
| for (i=0; i < length; i++) { |
| writer.setReferenceData(refIndex++, OUString(), |
| RT_REF_SUPPORTS, RT_ACCESS_OPTIONAL, |
| optionalInterfaces[i]->getName() |
| .replace('.', '/')); |
| } |
| } |
| |
| const void* p = writer.getBlob(blobsize); |
| pBlob = (sal_uInt8*)rtl_allocateMemory(*blobsize); |
| rtl_copyMemory(pBlob, p, *blobsize); |
| } |
| break; |
| case TypeClass_SINGLETON: |
| { |
| Reference<XSingletonTypeDescription2> xSingleton(xType, UNO_QUERY); |
| |
| if ( !xSingleton.is() ) |
| return NULL; |
| |
| typereg::Writer writer(TYPEREG_VERSION_1, OUString(), OUString(), |
| RT_TYPE_SINGLETON, xPublished->isPublished(), |
| uTypeName.replace('.', '/'), |
| 1, 0, 0, 0); |
| |
| if (xSingleton->isInterfaceBased()) { |
| writer.setSuperTypeName(0, xSingleton->getInterface() |
| ->getName().replace('.','/')); |
| } else { |
| writer.setSuperTypeName(0, xSingleton->getService() |
| ->getName().replace('.','/')); |
| } |
| |
| const void* p = writer.getBlob(blobsize); |
| pBlob = (sal_uInt8*)rtl_allocateMemory(*blobsize); |
| rtl_copyMemory(pBlob, p, *blobsize); |
| } |
| break; |
| default: |
| OSL_ENSURE( 0, "unsupported type" ); |
| break; |
| } |
| |
| return pBlob; |
| } |
| |
| } // end of namespace unodevtools |
