xref: /trunk/main/unodevtools/source/skeletonmaker/javatypemaker.cxx (revision 7ceddb92)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



#include "codemaker/commonjava.hxx"

#include "skeletoncommon.hxx"
#include "skeletonjava.hxx"

using namespace ::rtl;

namespace skeletonmaker { namespace java {

void printType(std::ostream & o,
               ProgramOptions const & options, TypeManager const & manager,
               OString const & type, bool referenceType,
               bool defaultvalue);

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, bool referenceType,
               bool defaultvalue)
{
    if ( defaultvalue && rank == 0 && sort <= codemaker::UnoType::SORT_CHAR ) {
        switch (sort)
        {
        case codemaker::UnoType::SORT_BOOLEAN:
            o << "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 ) {
        if ( sort == codemaker::UnoType::SORT_COMPLEX &&
            typeClass == RT_TYPE_INTERFACE ) {
            o << "null";
            return;
        } else if ( sort == codemaker::UnoType::SORT_ANY && rank==0 ) {
            o << "com.sun.star.uno.Any.VOID";
            return;
        } else if ( sort == codemaker::UnoType::SORT_TYPE && rank==0 ) {
            o << "com.sun.star.uno.Type.VOID";
            return;
        } else
            if ( typeClass != RT_TYPE_ENUM || rank > 0 )
                o << "new ";
    }

    OString sType(codemaker::java::translateUnoToJavaType(
                      sort, typeClass, name, referenceType && rank==0).replace('/', '.'));
    if ( sType.indexOf("java.lang.") == 0 )
        sType = sType.copy(10);
    o << sType.getStr();
    if ( !arguments.empty() && options.java5 ) {
        o << '<';
        for ( std::vector< OString >::const_iterator i(arguments.begin());
              i != arguments.end(); ++i )
        {
            if ( i != arguments.begin() ) {
                o << ", ";
            }

            printType(o, options, manager, *i, true, false);
        }
        o << '>';
    }
    for ( sal_Int32 i = 0; i < rank; ++i ) {
        if ( defaultvalue )
            o << "[0]";
        else
            o << "[]";
    }

    if ( defaultvalue && sort > codemaker::UnoType::SORT_CHAR && rank == 0 ) {
        if ( typeClass == RT_TYPE_ENUM )
            o << ".getDefault()";
        else
            o << "()";
    }
}

void printType(std::ostream & o,
    ProgramOptions const & options, TypeManager const & manager,
    OString const & type, bool 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 << ", ";
        }
        previous = true;
        if ( (reader.getFieldFlags(i) & RT_ACCESS_PARAMETERIZED_TYPE) == 0  ) {
            printType(o,
                options, manager,
                codemaker::convertString(reader.getFieldTypeName(i)),
                false);
        } else if ( arguments.empty() ) {
            o << "java.lang.Object";
        } 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], true);
        }
        o
            << ' '
            << (codemaker::java::translateUnoToJavaIdentifier(
                    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 " << 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, bool /*shortname*/)
{
    for ( sal_uInt16 i = 0; i < reader.getMethodParameterCount(method); ++i ) {
        if ( previous  )
            o << ", ";
        else
            previous = true;

        if ( withtype ) {
            printType(o, options, manager,
                      codemaker::convertString(
                          reader.getMethodParameterTypeName(method, i)),
                      false);
            if ( reader.getMethodParameterFlags(method, i) == RT_PARAM_OUT
                 || reader.getMethodParameterFlags(method, i) == RT_PARAM_INOUT )
            {
                o << "[]";
            } else if ( (reader.getMethodParameterFlags(method, i) & RT_PARAM_REST )
                       != 0)
            {
                o << (options.java5 ? "..." : "[]");
            }
            o << ' ';
        }
        o << (codemaker::java::translateUnoToJavaIdentifier(
                  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)
{
    if ( reader.getMethodExceptionCount(method) > 0 ) {
        o << " throws ";
        for ( sal_uInt16 i = 0; i < reader.getMethodExceptionCount(method); ++i )
        {
            if ( i != 0 ) {
                o << ", ";
            }
            printType(o,
                options, manager,
                codemaker::convertString(
                    reader.getMethodExceptionTypeName(method, i)),
                false);
        }
    }
}


void printSetPropertyMixinBody(std::ostream & o,
                               typereg::Reader const & reader,
                               sal_uInt16 field,
                               sal_uInt16 method,
                               OString const & indentation)
{
    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" << indentation << "{\n";

    if ( bound ) {
        o << indentation << "    PropertySetMixin.BoundListeners l = "
            "new PropertySetMixin.BoundListeners();\n\n";
    }

    o << indentation << "    m_prophlp.prepareSet(\""
      << fieldname << "\", ";
    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));
			OStringBuffer buffer(16);
            buffer.append("((");
            buffer.append(s.copy(s.lastIndexOf('/')+1));
            buffer.append(')');
			OString t = buffer.makeStringAndClear();

            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 << "Any.VOID,\n" << indentation << "        ";
        if ( optional )
            o << "(";
        o << buffer1.makeStringAndClear();
		if ( optional )
			o << ") ? " << buffer2.makeStringAndClear() << " : Any.VOID,\n"
              << indentation << "        ";
        else
            o << ", ";
    }

    if ( bound )
        o << "l";
    else
        o << "null";
    o << ");\n";

    o << indentation << "    synchronized (this) {\n"
      << indentation << "        m_" << fieldname
      << " = the_value;\n" << indentation << "    }\n";

    if ( bound ) {
        o << indentation << "    l.notifyListeners();\n";
    }
    o  << indentation << "}\n\n";
}

void generateXPropertySetBodies(std::ostream& o);
void generateXFastPropertySetBodies(std::ostream& o);
void generateXPropertyAccessBodies(std::ostream& o);

void printMethods(std::ostream & o,
    ProgramOptions const & options, TypeManager const & manager,
    typereg::Reader const & reader,
    codemaker::GeneratedTypeSet & generated,
    OString const & delegate, OString const & indentation,
    bool defaultvalue, bool usepropertymixin)
{
    OString type(codemaker::convertString(reader.getTypeName()));
    if ( generated.contains(type) || type == "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;
    }

    if ( usepropertymixin ) {
        if ( type.equals("com/sun/star/beans/XPropertySet") ) {
            generated.add(type);
            generateXPropertySetBodies(o);
            return;
        } else if ( type.equals("com/sun/star/beans/XFastPropertySet") ) {
            generated.add(type);
            generateXFastPropertySetBodies(o);
            return;
        } else if ( type.equals("com/sun/star/beans/XPropertyAccess") ) {
            generated.add(type);
            generateXPropertyAccessBodies(o);
            return;
        }
    }

    static OString sd(RTL_CONSTASCII_STRINGPARAM("_"));
    bool body = ((delegate.getLength() > 0) ? true : false);
    bool defaultbody = ((delegate.equals(sd)) ? true : false);

    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)));
            }
            printMethods(o, options, manager, super, generated, delegate,
                         indentation, defaultvalue, usepropertymixin);
        }
        if ( reader.getFieldCount() > 0 || reader.getMethodCount() > 0 ) {
            o << indentation << "// ";
            printType(o, options, manager, type, false);
            o << ":\n";
        }
    }
    sal_uInt16 method = 0;
    for ( sal_uInt16 i = 0; i < reader.getFieldCount(); ++i ) {
//         OString fieldName(
//             codemaker::convertString(reader.getFieldName(i)).
//             replace('/', '.'));
//         OString fieldType(
//             codemaker::convertString(reader.getFieldTypeName(i)).
//             replace('/', '.'));
//         attributes.insert(StringPairHashMap::value_type(fieldName,
//                               std::pair<OString, sal_Int16>(
//                                   fieldType, reader.getFieldFlags(i))));

        o << indentation << "public ";
        printType(o,
            options, manager,
            codemaker::convertString(reader.getFieldTypeName(i)), false);
        o << " get"
          << codemaker::convertString(reader.getFieldName(i)).getStr()
          << "()";

        #if 0
		// DEBUG
		sal_uInt16 mc = reader.getMethodCount();
		RTMethodMode mm = reader.getMethodFlags(method);
        #endif
		OUString mn = reader.getMethodName(method);
		OUString fn = reader.getFieldName(i);

        if ( method < reader.getMethodCount()
             && reader.getMethodFlags(method) == RT_MODE_ATTRIBUTE_GET
             && reader.getMethodName(method) == reader.getFieldName(i) )
        {
            printExceptionSpecification(o, options, manager, reader, method++);
        }
        if ( body ) {
            if ( defaultbody ) {
                if ( usepropertymixin ) {
                    o << "\n" << indentation << "{\n" << indentation
                      << "    return m_"
                      << codemaker::convertString(reader.getFieldName(i)).getStr()
                      << ";\n" << indentation << "}\n\n";
                } else {
                    o << "\n" << indentation << "{\n" << indentation
                      << "    return ";
                    printType(o,
                              options, manager,
                              codemaker::convertString(reader.getFieldTypeName(i)),
                              false, true);
                    o << ";\n" << indentation << "}\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";
		}

		// REMOVE next line
		OUString tmp = reader.getFieldName(i);
		bool setAttrMethod = false;
        if ( (reader.getFieldFlags(i) & RT_ACCESS_READONLY) == 0 ) {
            o << indentation << "public void set"
              << (codemaker::convertString(reader.getFieldName(i)).
                  getStr())
              << '(';
            printType(o,
                options, manager,
                codemaker::convertString(reader.getFieldTypeName(i)),
                false);
            o << " the_value)";
            if ( method < reader.getMethodCount()
                 && reader.getMethodFlags(method) == RT_MODE_ATTRIBUTE_SET
                 && reader.getMethodName(method) == reader.getFieldName(i) )
            {
				setAttrMethod=true;
                printExceptionSpecification(o, options, manager, reader, method);
            }
            if ( body ) {
                if ( defaultbody ) {
                    if ( usepropertymixin ) {
                        printSetPropertyMixinBody(o, reader, i, method,
                                                  indentation);
                    } else {
                        o << "\n" << indentation << "{\n\n" << indentation
                          << "}\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";
			}
			if (setAttrMethod) ++method;
        }
    }
    for ( ; method < reader.getMethodCount(); ++method ) {
        o << indentation << "public ";
        printType(o,
            options, manager,
            codemaker::convertString(
                reader.getMethodReturnTypeName(method)),
            false);

        const OString methodName(codemaker::convertString(reader.getMethodName(method)));

        o << ' ' << methodName.getStr() << '(';
        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" << indentation << "{\n";
                if ( !reader.getMethodReturnTypeName(method).equals(s) ) {
                    o << indentation << "    // TODO: Exchange the default return "
                      << "implementation for \"" << methodName << "\" !!!\n";
                    o << indentation << "    // NOTE: "
                        "Default initialized polymorphic structs can cause problems"
                        "\n" << indentation << "    // because of missing default "
                        "initialization of primitive types of\n" << indentation
                      << "    // some C++ compilers or different Any initialization"
                        " in Java and C++\n" << indentation
                      << "    // polymorphic structs.\n" << indentation
                      << "    return ";
                    printType(o,
                        options, manager,
                        codemaker::convertString(
                            reader.getMethodReturnTypeName(method)),
                        false, true);
                    o << ";";
                } else {
                    o << indentation << "    // TODO: Insert your implementation for \""
                      << methodName << "\" here.";
                }
                o << "\n" << indentation << "}\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";
        }
    }
}

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 << "public static ";
        printType(o,
            options, manager,
            codemaker::convertString(reader.getSuperTypeName(0)), false);
        o << ' ';
        if ( reader.getMethodName(i).getLength() == 0 ) {
            o << "create";
        } else {
            o << (codemaker::java::translateUnoToJavaIdentifier(
                      codemaker::convertString(reader.getMethodName(i)),
                      "method").getStr());
        }
        o << "(com.sun.star.uno.XComponentContext the_context";
        printMethodParameters(o, options, manager, reader, i, true, true);
        o << ')';
        printExceptionSpecification(o, options, manager, reader, i);
        o << ";\n";
    }
}

void generateDocumentation(std::ostream & o,
    ProgramOptions const & options, TypeManager const & manager,
    OString const & type);

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// 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, false);
        o << " "
          << codemaker::java::translateUnoToJavaIdentifier(
              fieldName, "property").getStr()
          << ";\n";
    }
}

void printMapsToJavaType(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 * javaTypeSort)
{
    o << "maps to Java " << (options.java5 ? "1.5" : "1.4") << " ";
    if ( javaTypeSort != 0 ) {
        o << javaTypeSort << ' ';
    }
    o << "type \"";
    if ( rank == 0 && name == "com/sun/star/uno/XInterface" ) {
        o << "com.sun.star.uno.XInterface";
    } else {
        printType(o,
            options, manager, sort, typeClass, name, rank, arguments, false);
    }
    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 ) {
        printMapsToJavaType(o,
            options, manager, sort, typeClass, name, rank, arguments, "array");
        o << '\n';
    } else if ( sort != codemaker::UnoType::SORT_COMPLEX ) {
        printMapsToJavaType(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:
            printMapsToJavaType(o,
                options, manager, sort, typeClass, name, rank, arguments,
                "interface");
            if ( name == "com/sun/star/uno/XInterface" ) {
                o << '\n';
            } else {
                o
                    << "; " << (options.all ? "all" : "direct")
                    << " methods:\n";
                codemaker::GeneratedTypeSet generated;
                printMethods(o, options, manager, reader, generated,
                             delegate, "");
            }
            break;

        case RT_TYPE_MODULE:
            printMapsToJavaType(o,
                options, manager, sort, typeClass, name, rank, arguments,
                "package");
            o << '\n';
            break;

        case RT_TYPE_STRUCT:
            if ( reader.getReferenceCount() == 0 ) {
                printMapsToJavaType(o,
                    options, manager, sort, typeClass, name, rank, arguments,
                    "class");
            } else if ( arguments.empty() ) {
                printMapsToJavaType(o,
                    options, manager, sort, typeClass, name, rank, arguments,
                    options.java5 ? "generic class" : "class");
            } else {
                printMapsToJavaType(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:
        case RT_TYPE_CONSTANTS:
            printMapsToJavaType(o,
                options, manager, sort, typeClass, name, rank, arguments,
                "class");
            o << '\n';
            break;

        case RT_TYPE_EXCEPTION:
            printMapsToJavaType(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 ) {
                printMapsToJavaType(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 {
                o << ("does not map to Java\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) ) {
                printMapsToJavaType(o, options, manager, sort, typeClass,
                                    name, rank, arguments, "class");
                o << "; get method:\npublic static ";
                printType(o, options, manager,
                          codemaker::convertString(reader.getSuperTypeName(0)),
                          false);
                o
                    << " get(com.sun.star.uno.XComponentContext context);\n";
            } else {
                o << "does not map to Java\n";
            }
            break;

        default:
            OSL_ASSERT(false);
            break;
        }
    }
}

} }