diff options
Diffstat (limited to 'unodevtools/source/skeletonmaker/cpptypemaker.cxx')
| -rw-r--r-- | unodevtools/source/skeletonmaker/cpptypemaker.cxx | 973 |
1 files changed, 973 insertions, 0 deletions
diff --git a/unodevtools/source/skeletonmaker/cpptypemaker.cxx b/unodevtools/source/skeletonmaker/cpptypemaker.cxx new file mode 100644 index 000000000000..ce9f4b8d95a6 --- /dev/null +++ b/unodevtools/source/skeletonmaker/cpptypemaker.cxx @@ -0,0 +1,973 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include "codemaker/commoncpp.hxx" + +#include "skeletoncommon.hxx" +#include "skeletoncpp.hxx" + +using namespace ::rtl; +using namespace ::codemaker::cpp; + +namespace skeletonmaker { namespace cpp { + +void printType(std::ostream & o, + ProgramOptions const & options, TypeManager const & manager, + codemaker::UnoType::Sort sort, RTTypeClass typeClass, + OString const & name, sal_Int32 rank, + std::vector< OString > const & arguments, short referenceType, + bool defaultvalue) +{ + if (defaultvalue && rank == 0 && sort <= codemaker::UnoType::SORT_CHAR) { + switch (sort) + { + case codemaker::UnoType::SORT_BOOLEAN: + o << "sal_False"; + return; + case codemaker::UnoType::SORT_CHAR: + case codemaker::UnoType::SORT_BYTE: + case codemaker::UnoType::SORT_SHORT: + case codemaker::UnoType::SORT_UNSIGNED_SHORT: + case codemaker::UnoType::SORT_LONG: + case codemaker::UnoType::SORT_UNSIGNED_LONG: + case codemaker::UnoType::SORT_HYPER: + case codemaker::UnoType::SORT_UNSIGNED_HYPER: + case codemaker::UnoType::SORT_FLOAT: + case codemaker::UnoType::SORT_DOUBLE: + o << "0"; + return; + case codemaker::UnoType::SORT_VOID: + case codemaker::UnoType::SORT_STRING: + case codemaker::UnoType::SORT_TYPE: + case codemaker::UnoType::SORT_ANY: + case codemaker::UnoType::SORT_COMPLEX: + break; + } + } + + if (defaultvalue && referenceType == 16) { + if (typeClass == RT_TYPE_ENUM) { + typereg::Reader reader(manager.getTypeReader(name)); + o << name.copy(name.lastIndexOf('/')) + << "_" + << codemaker::convertString(reader.getFieldName(0)); + } + return; + } + bool bReference = false; + if (((sort > codemaker::UnoType::SORT_CHAR || + rank > 0) && referenceType != 8 && + !(typeClass == RT_TYPE_ENUM && referenceType == 4 && rank == 0)) || + (sort <= codemaker::UnoType::SORT_CHAR && referenceType == 2)) + { + bReference = true; + } + + if (bReference && referenceType == 4) + o << "const "; + + for (sal_Int32 i = 0; i < rank; ++i) { + o << ((options.shortnames) ? "css::uno::Sequence< " : + "::com::sun::star::uno::Sequence< "); + } + if (typeClass == RT_TYPE_INTERFACE && referenceType > 0) { + o << ((options.shortnames) ? "css::uno::Reference< " : + "::com::sun::star::uno::Reference< "); + } + + o << scopedCppName(codemaker::cpp::translateUnoToCppType( + sort, typeClass, name, false), + false, options.shortnames && referenceType > 0); + + if (typeClass == RT_TYPE_INTERFACE && referenceType > 0) + o << " >"; + + if (!arguments.empty()) { + o << "< "; + for (std::vector< OString >::const_iterator i(arguments.begin()); + i != arguments.end(); ++i) + { + if (i != arguments.begin()) + o << ", "; + + printType(o, options, manager, *i, 1, false); + } + o << " >"; + } + + for (sal_Int32 i = 0; i < rank; ++i) + o << " >"; + + if (bReference && referenceType > 1) + o << " &"; + + if (referenceType == 8 && (sort > codemaker::UnoType::SORT_CHAR || rank > 0)) + o << "()"; +} + +void printType(std::ostream & o, + ProgramOptions const & options, TypeManager const & manager, + OString const & type, short referenceType, bool defaultvalue) +{ + RTTypeClass typeClass; + OString name; + sal_Int32 rank; + std::vector< OString > arguments; + codemaker::UnoType::Sort sort = codemaker::decomposeAndResolve( + manager, type, true, true, true, &typeClass, &name, &rank, &arguments); + printType(o, + options, manager, sort, typeClass, name, rank, arguments, + referenceType, defaultvalue); +} + +bool printConstructorParameters(std::ostream & o, + ProgramOptions const & options, TypeManager const & manager, + typereg::Reader const & reader, typereg::Reader const & outerReader, + std::vector< OString > const & arguments) +{ + bool previous = false; + if (reader.getSuperTypeCount() != 0) { + OString super( + codemaker::convertString(reader.getSuperTypeName(0))); + typereg::Reader superReader(manager.getTypeReader(super)); + if (!superReader.isValid()) + throw CannotDumpException("Bad type library entity " + super); + + previous = printConstructorParameters(o, + options, manager, superReader, outerReader, arguments); + } + for (sal_uInt16 i = 0; i < reader.getFieldCount(); ++i) { + if (previous) + o << ", "; + else + previous = true; + + if ((reader.getFieldFlags(i) & RT_ACCESS_PARAMETERIZED_TYPE) == 0) { + printType(o, options, manager, + codemaker::convertString(reader.getFieldTypeName(i)), 4); + } else if (arguments.empty()) { + // ToDo ! + // o << "com::sun::star::uno::Any"; + } else { + sal_uInt16 tparam = 0; + while (outerReader.getReferenceTypeName(tparam) + != reader.getFieldTypeName(i)) + { + ++tparam; + OSL_ASSERT(tparam < outerReader.getReferenceCount()); + } + // assume std::vector< OString >::size_type is at least as + // large as sal_uInt16: + printType(o, options, manager, arguments[tparam], 4); + } + o << ' ' + << (codemaker::cpp::translateUnoToCppIdentifier( + codemaker::convertString(reader.getFieldName(i)), + "param"). + getStr()); + } + return previous; +} + +void printConstructor(std::ostream & o, + ProgramOptions const & options, TypeManager const & manager, + typereg::Reader const & reader, + std::vector< OString > const & arguments) +{ + OString type(codemaker::convertString(reader.getTypeName())); + o << "public "; + o << type.copy(type.lastIndexOf('/') + 1) << '('; + printConstructorParameters(o, options, manager, reader, reader, + arguments); + o << ");\n"; +} + +void printMethodParameters(std::ostream & o, + ProgramOptions const & options, TypeManager const & manager, + typereg::Reader const & reader, sal_uInt16 method, bool previous, + bool withtype) +{ + short referenceType = 4; + for (sal_uInt16 i = 0; i < reader.getMethodParameterCount(method); ++i) { + if (previous) + o << ", "; + + previous = true; + + if (reader.getMethodParameterFlags(method, i) == RT_PARAM_OUT + || reader.getMethodParameterFlags(method, i) == RT_PARAM_INOUT) + { + referenceType = 2; + } else { + referenceType = 4; + } + + if (withtype) { + printType(o, options, manager, + codemaker::convertString( + reader.getMethodParameterTypeName(method, i)), + referenceType); + o << ' '; + } + + o << (codemaker::cpp::translateUnoToCppIdentifier( + codemaker::convertString( + reader.getMethodParameterName(method, i)), + "param"). + getStr()); + } +} + +void printExceptionSpecification(std::ostream & o, + ProgramOptions const & options, TypeManager const & manager, + typereg::Reader const & reader, sal_uInt16 method) +{ + o << ((options.shortnames) ? " throw (css::uno::RuntimeException" : + " throw (::com::sun::star::uno::RuntimeException"); + if (reader.getMethodExceptionCount(method) > 0) { + for (sal_uInt16 i = 0; i < reader.getMethodExceptionCount(method); ++i) { + o << ", "; + printType(o, options, manager, + codemaker::convertString( + reader.getMethodExceptionTypeName(method, i)), 1); + } + } + o << ")"; +} + +void printSetPropertyMixinBody(std::ostream & o, + typereg::Reader const & reader, + sal_uInt16 field, + sal_uInt16 method) +{ + RTFieldAccess propFlags = checkAdditionalPropertyFlags(reader, field, method); + OString fieldname = codemaker::convertString(reader.getFieldName(field)); + bool bound = (reader.getFieldFlags(field) & RT_ACCESS_BOUND ? true : false); + + o << "\n{\n"; + + if (bound) + o << " BoundListeners l;\n"; + + if (propFlags & RT_ACCESS_CONSTRAINED) { + OString fieldtype = codemaker::convertString( + reader.getFieldTypeName(field)); + + sal_Int32 index = fieldtype.lastIndexOf('<'); + sal_Int32 nPos=0; + bool single = true; + bool optional = false; + OStringBuffer buffer1(64); + OStringBuffer buffer2(64); + do + { + OString s(fieldtype.getToken(0, '<', nPos)); + OString t = s.copy(s.lastIndexOf('/')+1); + + if (t.equals("Optional")) { + optional=true; + if (single) { + single=false; + buffer1.append("the_value.IsPresent"); + buffer2.append("the_value.Value"); + } else { + buffer1.insert(0, t); + buffer1.append(".IsPresent"); + buffer2.insert(0, t); + buffer2.append(".Value"); + } + } else { + if (single) { + single=false; + if (!optional) + buffer1.append("the_value.Value"); + + buffer2.append("the_value.Value"); + } else { + if (!optional) { + buffer1.insert(0, t); + buffer1.append(".Value"); + } + buffer2.insert(0, t); + buffer2.append(".Value"); + } + } + } while( nPos <= index ); + + o << " css::uno::Any v;\n"; + if (optional) { + o << " if(" << buffer1.makeStringAndClear() << ")\n {\n" + << " v <<= " << buffer2.makeStringAndClear() << ";\n }\n"; + } else { + o << " v <<= " << buffer2.makeStringAndClear() << ";\n\n"; + } + + o << " prepareSet(\n rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(\"" + << fieldname << "\")),\n css::uno::Any(), v, "; + } else { + o << " prepareSet(\n rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(\"" + << fieldname << "\")),\n css::uno::Any(), css::uno::Any(), "; + } + + if (bound) + o << "&l);\n"; + else + o << "0);\n"; + + o << " {\n osl::MutexGuard g(m_aMutex);\n m_" + << fieldname << " = the_value;\n }\n"; + + if (bound) + o << " l.notify();\n"; + + o << "}\n\n"; +} + +void generateXPropertySetBodies(std::ostream& o, + const OString & classname, + const OString & interfaceName); +void generateXFastPropertySetBodies(std::ostream& o, + const OString & classname, + const OString & interfaceName); +void generateXPropertyAccessBodies(std::ostream& o, + const OString & classname, + const OString & interfaceName); + +void generateXAddInBodies(std::ostream& o, const OString & classname); + +void generateXLocalizable(std::ostream& o, const OString & classname); + +void generateXCompatibilityNamesBodies(std::ostream& o, const OString & classname); + +void generateXInitialization(std::ostream& o, const OString & classname); + +void generateXDispatch(std::ostream& o, + const OString & classname, + const ProtocolCmdMap & protocolCmdMap); + +void generateXDispatchProvider(std::ostream& o, + const OString & classname, + const ProtocolCmdMap & protocolCmdMap); + + +void printMethods(std::ostream & o, + ProgramOptions const & options, TypeManager const & manager, + typereg::Reader const & reader, codemaker::GeneratedTypeSet & generated, + OString const & delegate, OString const & classname, + OString const & indentation, bool defaultvalue, + OString const & propertyhelper) +{ + OString type(codemaker::convertString(reader.getTypeName())); + if (generated.contains(type) || type.equals("com/sun/star/uno/XInterface") || + (defaultvalue && + ( type.equals("com/sun/star/lang/XComponent") || + type.equals("com/sun/star/lang/XTypeProvider") || + type.equals("com/sun/star/uno/XWeak")) ) ) + { + return; + } + + static OString sd(RTL_CONSTASCII_STRINGPARAM("_")); + bool body = ((delegate.getLength() > 0) ? true : false); + bool defaultbody = ((delegate.equals(sd)) ? true : false); + + if (body && propertyhelper.getLength() > 1) { + if ( type.equals("com/sun/star/beans/XPropertySet")) { + generated.add(type); + generateXPropertySetBodies( + o, classname, scopedCppName(propertyhelper, false, true)); + return; + } else if ( type.equals("com/sun/star/beans/XFastPropertySet")) { + generated.add(type); + generateXFastPropertySetBodies( + o, classname, scopedCppName(propertyhelper, false, true)); + return; + } else if ( type.equals("com/sun/star/beans/XPropertyAccess")) { + generated.add(type); + generateXPropertyAccessBodies( + o, classname, scopedCppName(propertyhelper, false, true)); + return; + } + } + + if (body && options.componenttype == 2) { + if (type.equals("com/sun/star/lang/XServiceName")) { + o << "// ::com::sun::star::lang::XServiceName:\n" + "::rtl::OUString SAL_CALL " << classname << "getServiceName() " + "throw (css::uno::RuntimeException)\n{\n " + "return ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" + "sADDIN_SERVICENAME));\n}\n"; + generated.add(type); + return; + } else if (type.equals("com/sun/star/sheet/XAddIn")) { + generateXAddInBodies(o, classname); + generated.add(type); + + // special handling of XLocalizable -> parent of XAddIn + if (!generated.contains("com/sun/star/lang/XLocalizable")) { + generateXLocalizable(o, classname); + generated.add("com/sun/star/lang/XLocalizable"); + } + return; + } else if (type.equals("com/sun/star/lang/XLocalizable")) { + generateXLocalizable(o, classname); + generated.add(type); + return; + } else if (type.equals("com/sun/star/sheet/XCompatibilityNames")) { + generateXCompatibilityNamesBodies(o, classname); + generated.add(type); + return; + } + } + + if (body && options.componenttype == 3) { + if (type.equals("com/sun/star/lang/XInitialization")) { + generateXInitialization(o, classname); + generated.add(type); + return; + } else if (type.equals("com/sun/star/frame/XDispatch")) { + generateXDispatch(o, classname, options.protocolCmdMap); + generated.add(type); + return; + } else if (type.equals("com/sun/star/frame/XDispatchProvider")) { + generateXDispatchProvider(o, classname, options.protocolCmdMap); + generated.add(type); + return; + } + } + + generated.add(type); + if (options.all || defaultvalue) { + for (sal_uInt16 i = 0; i < reader.getSuperTypeCount(); ++i) { + typereg::Reader super( + manager.getTypeReader( + codemaker::convertString( + reader.getSuperTypeName(i)))); + if (!super.isValid()) { + throw CannotDumpException( + "Bad type library entity " + + codemaker::convertString( + reader.getSuperTypeName(i))); + } + + OString stype(codemaker::convertString(super.getTypeName())); + printMethods(o, options, manager, super, generated, delegate, + classname, indentation, defaultvalue, propertyhelper); + } + + if (reader.getFieldCount() > 0 || reader.getMethodCount() > 0) { + o << indentation << "// "; + printType(o, options, manager, type, 0); + o << ":\n"; + } + } + sal_uInt16 method = 0; + for (sal_uInt16 i = 0; i < reader.getFieldCount(); ++i) { + o << indentation; + if (!body) + o << "virtual "; + + printType(o, options, manager, + codemaker::convertString(reader.getFieldTypeName(i)), 1); + o << " SAL_CALL "; + if (classname.getLength() > 0) + o << classname; + + o << "get" + << codemaker::convertString(reader.getFieldName(i)).getStr() + << "()"; + if (method < reader.getMethodCount() + && reader.getMethodFlags(method) == RT_MODE_ATTRIBUTE_GET + && reader.getMethodName(method) == reader.getFieldName(i)) + { + printExceptionSpecification(o, options, manager, reader, method++); + } else { + o << ((options.shortnames) ? " throw (css::uno::RuntimeException)" : + " throw (::com::sun::star::uno::RuntimeException)"); + } + if (body) { + if (defaultbody) { + if (propertyhelper.getLength() > 0) { + o << "\n{\n osl::MutexGuard g(m_aMutex);\n return m_" + << codemaker::convertString(reader.getFieldName(i)).getStr() + << ";\n}\n\n"; + } else { + o << "\n{\n return "; + if (options.componenttype == 1) { + o << "m_" + << codemaker::convertString( + reader.getFieldName(i)).getStr(); + } else { + printType(o, options, manager, + codemaker::convertString( + reader.getFieldTypeName(i)), + 8, true); + } + o << ";\n}\n\n"; + } + } else { + o << "\n" << indentation << "{\n" << indentation << " return " + << delegate.getStr() << "get" + << codemaker::convertString(reader.getFieldName(i)).getStr() + << "();\n" << indentation << "}\n\n"; + } + } else { + o << ";\n"; + } + + if ((reader.getFieldFlags(i) & RT_ACCESS_READONLY) == 0) { + o << indentation; + if (!body) + o << "virtual "; + + o << "void SAL_CALL "; + if (classname.getLength() > 0) + o << classname; + + o << "set" + << (codemaker::convertString(reader.getFieldName(i)).getStr()) + << '('; + printType(o, options, manager, + codemaker::convertString(reader.getFieldTypeName(i)), 4); + o << " the_value)"; + if (method < reader.getMethodCount() + && reader.getMethodFlags(method) == RT_MODE_ATTRIBUTE_SET + && reader.getMethodName(method) == reader.getFieldName(i)) + { + printExceptionSpecification(o, options, manager, reader, method++); + } else { + o << ((options.shortnames) ? " throw (css::uno::RuntimeException)" : + " throw (::com::sun::star::uno::RuntimeException)"); + } + if (body) { + if (defaultbody) { + if (propertyhelper.getLength() > 0) { + printSetPropertyMixinBody(o, reader, i, method); + } else { + if (options.componenttype == 1) { + o << "\n{\n m_" + << codemaker::convertString( + reader.getFieldName(i)).getStr() + << " = the_value;\n}\n\n"; + } else { + o << "\n{\n\n}\n\n"; + } + } + } else { + o << "\n" << indentation << "{\n" << indentation << " " + << delegate.getStr() << "set" + << codemaker::convertString(reader.getFieldName(i)).getStr() + << "(the_value);\n" << indentation << "}\n\n"; + } + } else { + o << ";\n"; + } + } + } + for (; method < reader.getMethodCount(); ++method) { + o << indentation; + if (!body) + o << "virtual "; + + printType(o, options, manager, + codemaker::convertString( + reader.getMethodReturnTypeName(method)), 1); + o << " SAL_CALL "; + if (classname.getLength() > 0) + o << classname; + + const OString methodName(codemaker::convertString(reader.getMethodName(method))); + + o << methodName << '('; + printMethodParameters(o, options, manager, reader, method, false, true); + o << ')'; + printExceptionSpecification(o, options, manager, reader, method); + if (body) { + static OUString s(RTL_CONSTASCII_USTRINGPARAM("void")); + if (defaultbody) { + o << "\n{\n"; + if (!reader.getMethodReturnTypeName(method).equals(s)) { + o << " // TODO: Exchange the default return implementation for \"" + << methodName << "\" !!!\n"; + o << " // Exchange the default return implementation.\n" + " // NOTE: Default initialized polymorphic structs " + "can cause problems because of\n // missing default " + "initialization of primitive types of some C++ compilers or" + "\n // different Any initialization in Java and C++ " + "polymorphic structs.\n return "; + printType(o, options, manager, + codemaker::convertString( + reader.getMethodReturnTypeName(method)), 8, true); + o << ";"; + } else { + o << " // TODO: Insert your implementation for \"" + << methodName << "\" here."; + } + o << "\n}\n\n"; + } else { + o << "\n" << indentation << "{\n" << indentation << " "; + if (!reader.getMethodReturnTypeName(method).equals(s)) + o << "return "; + + o << delegate.getStr() + << (codemaker::convertString( + reader.getMethodName(method)).getStr()) + << '('; + printMethodParameters(o, options, manager, reader, method, + false, false); + o << ");\n" << indentation << "}\n\n"; + } + } else { + o << ";\n"; + } + } + + if (method > 0 && !body) + o << "\n"; +} + +void printConstructionMethods(std::ostream & o, + ProgramOptions const & options, TypeManager const & manager, + typereg::Reader const & reader) +{ + for (sal_uInt16 i = 0; i < reader.getMethodCount(); ++i) { + o << "static "; + printType(o, + options, manager, + codemaker::convertString(reader.getSuperTypeName(0)), 1); + o << ' '; + if (reader.getMethodName(i).getLength() == 0) { + o << "create"; + } else { + o << (codemaker::cpp::translateUnoToCppIdentifier( + codemaker::convertString(reader.getMethodName(i)), + "method"). + getStr()); + } + o << ((options.shortnames) ? "(css::uno::Reference< css" : + "(::com::sun::star::uno::Reference< ::com::sun::star") + << "::uno::XComponentContext > const & the_context"; + printMethodParameters(o, options, manager, reader, i, + true, true); + o << ')'; + printExceptionSpecification(o, options, manager, reader, i); + o << ";\n"; + } +} + +void printServiceMembers(std::ostream & o, + ProgramOptions const & options, TypeManager const & manager, + typereg::Reader const & reader, OString const & type, + OString const & delegate) +{ + for (sal_uInt16 i = 0; i < reader.getReferenceCount(); ++i) { + OString referenceType( + codemaker::convertString( + reader.getReferenceTypeName(i)).replace('/', '.')); + + if ( reader.getReferenceSort(i) == RT_REF_SUPPORTS ) { + o << "\n// supported interface " << referenceType.getStr() << "\n"; + generateDocumentation(o, options, manager, referenceType, delegate); + } else if ( reader.getReferenceSort(i) == RT_REF_EXPORTS ) { + o << "\n// exported service " << referenceType.getStr() << "\n"; + generateDocumentation(o, options, manager, referenceType, delegate); + o << "\n// end of exported service " << referenceType.getStr() << "\n"; + } + } + + if (delegate.getLength() == 0) { + o << "\n// properties of service \""<< type.getStr() << "\"\n"; + for (sal_uInt16 i = 0; i < reader.getFieldCount(); ++i) { + OString fieldName( + codemaker::convertString(reader.getFieldName(i))); + OString fieldType( + codemaker::convertString(reader.getFieldTypeName(i))); + + o << "// private "; + printType(o, options, manager, fieldType, 1); + o << " " + << codemaker::cpp::translateUnoToCppIdentifier( + fieldName, "property").getStr() + << ";\n"; + } + } +} + +void printMapsToCppType(std::ostream & o, + ProgramOptions const & options, TypeManager const & manager, + codemaker::UnoType::Sort sort, RTTypeClass typeClass, + OString const & name, sal_Int32 rank, + std::vector< OString > const & arguments, const char * cppTypeSort) +{ + o << "maps to C++ "; + if (cppTypeSort != 0) + o << cppTypeSort << ' '; + + o << "type \""; + if (rank == 0 && name == "com/sun/star/uno/XInterface") { + o << "Reference< com::sun::star::uno::XInterface >"; + } else { + printType(o, options, manager, sort, typeClass, name, rank, arguments, 0); + } + o << '"'; +} + +void generateDocumentation(std::ostream & o, + ProgramOptions const & options, TypeManager const & manager, + OString const & type, OString const & delegate) +{ + if (type.indexOf('/') >= 0) + throw CannotDumpException("Illegal type name " + type); + + OString binType(type.replace('.', '/')); + RTTypeClass typeClass; + OString name; + sal_Int32 rank; + std::vector< OString > arguments; + codemaker::UnoType::Sort sort = decomposeResolveAndCheck( + manager, binType, false, true, true, &typeClass, &name, &rank, + &arguments); + + bool comment=true; + if (delegate.getLength() > 0) { + if (typeClass != RT_TYPE_INTERFACE && + typeClass != RT_TYPE_SERVICE ) + { + return; + } + comment=false; + } + + if (comment) { + o << "\n// UNO"; + if (rank > 0) { + o << " sequence type"; + } else if (sort != codemaker::UnoType::SORT_COMPLEX) { + o << " simple type"; + } else { + typereg::Reader reader(manager.getTypeReader(name)); + if (!reader.isValid()) + throw CannotDumpException("Bad type library entity " + name); + + switch (typeClass) + { + case RT_TYPE_INTERFACE: + o << " interface type"; + break; + + case RT_TYPE_MODULE: + o << "IDL module"; + break; + + case RT_TYPE_STRUCT: + if (reader.getReferenceCount() == 0) + o << " simple struct type"; + else if (arguments.empty()) + o << " polymorphic struct type template"; + else + o << " instantiated polymorphic struct type"; + break; + + case RT_TYPE_ENUM: + o << " enum type"; + break; + + case RT_TYPE_EXCEPTION: + o << " exception type"; + break; + + case RT_TYPE_TYPEDEF: + o << "IDL typedef"; + break; + + case RT_TYPE_SERVICE: + if (reader.getSuperTypeCount() > 0) + o << " single-inheritance--based service"; + else + o << "IDL accumulation-based service"; + break; + + case RT_TYPE_SINGLETON: + if ((manager.getTypeReader( + codemaker::convertString( + reader.getSuperTypeName(0))).getTypeClass()) + == RT_TYPE_INTERFACE) + o << " inheritance-based singleton"; + else + o << "IDL service-based singleton"; + break; + + case RT_TYPE_CONSTANTS: + o << "IDL constant group"; + break; + + default: + OSL_ASSERT(false); + break; + } + } + o << " \"" << type.getStr() << "\" "; + } + sort = codemaker::decomposeAndResolve( + manager, binType, true, true, true, &typeClass, &name, &rank, + &arguments); + if (rank > 0) { + if (comment) { + printMapsToCppType(o, + options, manager, sort, typeClass, name, rank, arguments, "array"); + o << '\n'; + } + } else if (sort != codemaker::UnoType::SORT_COMPLEX) { + if (comment) { + printMapsToCppType(o, + options, manager, sort, typeClass, name, rank, arguments, 0); + o << '\n'; + } + } else { + typereg::Reader reader(manager.getTypeReader(name)); + if (!reader.isValid()) + throw CannotDumpException("Bad type library entity " + name); + + switch (typeClass) + { + case RT_TYPE_INTERFACE: + if (comment) + printMapsToCppType(o, + options, manager, sort, typeClass, name, rank, arguments, + "interface"); + if (name == "com/sun/star/uno/XInterface") { + if (comment) + o << '\n'; + } else { + if (comment) + o << "; " << (options.all ? "all" : "direct") << " methods:\n"; + + codemaker::GeneratedTypeSet generated; + printMethods(o, options, manager, reader, generated, + delegate, options.implname, ""); + } + break; + + case RT_TYPE_MODULE: + printMapsToCppType(o, + options, manager, sort, typeClass, name, rank, arguments, + "namespace"); + o << '\n'; + break; + + case RT_TYPE_STRUCT: + if (reader.getReferenceCount() == 0) { + printMapsToCppType(o, + options, manager, sort, typeClass, name, rank, arguments, + "class"); + } else if (arguments.empty()) { + printMapsToCppType(o, + options, manager, sort, typeClass, name, rank, arguments, + options.java5 ? "generic class" : "class"); + } else { + printMapsToCppType(o, + options, manager, sort, typeClass, name, rank, arguments, + options.java5 ? "generic class instantiation" : "class"); + } + o << "; full constructor:\n"; + printConstructor(o, options, manager, reader, arguments); + break; + + case RT_TYPE_ENUM: + printMapsToCppType(o, + options, manager, sort, typeClass, name, rank, arguments, + "enum"); + o << '\n'; + break; + + case RT_TYPE_CONSTANTS: + printMapsToCppType(o, + options, manager, sort, typeClass, name, rank, arguments, + "namespace"); + o << '\n'; + break; + + case RT_TYPE_EXCEPTION: + printMapsToCppType(o, + options, manager, sort, typeClass, name, rank, arguments, + "exception class"); + o << "; full constructor:\n"; + printConstructor(o, options, manager, reader, arguments); + break; + + case RT_TYPE_SERVICE: + if (reader.getSuperTypeCount() > 0) { + if (comment) { + printMapsToCppType(o, options, manager, sort, typeClass, + name, rank, arguments, "class"); + o << "; construction methods:\n"; + printConstructionMethods(o, options, manager, reader); + } + + OString super( + codemaker::convertString( + reader.getSuperTypeName(0)).replace('/', '.')); + generateDocumentation(o, options, manager, super, delegate); + } else { + if (comment) + o << ("does not map to C++\n" + "// the service members are generated instead\n"); + printServiceMembers(o, options, manager, reader, type, delegate); + } + break; + + case RT_TYPE_SINGLETON: + if (reader.getSuperTypeCount() > 0 && + ((manager.getTypeReader( + codemaker::convertString( + reader.getSuperTypeName(0))). + getTypeClass()) == RT_TYPE_INTERFACE) ) + { + printMapsToCppType(o, options, manager, sort, typeClass, + name, rank, arguments, + "class"); + o << "; get method:\nstatic "; + printType(o, options, manager, + codemaker::convertString(reader.getSuperTypeName(0)), 1); + o << " get(::com::sun::star::uno::Reference< ::com::sun::star::uno::XComponentContext > const & context);\n"; + } else { + o << "does not map to C++\n"; + } + break; + + default: + OSL_ASSERT(false); + break; + } + } +} + +} } + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |