| /************************************************************** |
| * |
| * 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. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_codemaker.hxx" |
| |
| #include <stdio.h> |
| #include <rtl/alloc.h> |
| #include <rtl/ustring.hxx> |
| #include <rtl/strbuf.hxx> |
| |
| #include "corbatype.hxx" |
| #include "corbaoptions.hxx" |
| |
| #include <hash_set> |
| #include <list> |
| |
| using namespace rtl; |
| |
| |
| //************************************************************************* |
| // CorbaType |
| //************************************************************************* |
| CorbaType::CorbaType(TypeReader& typeReader, |
| const OString& typeName, |
| const TypeManager& typeMgr, |
| const TypeDependency& typeDependencies, |
| TypeSet* generatedConversions) |
| : m_inheritedMemberCount(0) |
| , m_indentLength(0) |
| , m_typeName(typeName) |
| , m_reader(typeReader) |
| , m_typeMgr((TypeManager&)typeMgr) |
| , m_dependencies(typeDependencies) |
| , m_generatedConversions(generatedConversions) |
| { |
| sal_Int32 i = typeName.lastIndexOf('/'); |
| m_name = typeName.copy( i != -1 ? i+1 : 0 ); |
| } |
| |
| CorbaType::~CorbaType() |
| { |
| |
| } |
| |
| sal_Bool CorbaType::isNestedTypeByName(const ::rtl::OString& type) |
| { |
| sal_Bool ret = sal_False; |
| |
| sal_Int32 i = type.lastIndexOf('/'); |
| |
| if (i >= 0) |
| { |
| OString outerTypeName(type.copy(0, i)); |
| ret = (m_typeMgr.getTypeClass(outerTypeName) == RT_TYPE_INTERFACE); |
| } |
| |
| return ret; |
| } |
| |
| sal_Bool CorbaType::dump(CorbaOptions* pOptions, FileStream& o, TypeSet* allreadyDumped) |
| throw( CannotDumpException ) |
| { |
| sal_Bool ret = sal_False; |
| |
| ret = dumpConversionFunctions(o, allreadyDumped); |
| |
| return ret; |
| } |
| |
| sal_Bool CorbaType::dumpDependedTypes(CorbaOptions* pOptions, FileStream& o, TypeSet* allreadyDumped) |
| throw( CannotDumpException ) |
| { |
| sal_Bool ret = sal_True; |
| |
| TypeUsingSet usingSet(m_dependencies.getDependencies(m_typeName)); |
| |
| TypeUsingSet::const_iterator iter = usingSet.begin(); |
| OString typeName; |
| sal_uInt32 index = 0; |
| while (iter != usingSet.end()) |
| { |
| typeName = (*iter).m_type; |
| if ((index = typeName.lastIndexOf(']')) > 0) |
| typeName = typeName.copy(index + 1); |
| |
| if ( getUnoBaseType(typeName).isEmpty() ) |
| { |
| if (!produceType(typeName, |
| m_typeMgr, |
| m_dependencies, |
| pOptions, |
| o, allreadyDumped, m_generatedConversions)) |
| { |
| fprintf(stderr, "%s ERROR: %s\n", |
| pOptions->getProgramName().getStr(), |
| OString("cannot dump Type '" + typeName + "'").getStr()); |
| exit(99); |
| } |
| } |
| ++iter; |
| } |
| |
| return ret; |
| } |
| |
| sal_Bool CorbaType::dumpConversionFunctions(FileStream& o, TypeSet* allreadyDumped) |
| throw( CannotDumpException ) |
| { |
| if (m_typeName.lastIndexOf(']') < 0) |
| { |
| dumpInclude(o, allreadyDumped, m_typeName, "hpp", sal_False); |
| dumpDepIncludes(o, allreadyDumped, m_typeName, "hpp"); |
| |
| dumpFunctions(o); |
| } |
| |
| return sal_True; |
| } |
| |
| |
| void CorbaType::dumpDefaultHxxIncludes(FileStream& o) |
| { |
| o << "#ifndef _OSL_MUTEX_HXX_\n" |
| << "#include <osl/mutex.hxx>\n" |
| << "#endif\n\n"; |
| |
| o << "#ifndef _RTL_USTRING_HXX_\n" |
| << "#include <rtl/ustring.hxx>\n" |
| << "#endif\n\n"; |
| |
| o << "#ifndef _COM_SUN_STAR_UNO_TYPE_HXX_\n" |
| << "#include <com/sun/star/uno/Type.hxx>\n" |
| << "#endif\n"; |
| |
| o << "#ifndef _COM_SUN_STAR_UNO_ANY_HXX_\n" |
| << "#include <com/sun/star/uno/Any.hxx>\n" |
| << "#endif\n"; |
| |
| o << "#ifndef _COM_SUN_STAR_UNO_REFERENCE_HXX_\n" |
| << "#include <com/sun/star/uno/Reference.hxx>\n" |
| << "#endif\n"; |
| |
| o << "#ifndef _COM_SUN_STAR_UNO_XINTERFACE_HPP_\n" |
| << "#include <com/sun/star/uno/XInterface.hpp>\n" |
| << "#endif\n"; |
| |
| o << "#ifndef _BONOBO_NULLINTERFACE_HPP_\n" |
| << "#include <Bonobo/NullInterface.hpp>\n" |
| << "#endif\n"; |
| |
| o << "#ifndef _COM_SUN_STAR_UNO_EXCEPTION_HPP_\n" |
| << "#include <com/sun/star/uno/Exception.hpp>\n" |
| << "#endif\n"; |
| |
| o << "#ifndef _COM_SUN_STAR_UNO_RUNTIMEEXCEPTION_HPP_\n" |
| << "#include <com/sun/star/uno/RuntimeException.hpp>\n" |
| << "#endif\n"; |
| |
| o << "#ifndef _COM_SUN_STAR_UNO_SEQUENCE_HXX_\n" |
| << "#include <com/sun/star/uno/Sequence.hxx>\n" |
| << "#endif\n"; |
| } |
| |
| |
| void CorbaType::dumpInclude(FileStream& o, TypeSet* allreadyDumped, const OString& typeName, sal_Char* prefix, sal_Bool bExtended, sal_Bool bCaseSensitive) |
| { |
| OString realTypeName = checkRealBaseType( typeName ); |
| |
| if (!isNestedTypeByName(typeName) && |
| (BT_INVALID == isBaseType(realTypeName)) && |
| !realTypeName.equals("Bonobo/NullInterface") && |
| !realTypeName.equals("com/sun/star/uno/XInterface") && |
| !realTypeName.equals("com/sun/star/uno/TypeClass") && |
| !realTypeName.equals("com/sun/star/uno/Type") && |
| !realTypeName.equals("com/sun/star/uno/Exception") && |
| !realTypeName.equals("com/sun/star/uno/RuntimeException")) |
| { |
| TypeSet::const_iterator iter = allreadyDumped->find(realTypeName); |
| |
| if (iter == allreadyDumped->end()) |
| { |
| allreadyDumped->insert(realTypeName); |
| |
| sal_uInt32 length = 3+ m_typeName.getLength() + strlen(prefix); |
| |
| if (bExtended) |
| length += m_name.getLength() + 1; |
| |
| OStringBuffer tmpBuf(length); |
| |
| tmpBuf.append('_'); |
| tmpBuf.append(typeName); |
| tmpBuf.append('_'); |
| if (bExtended) |
| { |
| tmpBuf.append(m_name); |
| tmpBuf.append('_'); |
| } |
| tmpBuf.append(prefix); |
| tmpBuf.append('_'); |
| |
| OString tmp(tmpBuf.makeStringAndClear().replace('/', '_').toAsciiUpperCase()); |
| |
| length = 1 + typeName.getLength() + strlen(prefix); |
| if (bExtended) |
| length += m_name.getLength() + 1; |
| |
| tmpBuf.ensureCapacity(length); |
| tmpBuf.append(typeName); |
| if (bExtended) |
| { |
| tmpBuf.append('/'); |
| tmpBuf.append(m_name); |
| } |
| tmpBuf.append('.'); |
| tmpBuf.append(prefix); |
| |
| o << "#ifndef " << tmp << "\n#include <"; |
| if (bCaseSensitive) |
| { |
| o << tmpBuf.makeStringAndClear(); |
| } else |
| { |
| o << tmpBuf.makeStringAndClear(); |
| } |
| |
| o << ">\n"; |
| o << "#endif\n"; |
| |
| o << "namespace bonobobridge {\n\n"; |
| |
| std::list<OString> nestedTypes; |
| |
| do |
| { |
| if ((realTypeName.lastIndexOf(']') < 0) && |
| (BT_INVALID == isBaseType(realTypeName)) && |
| !realTypeName.equals("Bonobo/NullInterface") && |
| !realTypeName.equals("com/sun/star/uno/XInterface") && |
| !realTypeName.equals("com/sun/star/uno/TypeClass") && |
| !realTypeName.equals("com/sun/star/uno/Type") && |
| !realTypeName.equals("com/sun/star/uno/Exception") && |
| !realTypeName.equals("com/sun/star/uno/RuntimeException") && |
| !realTypeName.equals("com/sun/star/uno/TypeClass")) |
| { |
| o << "inline sal_Bool cpp_convert_b2u("; |
| dumpUnoType(o, realTypeName, sal_False, sal_True); |
| o << " u, "; |
| dumpCorbaType(o, realTypeName, sal_True, sal_True); |
| o << " b, const ::vos::ORef< ::bonobobridge::Bridge >& bridge);\n"; |
| o << "inline sal_Bool cpp_convert_u2b("; |
| dumpCorbaType(o, realTypeName, sal_False, sal_True); |
| o << " b, "; |
| dumpUnoType(o, realTypeName, sal_True, sal_True); |
| o << " u, const ::vos::ORef< ::bonobobridge::Bridge >& bridge);\n"; |
| } |
| |
| RegistryKey key = m_typeMgr.getTypeKey(realTypeName); |
| RegistryKeyNames nestedTypeNames; |
| key.getKeyNames(OUString(), nestedTypeNames); |
| for (sal_uInt32 i = 0; i < nestedTypeNames.getLength(); i++) |
| { |
| OString nTypeName(OUStringToOString(nestedTypeNames.getElement(i), RTL_TEXTENCODING_UTF8)); |
| |
| nTypeName = checkRealBaseType(nTypeName.copy(5)); |
| |
| if (BT_INVALID == isBaseType(nTypeName)) |
| { |
| allreadyDumped->insert(nTypeName); |
| nestedTypes.push_back(nTypeName); |
| } |
| } |
| |
| if (nestedTypes.size() > 0) |
| { |
| realTypeName = nestedTypes.front(); |
| nestedTypes.pop_front(); |
| } |
| else |
| { |
| realTypeName = ""; |
| } |
| } |
| while ( !realTypeName.isEmpty() ); |
| |
| o << "}; // namespace bonobobridge\n"; |
| } |
| } |
| } |
| |
| void CorbaType::dumpDepIncludes(FileStream& o, TypeSet* allreadyDumped, const OString& typeName, sal_Char* prefix) |
| { |
| TypeUsingSet usingSet(m_dependencies.getDependencies(typeName)); |
| |
| TypeUsingSet::const_iterator iter = usingSet.begin(); |
| |
| OString sPrefix(OString(prefix).toAsciiUpperCase()); |
| sal_Bool bSequenceDumped = sal_False; |
| sal_Bool bInterfaceDumped = sal_False; |
| sal_uInt32 index = 0; |
| sal_uInt32 seqNum = 0; |
| OString relType; |
| while (iter != usingSet.end()) |
| { |
| index = (*iter).m_type.lastIndexOf(']'); |
| seqNum = (index > 0 ? ((index+1) / 2) : 0); |
| |
| relType = (*iter).m_type; |
| if (index > 0) |
| relType = relType.copy(index+1); |
| |
| if (!isNestedTypeByName(relType)) |
| { |
| OString defPrefix("HXX"); |
| if (sPrefix.equals("HDL")) |
| defPrefix = "H"; |
| |
| if (seqNum > 0 && !bSequenceDumped) |
| { |
| bSequenceDumped = sal_True; |
| } |
| |
| if ( getUnoBaseType(relType).isEmpty() && |
| m_typeName != relType) |
| { |
| if (m_typeMgr.getTypeClass(relType) == RT_TYPE_INTERFACE |
| && sPrefix.equals("HDL")) |
| { |
| if (!bInterfaceDumped) |
| { |
| bInterfaceDumped = sal_True; |
| } |
| |
| if (!((*iter).m_use & TYPEUSE_SUPER)) |
| { |
| o << "\n"; |
| dumpNameSpace(o, sal_True, sal_False, relType); |
| o << "\nclass " << scopedName(m_typeName, relType, sal_True) << ";\n"; |
| dumpNameSpace(o, sal_False, sal_False, relType); |
| o << "\n\n"; |
| } else |
| { |
| dumpInclude(o, allreadyDumped, relType, prefix); |
| } |
| } else |
| { |
| dumpInclude(o, allreadyDumped, relType, prefix); |
| } |
| } |
| } |
| ++iter; |
| } |
| } |
| |
| void CorbaType::dumpNameSpace(FileStream& o, sal_Bool bOpen, sal_Bool bFull, const OString& type) |
| { |
| OString typeName(type); |
| sal_Bool bOneLine = sal_True; |
| if ( typeName.isEmpty() ) |
| { |
| typeName = m_typeName; |
| bOneLine = sal_False; |
| } |
| |
| if (typeName == "/") |
| return; |
| |
| if (typeName.indexOf( '/' ) == -1 && !bFull) |
| return; |
| |
| if (!bFull) |
| typeName = typeName.copy( 0, typeName.lastIndexOf( '/' ) ); |
| |
| if (bOpen) |
| { |
| sal_Int32 nIndex = 0; |
| do |
| { |
| o << "namespace " << typeName.getToken(0, '/', nIndex); |
| if (bOneLine) |
| o << " { "; |
| else |
| o << "\n{\n"; |
| } while( nIndex != -1 ); |
| } else |
| { |
| sal_Int32 nPos = 0; |
| do |
| { |
| nPos = typeName.lastIndexOf( '/' ); |
| o << "}"; |
| if( bOneLine ) |
| o << " "; |
| else |
| o << " // " << typeName.copy( nPos+1 ) << "\n"; |
| if( nPos != -1 ) |
| typeName = typeName.copy( 0, nPos ); |
| } while( nPos != -1 ); |
| } |
| } |
| |
| |
| sal_uInt32 CorbaType::getMemberCount() |
| { |
| sal_uInt32 count = m_reader.getMethodCount(); |
| |
| sal_uInt32 fieldCount = m_reader.getFieldCount(); |
| RTFieldAccess access = RT_ACCESS_INVALID; |
| for (sal_uInt16 i=0; i < fieldCount; i++) |
| { |
| access = m_reader.getFieldAccess(i); |
| |
| if (access != RT_ACCESS_CONST && access != RT_ACCESS_INVALID) |
| count++; |
| } |
| return count; |
| } |
| |
| sal_uInt32 CorbaType::checkInheritedMemberCount(const TypeReader* pReader) |
| { |
| sal_Bool bSelfCheck = sal_True; |
| if (!pReader) |
| { |
| bSelfCheck = sal_False; |
| pReader = &m_reader; |
| } |
| |
| sal_uInt32 count = 0; |
| OString superType(pReader->getSuperTypeName()); |
| if ( !superType.isEmpty() ) |
| { |
| TypeReader aSuperReader(m_typeMgr.getTypeReader(superType)); |
| if ( aSuperReader.isValid() ) |
| { |
| count = checkInheritedMemberCount(&aSuperReader); |
| } |
| } |
| |
| if (bSelfCheck) |
| { |
| count += pReader->getMethodCount(); |
| sal_uInt32 fieldCount = pReader->getFieldCount(); |
| RTFieldAccess access = RT_ACCESS_INVALID; |
| for (sal_uInt16 i=0; i < fieldCount; i++) |
| { |
| access = pReader->getFieldAccess(i); |
| |
| if (access != RT_ACCESS_CONST && access != RT_ACCESS_INVALID) |
| count++; |
| } |
| } |
| |
| return count; |
| } |
| |
| sal_uInt32 CorbaType::getInheritedMemberCount() |
| { |
| if (m_inheritedMemberCount == 0) |
| { |
| m_inheritedMemberCount = checkInheritedMemberCount(0); |
| } |
| |
| return m_inheritedMemberCount; |
| } |
| |
| OString CorbaType::getTypeClass(const OString& type, sal_Bool bCStyle) |
| { |
| OString typeName = ( !type.isEmpty() ? type : m_typeName); |
| RTTypeClass rtTypeClass = RT_TYPE_INVALID; |
| |
| if ( !type.isEmpty() ) |
| { |
| typeName = type; |
| rtTypeClass = m_typeMgr.getTypeClass(typeName); |
| } else |
| { |
| typeName = m_typeName; |
| rtTypeClass = m_reader.getTypeClass(); |
| } |
| |
| if (typeName.lastIndexOf(']') > 0) |
| return bCStyle ? "typelib_TypeClass_SEQUENCE" : "::com::sun::star::uno::TypeClass_SEQUENCE"; |
| |
| switch (rtTypeClass) |
| { |
| case RT_TYPE_INTERFACE: |
| return bCStyle ? "typelib_TypeClass_INTERFACE" : "::com::sun::star::uno::TypeClass_INTERFACE"; |
| break; |
| case RT_TYPE_MODULE: |
| return bCStyle ? "typelib_TypeClass_MODULE" : "::com::sun::star::uno::TypeClass_MODULE"; |
| break; |
| case RT_TYPE_STRUCT: |
| return bCStyle ? "typelib_TypeClass_STRUCT" : "::com::sun::star::uno::TypeClass_STRUCT"; |
| break; |
| case RT_TYPE_ENUM: |
| return bCStyle ? "typelib_TypeClass_ENUM" : "::com::sun::star::uno::TypeClass_ENUM"; |
| break; |
| case RT_TYPE_EXCEPTION: |
| return bCStyle ? "typelib_TypeClass_EXCEPTION" : "::com::sun::star::uno::TypeClass_EXCEPTION"; |
| break; |
| case RT_TYPE_TYPEDEF: |
| { |
| OString realType = checkRealBaseType( typeName ); |
| return getTypeClass( realType, bCStyle ); |
| } |
| // return bCStyle ? "typelib_TypeClass_TYPEDEF" : "::com::sun::star::uno::TypeClass_TYPEDEF"; |
| break; |
| case RT_TYPE_SERVICE: |
| return bCStyle ? "typelib_TypeClass_SERVICE" : "::com::sun::star::uno::TypeClass_SERVICE"; |
| break; |
| case RT_TYPE_INVALID: |
| { |
| if (type.equals("long")) |
| return bCStyle ? "typelib_TypeClass_LONG" : "::com::sun::star::uno::TypeClass_LONG"; |
| if (type.equals("short")) |
| return bCStyle ? "typelib_TypeClass_SHORT" : "::com::sun::star::uno::TypeClass_SHORT"; |
| if (type.equals("hyper")) |
| return bCStyle ? "typelib_TypeClass_HYPER" : "::com::sun::star::uno::TypeClass_HYPER"; |
| if (type.equals("string")) |
| return bCStyle ? "typelib_TypeClass_STRING" : "::com::sun::star::uno::TypeClass_STRING"; |
| if (type.equals("boolean")) |
| return bCStyle ? "typelib_TypeClass_BOOLEAN" : "::com::sun::star::uno::TypeClass_BOOLEAN"; |
| if (type.equals("char")) |
| return bCStyle ? "typelib_TypeClass_CHAR" : "::com::sun::star::uno::TypeClass_CHAR"; |
| if (type.equals("byte")) |
| return bCStyle ? "typelib_TypeClass_BYTE" : "::com::sun::star::uno::TypeClass_BYTE"; |
| if (type.equals("any")) |
| return bCStyle ? "typelib_TypeClass_ANY" : "::com::sun::star::uno::TypeClass_ANY"; |
| if (type.equals("type")) |
| return bCStyle ? "typelib_TypeClass_TYPE" : "::com::sun::star::uno::TypeClass_TYPE"; |
| if (type.equals("float")) |
| return bCStyle ? "typelib_TypeClass_FLOAT" : "::com::sun::star::uno::TypeClass_FLOAT"; |
| if (type.equals("double")) |
| return bCStyle ? "typelib_TypeClass_DOUBLE" : "::com::sun::star::uno::TypeClass_DOUBLE"; |
| if (type.equals("void")) |
| return bCStyle ? "typelib_TypeClass_VOID" : "::com::sun::star::uno::TypeClass_VOID"; |
| if (type.equals("unsigned long")) |
| return bCStyle ? "typelib_TypeClass_UNSIGNED_LONG" : "::com::sun::star::uno::TypeClass_UNSIGNED_LONG"; |
| if (type.equals("unsigned short")) |
| return bCStyle ? "typelib_TypeClass_UNSIGNED_SHORT" : "::com::sun::star::uno::TypeClass_UNSIGNED_SHORT"; |
| if (type.equals("unsigned hyper")) |
| return bCStyle ? "typelib_TypeClass_UNSIGNED_HYPER" : "::com::sun::star::uno::TypeClass_UNSIGNED_HYPER"; |
| } |
| break; |
| } |
| |
| return bCStyle ? "typelib_TypeClass_UNKNOWN" : "::com::sun::star::uno::TypeClass_UNKNOWN"; |
| } |
| |
| OString CorbaType::printUnoType(const OString& type, sal_Bool bConst, sal_Bool bRef, sal_Bool bNative) |
| throw( CannotDumpException ) |
| { |
| OStringBuffer ret(1024); |
| OString sType(checkRealBaseType(type, sal_True)); |
| sal_uInt32 index = sType.lastIndexOf(']'); |
| sal_uInt32 seqNum = (index > 0 ? ((index+1) / 2) : 0); |
| |
| OString relType = (index > 0 ? (sType).copy(index+1) : type); |
| |
| RTTypeClass typeClass = m_typeMgr.getTypeClass(relType); |
| |
| if (bConst) ret.append("const "); |
| |
| sal_uInt32 i; |
| for (i=0; i < seqNum; i++) |
| { |
| ret.append("::com::sun::star::uno::Sequence< "); |
| } |
| |
| switch (typeClass) |
| { |
| case RT_TYPE_INTERFACE: |
| if (bNative) |
| ret.append(scopedName(m_typeName, relType)); |
| else |
| ret.append("::com::sun::star::uno::Reference< ").append(scopedName(m_typeName, relType)).append(" >"); |
| break; |
| case RT_TYPE_INVALID: |
| { |
| OString tmp(getUnoBaseType(relType)); |
| if ( !tmp.isEmpty() ) |
| { |
| ret.append(getUnoBaseType(relType)); |
| } else |
| throw CannotDumpException("Unknown type '" + relType + "', incomplete type library. ("+type+")"); |
| } |
| break; |
| case RT_TYPE_STRUCT: |
| case RT_TYPE_ENUM: |
| case RT_TYPE_TYPEDEF: |
| case RT_TYPE_EXCEPTION: |
| ret.append(scopedName(m_typeName, relType)); |
| break; |
| } |
| |
| for (i=0; i < seqNum; i++) |
| { |
| ret.append(" >"); |
| } |
| |
| if (bRef) ret.append("&"); |
| return ret.makeStringAndClear(); |
| } |
| |
| void CorbaType::dumpUnoType(FileStream& o, const OString& type, |
| sal_Bool bConst, sal_Bool bRef, sal_Bool bNative) |
| throw( CannotDumpException ) |
| { |
| OString ret = printUnoType(type, bConst, bRef, bNative); |
| o << ret; |
| } |
| |
| OString CorbaType::printCorbaType(const OString& type, sal_Bool bConst, sal_Bool bRef) |
| throw( CannotDumpException ) |
| { |
| OStringBuffer ret(1024); |
| |
| OString sType(type); |
| |
| sal_uInt32 index = sType.lastIndexOf(']'); |
| sal_uInt32 seqNum = (index > 0 ? ((index+1) / 2) : 0); |
| |
| OString relType = (index > 0 ? (sType).copy(index+1) : type); |
| |
| RTTypeClass typeClass = m_typeMgr.getTypeClass(relType); |
| |
| if (relType.equals("com/sun/star/uno/XInterface")) |
| relType = "Bonobo/Unknown"; |
| |
| if (relType.equals("com/sun/star/uno/TypeClass")) |
| relType = "CORBA_TypeCode"; |
| |
| if (relType.equals("com/sun/star/uno/RuntimeException")) |
| relType = "CORBA_SystemException"; |
| |
| if (relType.equals("com/sun/star/uno/Exception")) |
| relType = "CORBA_any"; |
| |
| if (bConst) ret.append("const "); |
| |
| |
| sal_uInt32 i; |
| for (i=0; i < seqNum; i++) |
| { |
| ret.append("CORBA_sequence_"); |
| } |
| |
| switch (typeClass) |
| { |
| case RT_TYPE_INTERFACE: |
| ret.append(relType.replace('/', '_')); |
| break; |
| case RT_TYPE_INVALID: |
| { |
| OString tmp(getUnoBaseType(relType)); |
| if ( !tmp.isEmpty() ) |
| ret.append(getCorbaBaseType(relType)); |
| else |
| throw CannotDumpException("Unknown type '" + relType + "', incomplete type library. ("+type+")"); |
| } |
| break; |
| case RT_TYPE_STRUCT: |
| case RT_TYPE_ENUM: |
| case RT_TYPE_TYPEDEF: |
| case RT_TYPE_EXCEPTION: |
| ret.append(relType.replace('/', '_')); |
| break; |
| } |
| |
| if (bRef) ret.append("&"); |
| |
| return ret.makeStringAndClear(); |
| } |
| |
| sal_Bool CorbaType::isPassedAsPointer(const OString& type) |
| { |
| sal_Bool ret = sal_False; |
| |
| OString sType(checkSpecialCorbaType(type)); |
| |
| sal_Int32 index = sType.lastIndexOf(']'); |
| sal_Int32 seqNum = (index > 0 ? ((index+1) / 2) : 0); |
| |
| OString relType = (index > 0 ? (sType).copy(index+1) : type); |
| |
| if (index > 0) |
| { |
| OString fakeTest; |
| |
| sal_Int32 j = type.lastIndexOf('/'); |
| if (j >= 0) |
| fakeTest = type.copy(0, j+1)+"_faked_array_"+type.copy(j+1); |
| else |
| fakeTest = "_faked_array_"+sType; |
| |
| TypeReader fakeTestReader = m_typeMgr.getTypeReader(fakeTest); |
| |
| if (fakeTestReader.isValid()) |
| ret = sal_False; |
| else |
| ret = sal_True; |
| } |
| else |
| { |
| RTTypeClass typeClass = m_typeMgr.getTypeClass(sType); |
| |
| switch (typeClass) |
| { |
| case RT_TYPE_STRUCT: |
| case RT_TYPE_EXCEPTION: |
| ret = sal_True; |
| break; |
| |
| case RT_TYPE_INTERFACE: |
| case RT_TYPE_ENUM: |
| case RT_TYPE_INVALID: |
| if (sType.equals("any")) |
| ret = sal_True; |
| else |
| ret = sal_False; |
| break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| sal_Bool CorbaType::isDerivedFromUnknown(const ::rtl::OString& typeName) |
| { |
| sal_Bool ret = sal_True; |
| if ( typeName.isEmpty() ) |
| ret = sal_False; |
| else if (typeName.equals("Bonobo/NullInterface")) |
| ret = sal_False; |
| else if (typeName.equals("com/sun/star/uno/XInterface")) |
| ret = sal_True; |
| else |
| { |
| TypeReader reader(m_typeMgr.getTypeReader(typeName)); |
| if (reader.isValid()) |
| ret = isDerivedFromUnknown(reader.getSuperTypeName()); |
| else |
| ret = sal_False; |
| } |
| return ret; |
| } |
| |
| |
| sal_Bool CorbaType::isArray(const OString& type) |
| { |
| sal_Bool ret = sal_False; |
| |
| OString sType(checkSpecialCorbaType(type)); |
| |
| sal_Int32 index = sType.lastIndexOf(']'); |
| sal_Int32 seqNum = (index > 0 ? ((index+1) / 2) : 0); |
| |
| OString relType = (index > 0 ? (sType).copy(index+1) : type); |
| |
| if (index > 0) |
| { |
| OString fakeTest; |
| |
| sal_Int32 j = type.lastIndexOf('/'); |
| if (j >= 0) |
| fakeTest = type.copy(0, j+1)+"_faked_array_"+type.copy(j+1); |
| else |
| fakeTest = "_faked_array_"+sType; |
| |
| TypeReader fakeTestReader = m_typeMgr.getTypeReader(fakeTest); |
| |
| if (fakeTestReader.isValid()) |
| ret = sal_True; |
| } |
| |
| return ret; |
| } |
| |
| OString CorbaType::printCorbaParameter(const OString& type, sal_Bool bOut) |
| throw( CannotDumpException ) |
| { |
| OStringBuffer ret(1024); |
| |
| OString sType(type); |
| sal_Int32 index = sType.lastIndexOf(']'); |
| sal_Int32 seqNum = (index > 0 ? ((index+1) / 2) : 0); |
| |
| OString relType = (index > 0 ? (sType).copy(index+1) : type); |
| |
| RTTypeClass typeClass = m_typeMgr.getTypeClass(relType); |
| |
| if (relType.equals("Bonobo/NullInterface")) |
| relType = "CORBA_Object"; |
| |
| if (relType.equals("com/sun/star/uno/XInterface")) |
| relType = "Bonobo/Unknown"; |
| |
| if (relType.equals("com/sun/star/uno/TypeClass")) |
| relType = "CORBA_TypeCode"; |
| |
| if (relType.equals("com/sun/star/uno/RuntimeException")) |
| relType = "CORBA_SystemException"; |
| |
| if (relType.equals("com/sun/star/uno/Exception")) |
| relType = "CORBA_any"; |
| |
| int i; |
| for (i=0; i < seqNum; i++) |
| { |
| ret.append("CORBA_sequence_"); |
| } |
| |
| switch (typeClass) |
| { |
| case RT_TYPE_INTERFACE: |
| ret.append(relType.replace('/', '_')); |
| break; |
| case RT_TYPE_INVALID: |
| { |
| OString tmp(getUnoBaseType(relType)); |
| if ( !tmp.isEmpty() ) |
| { |
| ret.append(getCorbaBaseType(relType)); |
| } else |
| throw CannotDumpException("Unknown type '" + relType + "', incomplete type library. ("+type+")"); |
| } |
| break; |
| case RT_TYPE_STRUCT: |
| case RT_TYPE_EXCEPTION: |
| case RT_TYPE_ENUM: |
| case RT_TYPE_TYPEDEF: |
| ret.append(relType.replace('/', '_')); |
| break; |
| } |
| |
| return ret.makeStringAndClear(); |
| } |
| |
| void CorbaType::dumpCorbaType(FileStream& o, const OString& type, |
| sal_Bool bConst, sal_Bool bRef) |
| throw( CannotDumpException ) |
| { |
| OString ret = printCorbaType(type, bConst, bRef); |
| o << ret; |
| } |
| |
| OString CorbaType::getUnoBaseType(const OString& type) |
| { |
| if (type.equals("long")) |
| return "sal_Int32"; |
| if (type.equals("short")) |
| return "sal_Int16"; |
| if (type.equals("hyper")) |
| return "sal_Int64"; |
| if (type.equals("string")) |
| return "::rtl::OUString"; |
| if (type.equals("boolean")) |
| return "sal_Bool"; |
| if (type.equals("char")) |
| return "sal_Unicode"; |
| if (type.equals("byte")) |
| return "sal_Int8"; |
| if (type.equals("any")) |
| return "::com::sun::star::uno::Any"; |
| if (type.equals("type")) |
| return "::com::sun::star::uno::Type"; |
| if (type.equals("float")) |
| return "float"; |
| if (type.equals("double")) |
| return "double"; |
| if (type.equals("octet")) |
| return "sal_Int8"; |
| if (type.equals("void")) |
| return type; |
| if (type.equals("unsigned long")) |
| return "sal_uInt32"; |
| if (type.equals("unsigned short")) |
| return "sal_uInt16"; |
| if (type.equals("unsigned hyper")) |
| return "sal_uInt64"; |
| |
| return OString(); |
| } |
| |
| OString CorbaType::getCorbaBaseType(const OString& type) |
| { |
| if (type.equals("long")) |
| return "CORBA_long"; |
| if (type.equals("short")) |
| return "CORBA_short"; |
| if (type.equals("hyper")) |
| return "CORBA_long_long"; |
| if (type.equals("string")) |
| return "CORBA_char*"; |
| if (type.equals("boolean")) |
| return "CORBA_boolean"; |
| if (type.equals("char")) |
| return "CORBA_char"; |
| if (type.equals("byte")) |
| return "CORBA_octet"; |
| if (type.equals("any")) |
| return "CORBA_any"; |
| if (type.equals("type")) |
| return "CORBA_TypeCode"; |
| if (type.equals("float")) |
| return "CORBA_float"; |
| if (type.equals("double")) |
| return "CORBA_double"; |
| if (type.equals("octet")) |
| return "CORBA_octet"; |
| if (type.equals("void")) |
| return type; |
| if (type.equals("unsigned long")) |
| return "CORBA_unsigned_long"; |
| if (type.equals("unsigned short")) |
| return "CORBA_unsigned_short"; |
| if (type.equals("unsigned hyper")) |
| return "CORBA_unsigned_long_long"; |
| |
| return OString(); |
| } |
| |
| |
| void CorbaType::dumpTypeInit(FileStream& o, const OString& typeName) |
| { |
| OString type(checkSpecialCorbaType(typeName)); |
| |
| BASETYPE baseType = isBaseType(type); |
| |
| switch (baseType) |
| { |
| case BT_BOOLEAN: |
| o << "(sal_False)"; |
| return; |
| break; |
| case BT_ANY: |
| case BT_STRING: |
| o << "()"; |
| return; |
| break; |
| case BT_INVALID: |
| break; |
| default: |
| o << "(("; |
| dumpUnoType(o, type); |
| o << ")" << "0)"; |
| return; |
| } |
| |
| RTTypeClass typeClass = m_typeMgr.getTypeClass(type); |
| |
| if (typeClass == RT_TYPE_ENUM) |
| { |
| RegistryTypeReaderLoader aReaderLoader; |
| |
| if (aReaderLoader.isLoaded()) |
| { |
| TypeReader reader(m_typeMgr.getTypeReader(type)); |
| |
| if ( reader.isValid() ) |
| { |
| sal_Int32 nPos = type.lastIndexOf( '/' ); |
| o << "(" << shortScopedName("", type, sal_False) |
| << "::" << type.copy( nPos != -1 ? nPos+1 : 0 ) |
| << "_" << reader.getFieldName(0) << ")"; |
| return; |
| } |
| } |
| } |
| |
| o << "()"; |
| } |
| |
| BASETYPE CorbaType::isBaseType(const OString& type) |
| { |
| if (type.equals("long")) |
| return BT_LONG; |
| if (type.equals("short")) |
| return BT_SHORT; |
| if (type.equals("hyper")) |
| return BT_HYPER; |
| if (type.equals("string")) |
| return BT_STRING; |
| if (type.equals("boolean")) |
| return BT_BOOLEAN; |
| if (type.equals("char")) |
| return BT_CHAR; |
| if (type.equals("byte")) |
| return BT_BYTE; |
| if (type.equals("any")) |
| return BT_ANY; |
| if (type.equals("float")) |
| return BT_FLOAT; |
| if (type.equals("double")) |
| return BT_DOUBLE; |
| if (type.equals("void")) |
| return BT_VOID; |
| if (type.equals("unsigned long")) |
| return BT_UNSIGNED_LONG; |
| if (type.equals("unsigned short")) |
| return BT_UNSIGNED_SHORT; |
| if (type.equals("unsigned hyper")) |
| return BT_UNSIGNED_HYPER; |
| |
| return BT_INVALID; |
| } |
| |
| OString CorbaType::typeToIdentifier(const OString& type) |
| { |
| sal_uInt32 index = type.lastIndexOf(']'); |
| sal_uInt32 seqNum = (index > 0 ? ((index+1) / 2) : 0); |
| |
| OString relType = (index > 0 ? ((OString)type).copy(index+1) : type); |
| OString sIdentifier; |
| |
| while( seqNum > 0 ) |
| { |
| sIdentifier += OString("seq"); |
| |
| if ( --seqNum == 0 ) |
| { |
| sIdentifier += OString("_"); |
| } |
| } |
| |
| if ( isBaseType(relType) ) |
| { |
| sIdentifier += relType.replace(' ', '_'); |
| } else |
| { |
| sIdentifier += relType.replace('/', '_'); |
| } |
| |
| |
| return sIdentifier; |
| } |
| |
| OString CorbaType::checkSpecialCorbaType(const OString& type) |
| { |
| OString baseType(type); |
| |
| RegistryTypeReaderLoader & rReaderLoader = getRegistryTypeReaderLoader(); |
| |
| RegistryKey key; |
| sal_uInt8* pBuffer=NULL; |
| RTTypeClass typeClass; |
| sal_Bool isTypeDef = (m_typeMgr.getTypeClass(baseType) == RT_TYPE_TYPEDEF); |
| TypeReader reader; |
| |
| while (isTypeDef) |
| { |
| reader = m_typeMgr.getTypeReader(baseType); |
| |
| if (reader.isValid()) |
| { |
| typeClass = reader.getTypeClass(); |
| |
| if (typeClass == RT_TYPE_TYPEDEF) |
| baseType = reader.getSuperTypeName(); |
| else |
| isTypeDef = sal_False; |
| } else |
| break; |
| } |
| |
| return baseType; |
| } |
| |
| OString CorbaType::checkRealBaseType(const OString& type, sal_Bool bResolveTypeOnly) |
| { |
| sal_uInt32 index = type.lastIndexOf(']'); |
| OString baseType = (index > 0 ? ((OString)type).copy(index+1) : type); |
| OString seqPrefix = (index > 0 ? ((OString)type).copy(0, index+1) : OString()); |
| |
| RegistryTypeReaderLoader & rReaderLoader = getRegistryTypeReaderLoader(); |
| |
| RegistryKey key; |
| sal_uInt8* pBuffer=NULL; |
| RTTypeClass typeClass; |
| sal_Bool mustBeChecked = (m_typeMgr.getTypeClass(baseType) == RT_TYPE_TYPEDEF); |
| TypeReader reader; |
| |
| while (mustBeChecked) |
| { |
| reader = m_typeMgr.getTypeReader(baseType); |
| |
| if (reader.isValid()) |
| { |
| typeClass = reader.getTypeClass(); |
| |
| if (typeClass == RT_TYPE_TYPEDEF) |
| { |
| baseType = reader.getSuperTypeName(); |
| index = baseType.lastIndexOf(']'); |
| if (index > 0) |
| { |
| seqPrefix += baseType.copy(0, index+1); |
| baseType = baseType.copy(index+1); |
| } |
| } else |
| mustBeChecked = sal_False; |
| } else |
| break; |
| } |
| |
| if ( bResolveTypeOnly ) |
| baseType = seqPrefix + baseType; |
| |
| return baseType; |
| } |
| |
| |
| void CorbaType::inc(sal_uInt32 num) |
| { |
| m_indentLength += num; |
| } |
| |
| void CorbaType::dec(sal_uInt32 num) |
| { |
| if (m_indentLength - num < 0) |
| m_indentLength = 0; |
| else |
| m_indentLength -= num; |
| } |
| |
| OString CorbaType::indent() |
| { |
| OStringBuffer tmp(m_indentLength); |
| |
| for (sal_uInt32 i=0; i < m_indentLength; i++) |
| { |
| tmp.append(' '); |
| } |
| return tmp.makeStringAndClear(); |
| } |
| |
| OString CorbaType::indent(sal_uInt32 num) |
| { |
| OStringBuffer tmp(m_indentLength + num); |
| |
| for (sal_uInt32 i=0; i < m_indentLength + num; i++) |
| { |
| tmp.append(' '); |
| } |
| return tmp.makeStringAndClear(); |
| } |
| |
| //************************************************************************* |
| // InterfaceType |
| //************************************************************************* |
| InterfaceType::InterfaceType(TypeReader& typeReader, |
| const OString& typeName, |
| const TypeManager& typeMgr, |
| const TypeDependency& typeDependencies, |
| TypeSet* generatedConversions) |
| : CorbaType(typeReader, typeName, typeMgr, typeDependencies, generatedConversions) |
| { |
| m_inheritedMemberCount = 0; |
| m_hasAttributes = sal_False; |
| m_hasMethods = sal_False; |
| } |
| |
| InterfaceType::~InterfaceType() |
| { |
| |
| } |
| |
| |
| void InterfaceType::dumpUnoMethods(FileStream& o, sal_Bool bDeclOnly, sal_Bool bDelegateToSuper) |
| { |
| OString superName(m_reader.getSuperTypeName()); |
| if (bDeclOnly && |
| !superName.equals("Bonobo/NullInterface") && |
| !superName.equals("com/sun/star/uno/XInterface")) |
| { |
| TypeReader reader(m_typeMgr.getTypeReader(superName)); |
| InterfaceType iType(reader, superName, m_typeMgr, TypeDependency(), m_generatedConversions); |
| iType.inc(); |
| iType.dumpUnoMethods(o, bDeclOnly, sal_True); |
| } |
| |
| sal_uInt32 methodCount = m_reader.getMethodCount(); |
| sal_Bool first=sal_True; |
| |
| OString methodName, returnType, paramType, paramName; |
| sal_uInt32 paramCount = 0; |
| sal_uInt32 excCount = 0; |
| RTMethodMode methodMode = RT_MODE_INVALID; |
| RTParamMode paramMode = RT_PARAM_INVALID; |
| |
| sal_Bool bRef = sal_False; |
| sal_Bool bConst = sal_False; |
| sal_Bool bWithRunTimeExcp = sal_True; |
| |
| for (sal_uInt16 i=0; i < methodCount; i++) |
| { |
| methodName = m_reader.getMethodName(i); |
| returnType = m_reader.getMethodReturnType(i); |
| paramCount = m_reader.getMethodParamCount(i); |
| excCount = m_reader.getMethodExcCount(i); |
| methodMode = m_reader.getMethodMode(i); |
| |
| if ( methodName.equals("acquire") || methodName.equals("release") ) |
| bWithRunTimeExcp = sal_False; |
| |
| if (first) |
| { |
| first = sal_False; |
| o << "\n" << indent() << "// Methods\n"; |
| } |
| |
| o << indent(); |
| if (bDeclOnly) |
| o << "virtual "; |
| dumpUnoType(o, returnType); |
| o << " SAL_CALL "; |
| if (!bDeclOnly) |
| { |
| o << "bonobobridge::BonoboWrapper_"; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "::"; |
| } |
| |
| o << methodName << "( "; |
| |
| sal_uInt16 j; |
| for (j=0; j < paramCount; j++) |
| { |
| paramName = m_reader.getMethodParamName(i, j); |
| paramType = m_reader.getMethodParamType(i, j); |
| paramMode = m_reader.getMethodParamMode(i, j); |
| |
| switch (paramMode) |
| { |
| case RT_PARAM_IN: |
| { |
| OString relType = checkSpecialCorbaType(paramType); |
| if (m_typeMgr.getTypeClass(relType) == RT_TYPE_ENUM || |
| (isBaseType(relType) && !relType.equals("string") && !relType.equals("any"))) |
| { |
| bConst = sal_False; |
| bRef = sal_False; |
| } else |
| { |
| bConst = sal_True; |
| bRef = sal_True; |
| } |
| break; |
| } |
| case RT_PARAM_OUT: |
| case RT_PARAM_INOUT: |
| bConst = sal_False; |
| bRef = sal_True; |
| break; |
| } |
| |
| dumpUnoType(o, paramType, bConst, bRef); |
| o << " " << paramName; |
| |
| if (j+1 < paramCount) o << ", "; |
| } |
| o << " )"; |
| |
| o << " throw("; |
| OString excpName; |
| for (j=0; j < excCount; j++) |
| { |
| excpName = m_reader.getMethodExcType(i, j); |
| if (excpName != "com/sun/star/uno/RuntimeException") |
| o << scopedName(m_typeName, excpName); |
| if (bWithRunTimeExcp) |
| o << ", "; |
| } |
| |
| if ( bWithRunTimeExcp ) |
| { |
| o << " ::com::sun::star::uno::RuntimeException"; |
| } |
| |
| if (bDeclOnly && bDelegateToSuper) |
| { |
| o << " ) {\n"; |
| if (returnType.equals("void")) |
| o << indent() << " "; |
| else |
| o << indent() << " return "; |
| o << "BonoboWrapper_"; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "::" << methodName << "( "; |
| for (j = 0; j < paramCount; j++) |
| { |
| paramName = m_reader.getMethodParamName(i, j); |
| o << paramName; |
| if (j < (paramCount-1)) |
| o << ", "; |
| } |
| o << " );\n" |
| << indent() << "}\n"; |
| } |
| else if (!bDeclOnly) |
| { |
| o << " ) {\n"; |
| |
| OStringBuffer preBuffer(1024); |
| OStringBuffer callBuffer(1024); |
| OStringBuffer postBuffer(1024); |
| |
| callBuffer.append(" "); |
| |
| if (!returnType.equals("void")) |
| { |
| preBuffer.append(" "); |
| preBuffer.append(printCorbaParameter(returnType)); |
| if (isPassedAsPointer(returnType)) |
| preBuffer.append("*"); |
| preBuffer.append(" _b_ret;\n"); |
| preBuffer.append(" "); |
| preBuffer.append(printUnoType(returnType, sal_False, sal_False)); |
| preBuffer.append(" _u_ret;\n"); |
| |
| callBuffer.append("_b_ret = "); |
| } |
| |
| callBuffer.append(printCorbaType(m_typeName, sal_False, sal_False)); |
| callBuffer.append("_"); |
| if (methodName.indexOf("_reserved_identifier_") == 0) |
| callBuffer.append(methodName.copy(OString("_reserved_identifier_").getLength())); |
| else |
| callBuffer.append(methodName); |
| |
| callBuffer.append("( m_corbaObject"); |
| |
| for (j=0; j < paramCount; j++) |
| { |
| paramName = m_reader.getMethodParamName(i, j); |
| paramType = m_reader.getMethodParamType(i, j); |
| paramMode = m_reader.getMethodParamMode(i, j); |
| |
| preBuffer.append(" "); |
| preBuffer.append(printCorbaParameter(paramType)); |
| if (isPassedAsPointer(paramType) && (paramMode == RT_PARAM_OUT)) |
| { |
| preBuffer.append("* _b_"); |
| preBuffer.append(paramName); |
| preBuffer.append(";\n"); |
| } |
| else |
| { |
| preBuffer.append(" _b_"); |
| preBuffer.append(paramName); |
| preBuffer.append(";\n"); |
| } |
| |
| switch (paramMode) { |
| case RT_PARAM_IN: |
| |
| if (isArray(paramType)) |
| preBuffer.append(" // fix me: conversion of array types!\n"); |
| else |
| { |
| preBuffer.append(" cpp_convert_u2b("); |
| preBuffer.append("_b_"); |
| preBuffer.append(paramName); |
| preBuffer.append(", "); |
| preBuffer.append(paramName); |
| preBuffer.append(", m_bridge);\n"); |
| } |
| |
| if (isPassedAsPointer(paramType)) |
| callBuffer.append(", &_b_"); |
| else |
| callBuffer.append(", _b_"); |
| break; |
| case RT_PARAM_INOUT: |
| |
| if (isArray(paramType)) |
| preBuffer.append(" // fix me: conversion of array types!\n"); |
| else |
| { |
| preBuffer.append(" cpp_convert_u2b("); |
| if (isPassedAsPointer(paramType)) |
| preBuffer.append("_b_"); |
| else |
| preBuffer.append("_b_"); |
| preBuffer.append(paramName); |
| preBuffer.append(", "); |
| preBuffer.append(paramName); |
| preBuffer.append(", m_bridge);\n"); |
| } |
| |
| callBuffer.append(", &_b_"); |
| |
| if (isArray(paramType)) |
| postBuffer.append(" // fix me: conversion of array types!\n"); |
| else |
| { |
| postBuffer.append(" cpp_convert_b2u("); |
| postBuffer.append(paramName); |
| postBuffer.append(", _b_"); |
| postBuffer.append(paramName); |
| postBuffer.append(", m_bridge);\n"); |
| } |
| |
| break; |
| case RT_PARAM_OUT: |
| |
| callBuffer.append(", &_b_"); |
| |
| if (isArray(paramType)) |
| postBuffer.append(" // fix me: conversion of array types!\n"); |
| else |
| { |
| postBuffer.append(" cpp_convert_b2u("); |
| postBuffer.append(paramName); |
| if (isPassedAsPointer(paramType)) |
| postBuffer.append(", *_b_"); |
| else |
| postBuffer.append(", _b_"); |
| postBuffer.append(paramName); |
| postBuffer.append(", m_bridge);\n"); |
| } |
| |
| break; |
| } |
| |
| |
| callBuffer.append(paramName); |
| } |
| |
| callBuffer.append(", &_ev );\n"); |
| |
| if (!returnType.equals("void")) |
| { |
| if (isArray(returnType)) |
| { |
| postBuffer.append(" // fix me: conversion of array types!\n"); |
| } |
| else |
| { |
| if (isPassedAsPointer(returnType)) |
| postBuffer.append(" cpp_convert_b2u(_u_ret, *_b_ret, m_bridge);\n"); |
| else |
| postBuffer.append(" cpp_convert_b2u(_u_ret, _b_ret, m_bridge);\n"); |
| } |
| postBuffer.append(" return _u_ret;\n"); |
| } |
| |
| o << " ::osl::MutexGuard guard(m_bridge->getORBLock());\n" |
| << " CORBA_Environment _ev;\n" |
| << " CORBA_exception_init (&_ev);\n"; |
| |
| o << preBuffer; |
| o << callBuffer; |
| |
| o << " if (_ev._major != CORBA_NO_EXCEPTION) {\n" |
| << " ::com::sun::star::uno::RuntimeException _ex(::rtl::OUString::createFromAscii(\"exception raised in bonobobridge\"), NULL);\n" |
| << " CORBA_exception_free (&_ev);\n" |
| << " throw _ex;\n" |
| << " }\n" |
| << " CORBA_exception_free (&_ev);\n"; |
| |
| o << postBuffer; |
| |
| o << indent() << "}\n"; |
| } |
| else |
| o << " );\n"; |
| } |
| } |
| |
| void InterfaceType::dumpCorbaMethods(FileStream& o, sal_Bool bDeclOnly) |
| { |
| OString superName(m_reader.getSuperTypeName()); |
| |
| sal_uInt32 methodCount = m_reader.getMethodCount(); |
| |
| OString methodName, returnType, paramType, paramName; |
| sal_uInt32 paramCount = 0; |
| sal_uInt32 excCount = 0; |
| RTMethodMode methodMode = RT_MODE_INVALID; |
| RTParamMode paramMode = RT_PARAM_INVALID; |
| |
| sal_Bool bRef = sal_False; |
| sal_Bool bConst = sal_False; |
| sal_Bool bWithRunTimeExcp = sal_True; |
| |
| for (sal_uInt16 i=0; i < methodCount; i++) |
| { |
| methodName = m_reader.getMethodName(i); |
| returnType = m_reader.getMethodReturnType(i); |
| paramCount = m_reader.getMethodParamCount(i); |
| excCount = m_reader.getMethodExcCount(i); |
| methodMode = m_reader.getMethodMode(i); |
| |
| o << indent() |
| << "extern \"C\" " |
| << printCorbaParameter(returnType); |
| |
| if (isPassedAsPointer(returnType)) |
| o << "*"; |
| |
| o << " bonobobridge_"; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "_" << methodName << "( PortableServer_Servant _servant, "; |
| |
| sal_uInt16 j; |
| for (j=0; j < paramCount; j++) |
| { |
| paramName = m_reader.getMethodParamName(i, j); |
| paramType = m_reader.getMethodParamType(i, j); |
| paramMode = m_reader.getMethodParamMode(i, j); |
| |
| if ((isPassedAsPointer(paramType) || paramType.equals("string") || isArray(paramType)) && |
| (paramMode == RT_PARAM_IN)) |
| o << "const "; |
| |
| o << printCorbaParameter(paramType); |
| |
| if (isPassedAsPointer(paramType)) |
| { |
| if (paramMode == RT_PARAM_OUT) |
| o << "**"; |
| else |
| o << "*"; |
| } |
| else |
| { |
| if (paramMode != RT_PARAM_IN) |
| o << "*"; |
| } |
| |
| |
| o << " " << paramName << ", "; |
| } |
| |
| o << "CORBA_Environment * _ev)"; |
| |
| if (bDeclOnly) |
| o << ";\n"; |
| else |
| { |
| o << " {\n"; |
| OStringBuffer preBuffer(1024); |
| OStringBuffer callBuffer(1024); |
| OStringBuffer postBuffer(1024); |
| |
| callBuffer.append(" "); |
| |
| preBuffer.append(" "); |
| preBuffer.append(printUnoType(m_typeName, sal_False, sal_False)); |
| preBuffer.append(" rThis(("); |
| preBuffer.append(printUnoType(m_typeName, sal_False, sal_False, sal_True)); |
| preBuffer.append(" *)((bonobobridge::UNO_POA_com_sun_star_uno_XInterface*)_servant)->pThis->getUnoObject());\n"); |
| |
| if (!returnType.equals("void")) |
| { |
| preBuffer.append(" "); |
| preBuffer.append(printCorbaParameter(returnType)); |
| if (isPassedAsPointer(returnType)) |
| { |
| preBuffer.append("* _b_ret = "); |
| preBuffer.append(printCorbaType(returnType, sal_False, sal_False)); |
| preBuffer.append("__alloc();\n"); |
| |
| } |
| else |
| { |
| preBuffer.append(" _b_ret;\n"); |
| } |
| preBuffer.append(" "); |
| preBuffer.append(printUnoType(returnType, sal_False, sal_False)); |
| preBuffer.append(" _u_ret;\n"); |
| |
| callBuffer.append("_u_ret = "); |
| } |
| |
| callBuffer.append("rThis->"); |
| callBuffer.append(methodName); |
| callBuffer.append("( "); |
| |
| for (j=0; j < paramCount; j++) |
| { |
| paramName = m_reader.getMethodParamName(i, j); |
| paramType = m_reader.getMethodParamType(i, j); |
| paramMode = m_reader.getMethodParamMode(i, j); |
| |
| preBuffer.append(" "); |
| preBuffer.append(printUnoType(paramType, sal_False, sal_False)); |
| preBuffer.append(" _u_"); |
| preBuffer.append(paramName); |
| preBuffer.append(";\n"); |
| |
| callBuffer.append("_u_"); |
| callBuffer.append(paramName); |
| |
| if (j < (paramCount-1)) |
| callBuffer.append(", "); |
| |
| switch (paramMode) { |
| case RT_PARAM_IN: |
| |
| if (isArray(paramType)) |
| preBuffer.append(" // fix me: conversion of array types!\n"); |
| else |
| { |
| preBuffer.append(" cpp_convert_b2u("); |
| preBuffer.append("_u_"); |
| preBuffer.append(paramName); |
| preBuffer.append(", "); |
| if (isPassedAsPointer(paramType)) |
| preBuffer.append("*"); |
| preBuffer.append(paramName); |
| preBuffer.append(", ((bonobobridge::UNO_POA_com_sun_star_uno_XInterface*)_servant)->pThis->getBridge());\n"); |
| } |
| break; |
| case RT_PARAM_INOUT: |
| |
| if (isArray(paramType)) |
| { |
| preBuffer.append(" // fix me: conversion of array types!\n"); |
| postBuffer.append(" // fix me: conversion of array types!\n"); |
| } |
| else |
| { |
| preBuffer.append(" cpp_convert_b2u("); |
| preBuffer.append("_u_"); |
| preBuffer.append(paramName); |
| preBuffer.append(", "); |
| if (isPassedAsPointer(paramType)) |
| preBuffer.append("*"); |
| preBuffer.append(paramName); |
| preBuffer.append(", ((bonobobridge::UNO_POA_com_sun_star_uno_XInterface*)_servant)->pThis->getBridge());\n"); |
| |
| postBuffer.append(" cpp_convert_u2b("); |
| if (isPassedAsPointer(paramType)) |
| postBuffer.append("*"); |
| postBuffer.append(paramName); |
| postBuffer.append(", _u_"); |
| postBuffer.append(paramName); |
| postBuffer.append(", ((bonobobridge::UNO_POA_com_sun_star_uno_XInterface*)_servant)->pThis->getBridge());\n"); |
| } |
| break; |
| case RT_PARAM_OUT: |
| |
| if (isArray(paramType)) |
| preBuffer.append(" // fix me: conversion of array types!\n"); |
| else |
| { |
| postBuffer.append(" cpp_convert_u2b("); |
| if (isPassedAsPointer(paramType)) |
| postBuffer.append("**"); |
| else |
| postBuffer.append("*"); |
| postBuffer.append(paramName); |
| postBuffer.append(", _u_"); |
| postBuffer.append(paramName); |
| postBuffer.append(", ((bonobobridge::UNO_POA_com_sun_star_uno_XInterface*)_servant)->pThis->getBridge());\n"); |
| } |
| break; |
| } |
| } |
| |
| callBuffer.append(" );\n"); |
| |
| if (!returnType.equals("void")) |
| { |
| if (isArray(returnType)) |
| postBuffer.append(" // fix me: conversion of array types!\n"); |
| else |
| { |
| if (isPassedAsPointer(returnType)) |
| postBuffer.append(" cpp_convert_u2b(*_b_ret, _u_ret, ((bonobobridge::UNO_POA_com_sun_star_uno_XInterface*)_servant)->pThis->getBridge());\n"); |
| else |
| postBuffer.append(" cpp_convert_u2b(_b_ret, _u_ret, ((bonobobridge::UNO_POA_com_sun_star_uno_XInterface*)_servant)->pThis->getBridge());\n"); |
| } |
| |
| postBuffer.append(" return _b_ret;\n"); |
| } |
| |
| o << preBuffer; |
| o << callBuffer; |
| o << postBuffer; |
| |
| o << "}\n"; |
| } |
| } |
| } |
| |
| void InterfaceType::dumpFunctions(FileStream& o) |
| { |
| if (m_typeName.equals("com/sun/star/uno/XInterface") || |
| m_typeName.equals("Bonobo/NullInterface")) |
| return; |
| |
| m_generatedConversions->insert(m_typeName); |
| |
| o << "namespace bonobobridge {\n\n"; |
| |
| /* bonobo implementation class */ |
| o << "class BonoboWrapper_"; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| |
| OString superName(m_reader.getSuperTypeName()); |
| o << " : public BonoboWrapper< BonoboWrapper_"; |
| dumpCorbaType(o, superName, sal_False, sal_False); |
| o << ", "; |
| dumpUnoType(o, m_typeName, sal_False, sal_False, sal_True); |
| o << " > {\n"; |
| |
| o << "public: \n" |
| << " BonoboWrapper_"; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "("; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << " corbaObject," |
| << "const vos::ORef<bonobobridge::Bridge>& bridge)\n"; |
| |
| o << " : BonoboWrapper< " |
| << "BonoboWrapper_"; |
| dumpCorbaType(o, superName, sal_False, sal_False); |
| o << ", "; |
| dumpUnoType(o, m_typeName, sal_False, sal_False, sal_True); |
| o << " >(corbaObject, bridge) {\n"; |
| |
| if (isDerivedFromUnknown(m_typeName)) |
| { |
| o << " m_bridge->registerObjectWrapper(::getCppuType(("; |
| dumpUnoType(o, m_typeName, sal_False, sal_False); |
| o << "*)NULL), m_corbaObject, ("; |
| dumpUnoType(o, m_typeName, sal_False, sal_False, sal_True); |
| o << "*)this);\n"; |
| } |
| |
| o << " }\n"; |
| |
| o << " virtual ~BonoboWrapper_"; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "() {\n"; |
| if (isDerivedFromUnknown(m_typeName)) |
| { |
| o << " m_bridge->unregisterObjectWrapper(::getCppuType(("; |
| dumpUnoType(o, m_typeName, sal_False, sal_False); |
| o << "*)NULL), m_corbaObject, ("; |
| dumpUnoType(o, m_typeName, sal_False, sal_False, sal_True); |
| o << "*)this);\n"; |
| } |
| o << " }\n"; |
| inc(); |
| dumpUnoMethods(o, sal_True, sal_False); |
| dec(); |
| |
| o << "};\n\n"; |
| |
| o << "}; // namespace bonobobridge\n"; |
| |
| dumpUnoMethods(o, sal_False, sal_False); |
| |
| /* convert function bonobo to uno */ |
| o << "static sal_Bool convert_b2u_" << m_typeName.replace('/', '_') |
| << "(void* pOut, const void* pIn, const ::com::sun::star::uno::Type& type, const ::vos::ORef< ::bonobobridge::Bridge >& bridge) {\n" |
| << " sal_Bool ret = sal_True;\n "; |
| dumpUnoType(o, m_typeName, sal_False, sal_False); |
| o << "& _u = *("; |
| dumpUnoType(o, m_typeName, sal_False, sal_False); |
| o << "*) pOut;\n const "; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "& _b = *(const "; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "*) pIn;\n\n" |
| << " _u = new bonobobridge::BonoboWrapper_"; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "(_b, bridge);\n" |
| << " return ret;\n"; |
| |
| o << "}\n\n"; |
| |
| /* POA implementation class */ |
| dumpCorbaMethods(o, sal_True); |
| o << "static POA_"; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "__epv bonobobridge_"; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "_epv = {\n"; |
| sal_uInt32 methodCount = m_reader.getMethodCount(); |
| OString methodName; |
| |
| o << " NULL,\n"; |
| |
| for (sal_uInt16 i=0; i < methodCount; i++) |
| { |
| methodName = m_reader.getMethodName(i); |
| o << " bonobobridge_"; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "_" << methodName; |
| |
| if (i < (methodCount-1)) |
| o << ",\n"; |
| else |
| o << "\n};\n"; |
| } |
| |
| OStringBuffer initBuffer(1024); |
| |
| initBuffer.insert(0, OString("&bonobobridge_") + printCorbaType(m_typeName, sal_False, sal_False) + OString("_epv")); |
| |
| while( !superName.isEmpty() ) |
| { |
| if (superName.equals("Bonobo/NullInterface")) |
| { |
| superName = ""; |
| } |
| else |
| { |
| if (superName.equals("com/sun/star/uno/XInterface")) |
| { |
| initBuffer.insert(0, OString("&bonobobridge_com_sun_star_uno_XInterface_epv, ")); |
| } |
| else |
| { |
| initBuffer.insert(0, OString("&bonobobridge_") + printCorbaType(superName, sal_False, sal_False) + OString("_epv, ")); |
| } |
| TypeReader reader(m_typeMgr.getTypeReader(superName)); |
| superName = reader.getSuperTypeName(); |
| } |
| } |
| |
| initBuffer.insert(0, OString("NULL, ")); |
| |
| o << "static POA_"; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "__vepv bonobobridge_"; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "__vepv = {"; |
| o << initBuffer.makeStringAndClear(); |
| o << " };\n"; |
| |
| superName = m_reader.getSuperTypeName(); |
| |
| o << "namespace bonobobridge {\n\n"; |
| |
| o << "class UnoServant_"; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << " : public UnoServant_com_sun_star_uno_XInterface {\n"; |
| |
| o << "public:\n" |
| << " UnoServant_"; |
| |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "("; |
| dumpUnoType(o, m_typeName, sal_False, sal_False, sal_True); |
| o << "* unoObject," |
| << " const ::vos::ORef<bonobobridge::Bridge>& bridge," |
| << " CORBA_Environment *ev," |
| << " sal_Bool bInitPoa)\n" |
| << " : UnoServant_com_sun_star_uno_XInterface(unoObject, bridge, ev, sal_False) {\n" |
| << " if (bInitPoa) {\n" |
| << " memset(&m_POAUnknown, 0, sizeof(m_POAUnknown));\n" |
| << " POA_"; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "__init((PortableServer_Servant) &(m_POAUnknown.poa), ev);\n" |
| << " m_POAUnknown.pThis = (UnoServant_com_sun_star_uno_XInterface*)this;\n" |
| << " m_POAUnknown.poa.vepv = (POA_Bonobo_Unknown__vepv*)&bonobobridge_"; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "__vepv;\n" |
| << " }\n" |
| << " }\n" |
| << "};\n" |
| << "}; // namespace bonobobridge\n"; |
| |
| dumpCorbaMethods(o, sal_False); |
| |
| /* convert function uno to bonobo */ |
| o << "static sal_Bool convert_u2b_" << m_typeName.replace('/', '_') |
| << "(void* pOut, const void* pIn, const ::com::sun::star::uno::Type& type, const ::vos::ORef< ::bonobobridge::Bridge >& bridge) {\n"; |
| o << " sal_Bool ret = sal_True;\n const "; |
| dumpUnoType(o, m_typeName, sal_False, sal_False); |
| o << "& _u = *(const "; |
| dumpUnoType(o, m_typeName, sal_False, sal_False); |
| o << "*) pIn;\n "; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "& _b = *("; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "*) pOut;\n\n" |
| << " if (_u.is()) {\n" |
| << " bonobobridge::UnoServant_"; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << " *uno_servant;\n" |
| << " POA_"; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << " *poa;\n" |
| << " CORBA_Environment ev;\n" |
| << " CORBA_exception_init (&ev);\n" |
| << " uno_servant = new bonobobridge::UnoServant_"; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "(_u.get(), bridge, &ev, sal_True);\n" |
| << " poa = (POA_"; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "*)uno_servant->getPOA();\n" |
| << " if (ev._major != CORBA_NO_EXCEPTION) {\n" |
| << " delete uno_servant;\n" |
| << " CORBA_exception_free (&ev);\n" |
| << " _b = CORBA_OBJECT_NIL;\n" |
| << " ret = sal_False;\n" |
| << " }\n" |
| << " else {\n" |
| << " CORBA_free(PortableServer_POA_activate_object(bridge->getPOA(), poa, &ev));\n" |
| << " _b = PortableServer_POA_servant_to_reference (bridge->getPOA(), poa, &ev);\n" |
| << " uno_servant->corbaObjectRegistered(_b, getCppuType(("; |
| dumpUnoType(o, m_typeName, sal_False, sal_False); |
| o << "*)NULL)"; |
| |
| if (!isDerivedFromUnknown(m_typeName)) |
| o << ", sal_False"; |
| |
| o << ");\n" |
| << " }\n" |
| << " CORBA_exception_free (&ev);\n" |
| << " }\n" |
| << " return ret;\n" |
| << "}\n\n"; |
| |
| o << "inline sal_Bool bonobobridge::cpp_convert_b2u("; |
| dumpUnoType(o, m_typeName, sal_False, sal_True); |
| o << " u, "; |
| dumpCorbaType(o, m_typeName, sal_True, sal_True); |
| o << " b, const ::vos::ORef< ::bonobobridge::Bridge >& bridge) {\n" |
| << " return bridge->convertB2U(&u, &b, ::getCppuType(&u));\n" |
| << "};\n\n"; |
| |
| o << "inline sal_Bool bonobobridge::cpp_convert_u2b("; |
| dumpCorbaType(o, m_typeName, sal_False, sal_True); |
| o << " b, "; |
| dumpUnoType(o, m_typeName, sal_True, sal_True); |
| o << " u, const ::vos::ORef< ::bonobobridge::Bridge >& bridge) {\n" |
| << " return bridge->convertU2B(&b, &u, ::getCppuType(&u));\n" |
| << "};\n\n"; |
| |
| return; |
| } |
| |
| |
| |
| |
| sal_uInt32 InterfaceType::getMemberCount() |
| { |
| sal_uInt32 count = m_reader.getMethodCount(); |
| |
| if (count) |
| m_hasMethods = sal_True; |
| |
| sal_uInt32 fieldCount = m_reader.getFieldCount(); |
| RTFieldAccess access = RT_ACCESS_INVALID; |
| for (sal_uInt16 i=0; i < fieldCount; i++) |
| { |
| access = m_reader.getFieldAccess(i); |
| |
| if (access != RT_ACCESS_CONST && access != RT_ACCESS_INVALID) |
| { |
| m_hasAttributes = sal_True; |
| count++; |
| } |
| } |
| return count; |
| } |
| |
| sal_uInt32 InterfaceType::checkInheritedMemberCount(const TypeReader* pReader) |
| { |
| sal_uInt32 cout = 0; |
| sal_Bool bSelfCheck = sal_True; |
| if (!pReader) |
| { |
| bSelfCheck = sal_False; |
| pReader = &m_reader; |
| } |
| |
| sal_uInt32 count = 0; |
| OString superType(pReader->getSuperTypeName()); |
| if ( !superType.isEmpty() ) |
| { |
| TypeReader aSuperReader(m_typeMgr.getTypeReader(superType)); |
| if (aSuperReader.isValid()) |
| { |
| count = checkInheritedMemberCount(&aSuperReader); |
| } |
| } |
| |
| if (bSelfCheck) |
| { |
| count += pReader->getMethodCount(); |
| sal_uInt32 fieldCount = pReader->getFieldCount(); |
| RTFieldAccess access = RT_ACCESS_INVALID; |
| for (sal_uInt16 i=0; i < fieldCount; i++) |
| { |
| access = pReader->getFieldAccess(i); |
| |
| if (access != RT_ACCESS_CONST && access != RT_ACCESS_INVALID) |
| count++; |
| } |
| } |
| |
| return count; |
| } |
| |
| sal_uInt32 InterfaceType::getInheritedMemberCount() |
| { |
| if (m_inheritedMemberCount == 0) |
| { |
| m_inheritedMemberCount = checkInheritedMemberCount(0); |
| } |
| |
| return m_inheritedMemberCount; |
| } |
| |
| |
| |
| |
| //************************************************************************* |
| // ModuleType |
| //************************************************************************* |
| ModuleType::ModuleType(TypeReader& typeReader, |
| const OString& typeName, |
| const TypeManager& typeMgr, |
| const TypeDependency& typeDependencies, |
| TypeSet* generatedConversions) |
| : CorbaType(typeReader, typeName, typeMgr, typeDependencies, generatedConversions) |
| { |
| } |
| |
| ModuleType::~ModuleType() |
| { |
| |
| } |
| |
| |
| sal_Bool ModuleType::hasConstants() |
| { |
| sal_uInt32 fieldCount = m_reader.getFieldCount(); |
| RTFieldAccess access = RT_ACCESS_INVALID; |
| |
| for (sal_uInt16 i=0; i < fieldCount; i++) |
| { |
| access = m_reader.getFieldAccess(i); |
| |
| if (access == RT_ACCESS_CONST) |
| return sal_True; |
| } |
| |
| return sal_False; |
| } |
| |
| void ModuleType::dumpFunctions(FileStream& o) |
| { |
| }; |
| |
| sal_Bool ModuleType::dumpConversionFunctions(FileStream& o, TypeSet* allreadyDumped) |
| throw( CannotDumpException ) |
| { |
| sal_Bool bSpecialDefine = sal_True; |
| |
| if (m_reader.getTypeClass() == RT_TYPE_CONSTANTS) |
| { |
| bSpecialDefine = sal_False; |
| } |
| |
| dumpInclude(o, allreadyDumped, m_typeName, "hpp", bSpecialDefine); |
| |
| return sal_True; |
| } |
| |
| //************************************************************************* |
| // ConstantsType |
| //************************************************************************* |
| ConstantsType::ConstantsType(TypeReader& typeReader, |
| const OString& typeName, |
| const TypeManager& typeMgr, |
| const TypeDependency& typeDependencies, |
| TypeSet* generatedConversions) |
| : ModuleType(typeReader, typeName, typeMgr, typeDependencies, generatedConversions) |
| { |
| } |
| |
| ConstantsType::~ConstantsType() |
| { |
| |
| } |
| |
| void ConstantsType::dumpFunctions(FileStream& o) |
| { |
| }; |
| |
| //************************************************************************* |
| // StructureType |
| //************************************************************************* |
| StructureType::StructureType(TypeReader& typeReader, |
| const OString& typeName, |
| const TypeManager& typeMgr, |
| const TypeDependency& typeDependencies, |
| TypeSet* generatedConversions) |
| : CorbaType(typeReader, typeName, typeMgr, typeDependencies, generatedConversions) |
| { |
| } |
| |
| StructureType::~StructureType() |
| { |
| |
| } |
| |
| void StructureType::dumpFunctions(FileStream& o) |
| { |
| m_generatedConversions->insert(m_typeName); |
| |
| OString superType(m_reader.getSuperTypeName()); |
| |
| o << "static sal_Bool convert_b2u_" << m_typeName.replace('/', '_') |
| << "(void* pOut, const void* pIn, const ::com::sun::star::uno::Type& type, const ::vos::ORef< ::bonobobridge::Bridge >& bridge) {\n" |
| << " sal_Bool ret = sal_True;\n "; |
| dumpUnoType(o, m_typeName, sal_False, sal_False); |
| o << "& _u = *("; |
| dumpUnoType(o, m_typeName, sal_False, sal_False); |
| o << "*) pOut;\n const "; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "& _b = *(const "; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "*) pIn;\n\n"; |
| |
| sal_uInt32 fieldCount = m_reader.getFieldCount(); |
| OString fieldName; |
| OString fieldType; |
| sal_uInt16 i=0; |
| sal_Int32 cIndex; |
| OString corbaFieldName; |
| |
| sal_Bool bIsUnion = sal_False; |
| |
| for (i=0; !bIsUnion && (i < fieldCount); i++) |
| bIsUnion = OString("_union_fake_tag").equals(m_reader.getFieldName(i)); |
| |
| if (bIsUnion) |
| { |
| o << " // fix me: union !!!!\n ret = sal_False;\n"; |
| } |
| else |
| { |
| if ( !superType.isEmpty() ) |
| { |
| o << " ret = bonobobridge::cpp_convert_b2u(("; |
| dumpUnoType(o, superType, sal_False, sal_False); |
| o << "&) _u, (const "; |
| dumpCorbaType(o, superType, sal_False, sal_False); |
| o << "&) _b, bridge);\n"; |
| } |
| |
| for (i=0; i < fieldCount; i++) |
| { |
| fieldName = m_reader.getFieldName(i); |
| fieldType = m_reader.getFieldType(i); |
| cIndex = fieldName.indexOf("_reserved_identifier_"); |
| |
| if (cIndex == 0) |
| corbaFieldName = fieldName.copy(OString("_reserved_identifier_").getLength()); |
| else |
| corbaFieldName = fieldName; |
| |
| if (isArray(fieldType)) |
| o << " // fix me: no conversion of array types!\n"; |
| else |
| o << " if (ret)\n" |
| << " ret = bonobobridge::cpp_convert_b2u(" |
| << "_u." << fieldName.getStr() |
| << " , _b." << corbaFieldName.getStr() |
| << ", bridge);\n"; |
| } |
| } |
| o << " return ret;\n" |
| << "}\n\n" |
| << "static sal_Bool convert_u2b_" << m_typeName.replace('/', '_') |
| << "(void* pOut, const void* pIn, const ::com::sun::star::uno::Type& type, const ::vos::ORef< ::bonobobridge::Bridge >& bridge) {\n" |
| << " sal_Bool ret = sal_True;\n const "; |
| dumpUnoType(o, m_typeName, sal_False, sal_False); |
| o << "& _u = *(const "; |
| dumpUnoType(o, m_typeName, sal_False, sal_False); |
| o << "*) pIn;\n "; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "& _b = *("; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "*) pOut;\n\n"; |
| |
| if (bIsUnion) |
| o << " // fix me: union !!!!\n ret = sal_False;\n"; |
| else |
| { |
| if ( !superType.isEmpty() ) |
| { |
| o << " ret = bonobobridge::cpp_convert_u2b(("; |
| dumpCorbaType(o, superType, sal_False, sal_False); |
| o << "&) _u, (const "; |
| dumpUnoType(o, superType, sal_False, sal_False); |
| o << "&) _b, bridge);\n"; |
| } |
| |
| for (i=0; i < fieldCount; i++) |
| { |
| fieldName = m_reader.getFieldName(i); |
| fieldType = m_reader.getFieldType(i); |
| |
| cIndex = fieldName.indexOf("_reserved_identifier_"); |
| |
| if (cIndex == 0) |
| corbaFieldName = fieldName.copy(OString("_reserved_identifier_").getLength()); |
| else |
| corbaFieldName = fieldName; |
| |
| if (isArray(fieldType)) |
| o << " // fix me: no conversion of array types!\n"; |
| else |
| o << " if (ret)\n" |
| << " ret = bonobobridge::cpp_convert_u2b(" |
| << "_b." << corbaFieldName.getStr() |
| << ", _u." << fieldName.getStr() |
| << ", bridge);\n"; |
| } |
| } |
| |
| o << " return ret;\n" |
| << "}\n\n"; |
| |
| o << "inline sal_Bool bonobobridge::cpp_convert_b2u("; |
| dumpUnoType(o, m_typeName, sal_False, sal_True); |
| o << " u , "; |
| dumpCorbaType(o, m_typeName, sal_True, sal_True); |
| o << " b, const ::vos::ORef< ::bonobobridge::Bridge >& bridge) {\n" |
| << " return convert_b2u_" << m_typeName.replace('/', '_') |
| << "(&u, &b, ::getCppuType(&u), bridge);\n" |
| << "};\n\n"; |
| |
| o << "inline sal_Bool bonobobridge::cpp_convert_u2b("; |
| dumpCorbaType(o, m_typeName, sal_False, sal_True); |
| o << " b, "; |
| dumpUnoType(o, m_typeName, sal_True, sal_True); |
| o << " u, const ::vos::ORef< ::bonobobridge::Bridge >& bridge) {\n" |
| << " return convert_u2b_" << m_typeName.replace('/', '_') |
| << "(&b, &u, ::getCppuType(&u), bridge);\n" |
| << "};\n\n"; |
| } |
| |
| sal_Bool StructureType::dumpSuperMember(FileStream& o, const OString& superType, sal_Bool bWithType) |
| { |
| sal_Bool hasMember = sal_False; |
| |
| if ( !superType.isEmpty() ) |
| { |
| TypeReader aSuperReader(m_typeMgr.getTypeReader(superType)); |
| |
| if (aSuperReader.isValid()) |
| { |
| hasMember = dumpSuperMember(o, aSuperReader.getSuperTypeName(), bWithType); |
| |
| sal_uInt32 fieldCount = aSuperReader.getFieldCount(); |
| RTFieldAccess access = RT_ACCESS_INVALID; |
| OString fieldName; |
| OString fieldType; |
| for (sal_uInt16 i=0; i < fieldCount; i++) |
| { |
| access = aSuperReader.getFieldAccess(i); |
| |
| if (access == RT_ACCESS_CONST || access == RT_ACCESS_INVALID) |
| continue; |
| |
| fieldName = aSuperReader.getFieldName(i); |
| fieldType = aSuperReader.getFieldType(i); |
| |
| if (hasMember) |
| { |
| o << ", "; |
| } else |
| { |
| hasMember = (fieldCount > 0); |
| } |
| |
| if (bWithType) |
| { |
| dumpUnoType(o, fieldType, sal_True, sal_True); |
| o << " "; |
| } |
| o << "__" << fieldName; |
| } |
| } |
| } |
| |
| return hasMember; |
| } |
| |
| //************************************************************************* |
| // ExceptionType |
| //************************************************************************* |
| ExceptionType::ExceptionType(TypeReader& typeReader, |
| const OString& typeName, |
| const TypeManager& typeMgr, |
| const TypeDependency& typeDependencies, |
| TypeSet* generatedConversions) |
| : CorbaType(typeReader, typeName, typeMgr, typeDependencies, generatedConversions) |
| { |
| } |
| |
| ExceptionType::~ExceptionType() |
| { |
| |
| } |
| |
| void ExceptionType::dumpFunctions(FileStream& o) |
| { |
| if (m_typeName.equals("com/sun/star/uno/Exception")) |
| return; |
| |
| if (m_typeName.equals("com/sun/star/uno/RuntimeException")) |
| return; |
| |
| m_generatedConversions->insert(m_typeName); |
| |
| OString superType(m_reader.getSuperTypeName()); |
| |
| o << "static sal_Bool convert_b2u_" << m_typeName.replace('/', '_') |
| << "(void* pOut, const void* pIn, const ::com::sun::star::uno::Type& type, const ::vos::ORef< ::bonobobridge::Bridge >& bridge) {\n" |
| << " sal_Bool ret = sal_True;\n"; |
| dumpUnoType(o, m_typeName, sal_False, sal_False); |
| o << "& _u = *("; |
| dumpUnoType(o, m_typeName, sal_False, sal_False); |
| o << "*) pOut;\n const "; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "& _b = *(const "; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "*) pIn;\n\n"; |
| |
| sal_uInt32 fieldCount = m_reader.getFieldCount(); |
| OString fieldName; |
| OString fieldType; |
| sal_uInt16 i=0; |
| sal_Int32 cIndex; |
| OString corbaFieldName; |
| |
| if ( !superType.isEmpty() ) |
| { |
| o << " ret = bonobobridge::cpp_convert_b2u(("; |
| dumpUnoType(o, superType, sal_False, sal_False); |
| o << "&) _u, (const "; |
| dumpCorbaType(o, superType, sal_False, sal_False); |
| o << "&) _b, bridge);\n"; |
| } |
| |
| for (i=0; i < fieldCount; i++) |
| { |
| fieldName = m_reader.getFieldName(i); |
| fieldType = m_reader.getFieldType(i); |
| cIndex = fieldName.indexOf("_reserved_identifier_"); |
| |
| if (cIndex == 0) |
| corbaFieldName = fieldName.copy(OString("_reserved_identifier_").getLength()); |
| else |
| corbaFieldName = fieldName; |
| |
| if (isArray(fieldType)) |
| o << " // fix me: no conversion of array types!\n"; |
| else |
| o << " if (ret)\n" |
| << " ret = bonobobridge::cpp_convert_b2u(" |
| << "_u." << fieldName.getStr() |
| << ", _b." << corbaFieldName.getStr() |
| << ", bridge);\n"; |
| } |
| o << " return ret;\n" |
| << "}\n\n"; |
| |
| |
| o << "static sal_Bool convert_u2b_" << m_typeName.replace('/', '_') |
| << "(void* pOut, const void* pIn, const ::com::sun::star::uno::Type& type, const ::vos::ORef< ::bonobobridge::Bridge >& bridge) {\n" |
| << " sal_Bool ret = sal_True;\n const "; |
| dumpUnoType(o, m_typeName, sal_False, sal_False); |
| o << "& _u = *(const "; |
| dumpUnoType(o, m_typeName, sal_False, sal_False); |
| o << "*) pIn;\n "; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "& _b = *("; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "*) pOut;\n\n"; |
| |
| if ( !superType.isEmpty() ) |
| { |
| o << " ret = bonobobridge::cpp_convert_u2b(("; |
| dumpCorbaType(o, superType, sal_False, sal_False); |
| o << "&) _u, (const "; |
| dumpUnoType(o, superType, sal_False, sal_False); |
| o << "&) _b, bridge);\n"; |
| } |
| |
| for (i=0; i < fieldCount; i++) |
| { |
| fieldName = m_reader.getFieldName(i); |
| fieldType = m_reader.getFieldType(i); |
| |
| cIndex = fieldName.indexOf("_reserved_identifier_"); |
| |
| if (cIndex == 0) |
| corbaFieldName = fieldName.copy(OString("_reserved_identifier_").getLength()); |
| else |
| corbaFieldName = fieldName; |
| |
| if (isArray(fieldType)) |
| o << " // fix me: no conversion of array types!\n"; |
| else |
| o << " if (ret)\n" |
| << " ret = bonobobridge::cpp_convert_u2b(" |
| << "_b." << corbaFieldName.getStr() |
| << ", _u." << fieldName.getStr() |
| << ", bridge);\n"; |
| } |
| |
| o << " return ret;\n" |
| << "}\n\n"; |
| |
| o << "inline sal_Bool bonobobridge::cpp_convert_b2u("; |
| dumpUnoType(o, m_typeName, sal_False, sal_True); |
| o << " u , "; |
| dumpCorbaType(o, m_typeName, sal_True, sal_True); |
| o << " b, const ::vos::ORef< ::bonobobridge::Bridge >& bridge) {\n" |
| << " return convert_b2u_" << m_typeName.replace('/', '_') |
| << "(&u, &b, ::getCppuType(&u), bridge);\n" |
| << "};\n\n"; |
| |
| o << "inline sal_Bool bonobobridge::cpp_convert_u2b("; |
| dumpCorbaType(o, m_typeName, sal_False, sal_True); |
| o << " b, "; |
| dumpUnoType(o, m_typeName, sal_True, sal_True); |
| o << " u, const ::vos::ORef< ::bonobobridge::Bridge >& bridge) {\n" |
| << " return convert_u2b_" << m_typeName.replace('/', '_') |
| << "(&b, &u, ::getCppuType(&u), bridge);\n" |
| << "};\n\n"; |
| } |
| |
| |
| |
| sal_Bool ExceptionType::dumpSuperMember(FileStream& o, const OString& superType, sal_Bool bWithType) |
| { |
| sal_Bool hasMember = sal_False; |
| |
| if ( !superType.isEmpty() ) |
| { |
| TypeReader aSuperReader(m_typeMgr.getTypeReader(superType)); |
| |
| if (aSuperReader.isValid()) |
| { |
| hasMember = dumpSuperMember(o, aSuperReader.getSuperTypeName(), bWithType); |
| |
| sal_uInt32 fieldCount = aSuperReader.getFieldCount(); |
| RTFieldAccess access = RT_ACCESS_INVALID; |
| OString fieldName; |
| OString fieldType; |
| for (sal_uInt16 i=0; i < fieldCount; i++) |
| { |
| access = aSuperReader.getFieldAccess(i); |
| |
| if (access == RT_ACCESS_CONST || access == RT_ACCESS_INVALID) |
| continue; |
| |
| fieldName = aSuperReader.getFieldName(i); |
| fieldType = aSuperReader.getFieldType(i); |
| |
| if (hasMember) |
| { |
| o << ", "; |
| } else |
| { |
| hasMember = (fieldCount > 0); |
| } |
| |
| if (bWithType) |
| { |
| dumpUnoType(o, fieldType, sal_True, sal_True); |
| o << " "; |
| } |
| o << "__" << fieldName; |
| } |
| } |
| } |
| |
| return hasMember; |
| } |
| |
| //************************************************************************* |
| // EnumType |
| //************************************************************************* |
| EnumType::EnumType(TypeReader& typeReader, |
| const OString& typeName, |
| const TypeManager& typeMgr, |
| const TypeDependency& typeDependencies, |
| TypeSet* generatedConversions) |
| : CorbaType(typeReader, typeName, typeMgr, typeDependencies, generatedConversions) |
| { |
| } |
| |
| EnumType::~EnumType() |
| { |
| |
| } |
| |
| void EnumType::dumpFunctions(FileStream& o) |
| { |
| if (m_typeName.equals("com/sun/star/uno/TypeClass")) |
| return; |
| |
| m_generatedConversions->insert(m_typeName); |
| |
| o << "static sal_Bool convert_b2u_" << m_typeName.replace('/', '_') |
| << "(void* pOut, const void* pIn, const ::com::sun::star::uno::Type& type, const ::vos::ORef< ::bonobobridge::Bridge >& bridge) {\n" |
| << " *("; |
| dumpUnoType(o, m_typeName, sal_False, sal_False); |
| o << "*) pOut = ("; |
| dumpUnoType(o, m_typeName, sal_False, sal_False); |
| o << ") *(const "; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "*) pIn;\n\n" |
| << " return sal_True;\n" |
| << "}\n\n"; |
| |
| o << "static sal_Bool convert_u2b_" << m_typeName.replace('/', '_') |
| << "(void* pOut, const void* pIn, const ::com::sun::star::uno::Type& type, const ::vos::ORef< ::bonobobridge::Bridge >& bridge) {\n" |
| << " *("; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << "*) pOut = ("; |
| dumpCorbaType(o, m_typeName, sal_False, sal_False); |
| o << ") *(const "; |
| dumpUnoType(o, m_typeName, sal_False, sal_False); |
| o << "*) pIn;\n\n" |
| << " return sal_True;\n" |
| << "}\n\n"; |
| |
| o << "inline sal_Bool bonobobridge::cpp_convert_b2u("; |
| dumpUnoType(o, m_typeName, sal_False, sal_True); |
| o << " u , "; |
| dumpCorbaType(o, m_typeName, sal_True, sal_True); |
| o << " b, const ::vos::ORef< ::bonobobridge::Bridge >& bridge) {\n" |
| << " return convert_b2u_" << m_typeName.replace('/', '_') |
| << "(&u, &b, ::getCppuType(&u), bridge);\n" |
| << "};\n\n"; |
| |
| o << "inline sal_Bool bonobobridge::cpp_convert_u2b("; |
| dumpCorbaType(o, m_typeName, sal_False, sal_True); |
| o << " b, "; |
| dumpUnoType(o, m_typeName, sal_True, sal_True); |
| o << " u, const ::vos::ORef< ::bonobobridge::Bridge >& bridge) {\n" |
| << " return convert_u2b_" << m_typeName.replace('/', '_') |
| << "(&b, &u, ::getCppuType(&u), bridge);\n" |
| << "};\n\n"; |
| |
| return; |
| } |
| |
| |
| //************************************************************************* |
| // TypeDefType |
| //************************************************************************* |
| TypeDefType::TypeDefType(TypeReader& typeReader, |
| const OString& typeName, |
| const TypeManager& typeMgr, |
| const TypeDependency& typeDependencies, |
| TypeSet* generatedConversions) |
| : CorbaType(typeReader, typeName, typeMgr, typeDependencies, generatedConversions) |
| { |
| } |
| |
| TypeDefType::~TypeDefType() |
| { |
| |
| } |
| |
| void TypeDefType::dumpFunctions(FileStream& o) |
| { |
| } |
| |
| |
| |
| //************************************************************************* |
| // produceType |
| //************************************************************************* |
| sal_Bool produceType(const OString& typeName, |
| TypeManager& typeMgr, |
| TypeDependency& typeDependencies, |
| CorbaOptions* pOptions, |
| FileStream& o, TypeSet* allreadyDumped, |
| TypeSet* generatedConversions) |
| throw( CannotDumpException ) |
| { |
| sal_Bool bNewTypeSet = (allreadyDumped == NULL); |
| sal_Bool ret = sal_True; |
| |
| if (bNewTypeSet) |
| allreadyDumped = new TypeSet(); |
| |
| |
| if (!typeDependencies.isGenerated(typeName)) |
| { |
| TypeReader reader(typeMgr.getTypeReader(typeName)); |
| |
| if (!reader.isValid() && !typeName.equals("/")) |
| ret = sal_False; |
| |
| if( ret && !checkTypeDependencies(typeMgr, typeDependencies, typeName)) |
| ret = sal_False; |
| |
| if (ret) |
| { |
| RTTypeClass typeClass = reader.getTypeClass(); |
| |
| switch (typeClass) |
| { |
| case RT_TYPE_INTERFACE: |
| { |
| InterfaceType iType(reader, typeName, typeMgr, typeDependencies, generatedConversions); |
| ret = iType.dump(pOptions, o, allreadyDumped); |
| if (ret) typeDependencies.setGenerated(typeName); |
| ret = iType.dumpDependedTypes(pOptions, o, allreadyDumped); |
| } |
| break; |
| case RT_TYPE_MODULE: |
| { |
| ModuleType mType(reader, typeName, typeMgr, typeDependencies, generatedConversions); |
| if (mType.hasConstants()) |
| { |
| ret = mType.dump(pOptions, o, allreadyDumped); |
| if (ret) typeDependencies.setGenerated(typeName); |
| } else |
| { |
| typeDependencies.setGenerated(typeName); |
| ret = sal_True; |
| } |
| } |
| break; |
| case RT_TYPE_STRUCT: |
| { |
| StructureType sType(reader, typeName, typeMgr, typeDependencies, generatedConversions); |
| ret = sType.dump(pOptions, o, allreadyDumped); |
| if (ret) typeDependencies.setGenerated(typeName); |
| ret = sType.dumpDependedTypes(pOptions, o, allreadyDumped); |
| } |
| break; |
| case RT_TYPE_ENUM: |
| { |
| EnumType enType(reader, typeName, typeMgr, typeDependencies, generatedConversions); |
| ret = enType.dump(pOptions, o, allreadyDumped); |
| if (ret) typeDependencies.setGenerated(typeName); |
| ret = enType.dumpDependedTypes(pOptions, o, allreadyDumped); |
| } |
| break; |
| case RT_TYPE_EXCEPTION: |
| { |
| ExceptionType eType(reader, typeName, typeMgr, typeDependencies, generatedConversions); |
| ret = eType.dump(pOptions, o, allreadyDumped); |
| if (ret) typeDependencies.setGenerated(typeName); |
| ret = eType.dumpDependedTypes(pOptions, o, allreadyDumped); |
| } |
| break; |
| case RT_TYPE_TYPEDEF: |
| { |
| TypeDefType tdType(reader, typeName, typeMgr, typeDependencies, generatedConversions); |
| ret = tdType.dump(pOptions, o, allreadyDumped); |
| if (ret) typeDependencies.setGenerated(typeName); |
| ret = tdType.dumpDependedTypes(pOptions, o, allreadyDumped); |
| } |
| break; |
| case RT_TYPE_CONSTANTS: |
| { |
| ConstantsType cType(reader, typeName, typeMgr, typeDependencies, generatedConversions); |
| if (cType.hasConstants()) |
| { |
| ret = cType.dump(pOptions, o, allreadyDumped); |
| if (ret) typeDependencies.setGenerated(typeName); |
| } else |
| { |
| typeDependencies.setGenerated(typeName); |
| ret = sal_True; |
| } |
| } |
| break; |
| case RT_TYPE_SERVICE: |
| case RT_TYPE_OBJECT: |
| ret = sal_True; |
| break; |
| } |
| } |
| } |
| |
| if (bNewTypeSet) |
| delete allreadyDumped; |
| |
| return ret; |
| } |
| |
| //************************************************************************* |
| // scopedName |
| //************************************************************************* |
| OString scopedName(const OString& scope, const OString& type, |
| sal_Bool bNoNameSpace) |
| { |
| sal_Int32 nPos = type.lastIndexOf( '/' ); |
| if (nPos == -1) |
| return type; |
| |
| if (bNoNameSpace) |
| return type.copy(nPos+1); |
| |
| OStringBuffer tmpBuf(type.getLength()*2); |
| nPos = 0; |
| do |
| { |
| tmpBuf.append("::"); |
| tmpBuf.append(type.getToken(0, '/', nPos)); |
| } while( nPos != -1 ); |
| |
| return tmpBuf.makeStringAndClear(); |
| } |
| |
| //************************************************************************* |
| // shortScopedName |
| //************************************************************************* |
| OString shortScopedName(const OString& scope, const OString& type, |
| sal_Bool bNoNameSpace) |
| { |
| sal_Int32 nPos = type.lastIndexOf( '/' ); |
| if( nPos == -1 ) |
| return OString(); |
| |
| if (bNoNameSpace) |
| return OString(); |
| |
| // scoped name only if the namespace is not equal |
| if (scope.lastIndexOf('/') > 0) |
| { |
| OString tmpScp(scope.copy(0, scope.lastIndexOf('/'))); |
| OString tmpScp2(type.copy(0, nPos)); |
| |
| if (tmpScp == tmpScp2) |
| return OString(); |
| } |
| |
| OString aScope( type.copy( 0, nPos ) ); |
| OStringBuffer tmpBuf(aScope.getLength()*2); |
| |
| nPos = 0; |
| do |
| { |
| tmpBuf.append("::"); |
| tmpBuf.append(aScope.getToken(0, '/', nPos)); |
| } while( nPos != -1 ); |
| |
| return tmpBuf.makeStringAndClear(); |
| } |
| |
| |