/**************************************************************
 * 
 * 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 "javatype.hxx"

#include "classfile.hxx"
#include "javaoptions.hxx"

#include "codemaker/exceptiontree.hxx"
#include "codemaker/generatedtypeset.hxx"
#include "codemaker/global.hxx"
#include "codemaker/options.hxx"
#include "codemaker/typemanager.hxx"
#include "codemaker/unotype.hxx"
#include "codemaker/commonjava.hxx"

#include "osl/diagnose.h"
#include "registry/reader.hxx"
#include "registry/refltype.hxx"
#include "registry/types.h"
#include "rtl/strbuf.hxx"
#include "rtl/string.h"
#include "rtl/string.hxx"
#include "rtl/textcvt.h"
#include "rtl/textenc.h"
#include "rtl/ustring.h"
#include "rtl/ustring.hxx"
#include "sal/types.h"

#include <algorithm>
#include <list>
#include <map>
#include <memory>
#include <set>
#include <utility>
#include <vector>

using codemaker::javamaker::ClassFile;

namespace {

void checkNoTypeArguments(std::vector< rtl::OString > const & arguments) {
    if (!arguments.empty()) {
        throw CannotDumpException(
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("Bad type information")));
            //TODO
    }
}

// helper function for createUnoName
void appendUnoName(
    TypeManager const & manager, rtl::OString const & nucleus, sal_Int32 rank,
    std::vector< rtl::OString > const & arguments, rtl::OStringBuffer * buffer)
{
    OSL_ASSERT(rank >= 0 && buffer != 0);
    for (sal_Int32 i = 0; i < rank; ++i) {
        buffer->append(RTL_CONSTASCII_STRINGPARAM("[]"));
    }
    buffer->append(nucleus.replace('/', '.'));
    if (!arguments.empty()) {
        buffer->append('<');
        for (std::vector< rtl::OString >::const_iterator i(arguments.begin());
             i != arguments.end(); ++i)
        {
            if (i != arguments.begin()) {
                buffer->append(',');
            }
            RTTypeClass argTypeClass;
            rtl::OString argNucleus;
            sal_Int32 argRank;
            std::vector< rtl::OString > argArgs;
            codemaker::decomposeAndResolve(
                manager, *i, true, false, false, &argTypeClass, &argNucleus,
                &argRank, &argArgs);
            appendUnoName(manager, argNucleus, argRank, argArgs, buffer);
        }
        buffer->append('>');
    }
}

// Translate the name of a UNO type registry entity (enum type, plain struct
// type, polymorphic struct type template, or interface type, decomposed into
// nucleus, rank, and arguments) into a core UNO type name:
rtl::OString createUnoName(
    TypeManager const & manager, rtl::OString const & nucleus, sal_Int32 rank,
    std::vector< rtl::OString > const & arguments)
{
    rtl::OStringBuffer buf;
    appendUnoName(manager, nucleus, rank, arguments, &buf);
    return buf.makeStringAndClear();
}

/**
   Set of UTF-8--encoded names of UNO type registry entities a given UNO type
   registry entity depends on.

   UNO type registry entities are enum types, plain struct types, polymorphic
   struct type templates, exception types, interface types, typedefs, modules,
   constant groupds, single-interface--based services, accumulation-based
   services, interface-based singletons, and service-based singletons.
 */
typedef std::set< rtl::OString > Dependencies;

enum SpecialType {
    SPECIAL_TYPE_NONE,
    SPECIAL_TYPE_ANY,
    SPECIAL_TYPE_UNSIGNED,
    SPECIAL_TYPE_INTERFACE
};

bool isSpecialType(SpecialType special) {
    return special >= SPECIAL_TYPE_UNSIGNED;
}

rtl::OString translateUnoTypeToJavaFullyQualifiedName(
    rtl::OString const & type, rtl::OString const & prefix)
{
    sal_Int32 i = type.lastIndexOf('/') + 1;
    return type.copy(0, i) +
        codemaker::java::translateUnoToJavaIdentifier(type.copy(i), prefix);
}

struct PolymorphicUnoType {
    PolymorphicUnoType(): kind(KIND_NONE) {}

    enum Kind { KIND_NONE, KIND_STRUCT, KIND_SEQUENCE };
    Kind kind;
    rtl::OString name;
};

SpecialType translateUnoTypeToDescriptor(
    TypeManager const & manager, rtl::OString const & type, bool array,
    bool classType, Dependencies * dependencies,
    rtl::OStringBuffer * descriptor, rtl::OStringBuffer * signature,
    bool * needsSignature, PolymorphicUnoType * polymorphicUnoType);

SpecialType translateUnoTypeToDescriptor(
    TypeManager const & manager, codemaker::UnoType::Sort sort,
    RTTypeClass typeClass, rtl::OString const & nucleus, sal_Int32 rank,
    std::vector< rtl::OString > const & arguments, bool array, bool classType,
    Dependencies * dependencies, rtl::OStringBuffer * descriptor,
    rtl::OStringBuffer * signature, bool * needsSignature,
    PolymorphicUnoType * polymorphicUnoType)
{
    OSL_ASSERT(rank >= 0 && (signature == 0) == (needsSignature == 0));
    if (rank > 0xFF - (array ? 1 : 0)) {
        throw CannotDumpException(
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM(
                    "Too many array dimensions for Java class file format")));
    }
    if (array) {
        ++rank;
    }
    for (sal_Int32 i = 0; i < rank; ++i) {
        if (descriptor != 0) {
            descriptor->append('[');
        }
        if (signature != 0) {
            signature->append('[');
        }
    }
    if (sort == codemaker::UnoType::SORT_COMPLEX) {
        //TODO: check that nucleus is a valid (Java-modified UTF-8) identifier
        rtl::OString superClass;
        if (typeClass == RT_TYPE_INTERFACE
            && (nucleus
                == rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/XInterface"))))
        {
            if (descriptor != 0) {
                descriptor->append(
                    rtl::OString(
                        RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Object;")));
            }
            if (signature != 0) {
                signature->append(
                    rtl::OString(
                        RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Object;")));
            }
            if (polymorphicUnoType != 0) {
                polymorphicUnoType->kind = PolymorphicUnoType::KIND_NONE;
            }
            return SPECIAL_TYPE_INTERFACE;
        } else {
            if (dependencies != 0) {
                dependencies->insert(nucleus);
            }
            if (descriptor != 0) {
                descriptor->append('L');
                descriptor->append(nucleus);
                descriptor->append(';');
            }
            if (signature != 0) {
                signature->append('L');
                signature->append(nucleus);
                if (!arguments.empty()) {
                    signature->append('<');
                    for (std::vector< rtl::OString >::const_iterator i(
                             arguments.begin());
                         i != arguments.end(); ++i)
                    {
                        translateUnoTypeToDescriptor(
                            manager, *i, false, true, dependencies, 0,
                            signature, needsSignature, 0);
                    }
                    signature->append('>');
                    *needsSignature = true;
                }
                signature->append(';');
            }
            if (polymorphicUnoType != 0) {
                if (arguments.empty()) {
                    polymorphicUnoType->kind = PolymorphicUnoType::KIND_NONE;
                } else {
                    polymorphicUnoType->kind = rank == 0
                        ? PolymorphicUnoType::KIND_STRUCT
                        : PolymorphicUnoType::KIND_SEQUENCE;
                    polymorphicUnoType->name = createUnoName(
                        manager, nucleus, rank, arguments);
                }
            }
            return SPECIAL_TYPE_NONE;
        }
    } else {
        static rtl::OString const
            simpleTypeDescriptors[codemaker::UnoType::SORT_ANY + 1][2] = {
                { rtl::OString(RTL_CONSTASCII_STRINGPARAM("V")),
                  rtl::OString(RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Void;"))
                },
                { rtl::OString(RTL_CONSTASCII_STRINGPARAM("Z")),
                  rtl::OString(
                      RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Boolean;"))
                },
                { rtl::OString(RTL_CONSTASCII_STRINGPARAM("B")),
                  rtl::OString(RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Byte;"))
                },
                { rtl::OString(RTL_CONSTASCII_STRINGPARAM("S")),
                  rtl::OString(RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Short;"))
                },
                { rtl::OString(RTL_CONSTASCII_STRINGPARAM("S")),
                  rtl::OString(RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Short;"))
                },
                { rtl::OString(RTL_CONSTASCII_STRINGPARAM("I")),
                  rtl::OString(
                      RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Integer;"))
                },
                { rtl::OString(RTL_CONSTASCII_STRINGPARAM("I")),
                  rtl::OString(
                      RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Integer;"))
                },
                { rtl::OString(RTL_CONSTASCII_STRINGPARAM("J")),
                  rtl::OString(RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Long;"))
                },
                { rtl::OString(RTL_CONSTASCII_STRINGPARAM("J")),
                  rtl::OString(RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Long;"))
                },
                { rtl::OString(RTL_CONSTASCII_STRINGPARAM("F")),
                  rtl::OString(RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Float;"))
                },
                { rtl::OString(RTL_CONSTASCII_STRINGPARAM("D")),
                  rtl::OString(RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Double;"))
                },
                { rtl::OString(RTL_CONSTASCII_STRINGPARAM("C")),
                  rtl::OString(
                      RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Character;"))
                },
                { rtl::OString(
                      RTL_CONSTASCII_STRINGPARAM("Ljava/lang/String;")),
                  rtl::OString(RTL_CONSTASCII_STRINGPARAM("Ljava/lang/String;"))
                },
                { rtl::OString(
                      RTL_CONSTASCII_STRINGPARAM("Lcom/sun/star/uno/Type;")),
                  rtl::OString(
                      RTL_CONSTASCII_STRINGPARAM("Lcom/sun/star/uno/Type;"))
                },
                { rtl::OString(
                      RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Object;")),
                  rtl::OString(
                      RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Object;"))
                } };
        rtl::OString const & s
            = simpleTypeDescriptors[sort][rank == 0 && classType];
        if (descriptor != 0) {
            descriptor->append(s);
        }
        if (signature != 0) {
            signature->append(s);
        }
        if (polymorphicUnoType != 0) {
            polymorphicUnoType->kind = PolymorphicUnoType::KIND_NONE;
        }
        static SpecialType const
            simpleTypeSpecials[codemaker::UnoType::SORT_ANY + 1] = {
                SPECIAL_TYPE_NONE, SPECIAL_TYPE_NONE, SPECIAL_TYPE_NONE,
                SPECIAL_TYPE_NONE, SPECIAL_TYPE_UNSIGNED, SPECIAL_TYPE_NONE,
                SPECIAL_TYPE_UNSIGNED, SPECIAL_TYPE_NONE, SPECIAL_TYPE_UNSIGNED,
                SPECIAL_TYPE_NONE, SPECIAL_TYPE_NONE, SPECIAL_TYPE_NONE,
                SPECIAL_TYPE_NONE, SPECIAL_TYPE_NONE, SPECIAL_TYPE_ANY };
        return simpleTypeSpecials[sort];
    }
}

SpecialType translateUnoTypeToDescriptor(
    TypeManager const & manager, rtl::OString const & type, bool array,
    bool classType, Dependencies * dependencies,
    rtl::OStringBuffer * descriptor, rtl::OStringBuffer * signature,
    bool * needsSignature, PolymorphicUnoType * polymorphicUnoType)
{
    RTTypeClass typeClass;
    rtl::OString nucleus;
    sal_Int32 rank;
    std::vector< rtl::OString > args;
    codemaker::UnoType::Sort sort = codemaker::decomposeAndResolve(
        manager, type, true, true, false, &typeClass, &nucleus, &rank, &args);
    OSL_ASSERT(rank < SAL_MAX_INT32);
    return translateUnoTypeToDescriptor(
        manager, sort, typeClass, nucleus, rank, args, array, classType,
        dependencies, descriptor, signature, needsSignature,
        polymorphicUnoType);
}

SpecialType getFieldDescriptor(
    TypeManager const & manager, Dependencies * dependencies,
    rtl::OString const & type, rtl::OString * descriptor,
    rtl::OString * signature, PolymorphicUnoType * polymorphicUnoType)
{
    OSL_ASSERT(dependencies != 0 && descriptor != 0);
    rtl::OStringBuffer desc;
    rtl::OStringBuffer sig;
    bool needsSig = false;
    SpecialType specialType = translateUnoTypeToDescriptor(
        manager, type, false, false, dependencies, &desc, &sig, &needsSig,
        polymorphicUnoType);
    *descriptor = desc.makeStringAndClear();
    if (signature != 0) {
        if (needsSig) {
            *signature = sig.makeStringAndClear();
        } else {
            *signature = rtl::OString();
        }
    }
    return specialType;
}

class MethodDescriptor {
public:
    MethodDescriptor(
        TypeManager const & manager, Dependencies * dependencies,
        rtl::OString const & returnType, SpecialType * specialReturnType,
        PolymorphicUnoType * polymorphicUnoType);

    SpecialType addParameter(
        rtl::OString const & type, bool array, bool dependency,
        PolymorphicUnoType * polymorphicUnoType);

    void addTypeParameter(rtl::OString const & name);

    rtl::OString getDescriptor() const;

    rtl::OString getSignature() const;

private:
    TypeManager const & m_manager;
    Dependencies * m_dependencies;
    rtl::OStringBuffer m_descriptorStart;
    rtl::OString m_descriptorEnd;
    rtl::OStringBuffer m_signatureStart;
    rtl::OString m_signatureEnd;
    bool m_needsSignature;
};

MethodDescriptor::MethodDescriptor(
    TypeManager const & manager, Dependencies * dependencies,
    rtl::OString const & returnType, SpecialType * specialReturnType,
    PolymorphicUnoType * polymorphicUnoType):
    m_manager(manager), m_dependencies(dependencies), m_needsSignature(false)
{
    OSL_ASSERT(dependencies != 0);
    m_descriptorStart.append('(');
    m_signatureStart.append('(');
    rtl::OStringBuffer descEnd;
    descEnd.append(')');
    rtl::OStringBuffer sigEnd;
    sigEnd.append(')');
    SpecialType special = translateUnoTypeToDescriptor(
        m_manager, returnType, false, false, m_dependencies, &descEnd, &sigEnd,
        &m_needsSignature, polymorphicUnoType);
    m_descriptorEnd = descEnd.makeStringAndClear();
    m_signatureEnd = sigEnd.makeStringAndClear();
    if (specialReturnType != 0) {
        *specialReturnType = special;
    }
}

SpecialType MethodDescriptor::addParameter(
    rtl::OString const & type, bool array, bool dependency,
    PolymorphicUnoType * polymorphicUnoType)
{
    return translateUnoTypeToDescriptor(
        m_manager, type, array, false, dependency ? m_dependencies : 0,
        &m_descriptorStart, &m_signatureStart, &m_needsSignature,
        polymorphicUnoType);
}

void MethodDescriptor::addTypeParameter(rtl::OString const & name) {
    m_descriptorStart.append(RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Object;"));
    m_signatureStart.append('T');
    m_signatureStart.append(name);
    m_signatureStart.append(';');
    m_needsSignature = true;
}

rtl::OString MethodDescriptor::getDescriptor() const {
    rtl::OStringBuffer buf(m_descriptorStart);
    buf.append(m_descriptorEnd);
    return buf.makeStringAndClear();
}

rtl::OString MethodDescriptor::getSignature() const {
    if (m_needsSignature) {
        rtl::OStringBuffer buf(m_signatureStart);
        buf.append(m_signatureEnd);
        return buf.makeStringAndClear();
    } else {
        return rtl::OString();
    }
}

class TypeInfo {
public:
    enum Kind { KIND_MEMBER, KIND_ATTRIBUTE, KIND_METHOD, KIND_PARAMETER };

    // Same values as in com/sun/star/lib/uno/typeinfo/TypeInfo.java:
    enum Flags {
        FLAG_READONLY = 0x008, FLAG_BOUND = 0x100, FLAG_ONEWAY = 0x010
    };

    // KIND_MEMBER:
    TypeInfo(
        rtl::OString const & name, SpecialType specialType, sal_Int32 index,
        PolymorphicUnoType const & polymorphicUnoType,
        sal_Int32 typeParameterIndex);

    // KIND_ATTRIBUTE/METHOD:
    TypeInfo(
        Kind kind, rtl::OString const & name, SpecialType specialType,
        Flags flags, sal_Int32 index,
        PolymorphicUnoType const & polymorphicUnoType);

    // KIND_PARAMETER:
    TypeInfo(
        rtl::OString const & parameterName, SpecialType specialType,
        bool inParameter, bool outParameter, rtl::OString const & methodName,
        sal_Int32 index, PolymorphicUnoType const & polymorphicUnoType);

    sal_uInt16 generateCode(ClassFile::Code & code, Dependencies * dependencies)
        const;

    void generatePolymorphicUnoTypeCode(
        ClassFile::Code & code, Dependencies * dependencies) const;

private:
    Kind m_kind;
    rtl::OString m_name;
    sal_Int32 m_flags;
    sal_Int32 m_index;
    rtl::OString m_methodName;
    PolymorphicUnoType m_polymorphicUnoType;
    sal_Int32 m_typeParameterIndex;
};

sal_Int32 translateSpecialTypeFlags(
    SpecialType specialType, bool inParameter, bool outParameter)
{
    static sal_Int32 const specialTypeFlags[SPECIAL_TYPE_INTERFACE + 1] = {
        0, 0x0040 /* ANY */, 0x0004 /* UNSIGNED */, 0x0080 /* INTERFACE */ };
    sal_Int32 flags = specialTypeFlags[specialType];
    if (inParameter) {
        flags |= 0x0001; /* IN */
    }
    if (outParameter) {
        flags |= 0x0002; /* OUT */
    }
    return flags;
}

TypeInfo::TypeInfo(
    rtl::OString const & name, SpecialType specialType, sal_Int32 index,
    PolymorphicUnoType const & polymorphicUnoType,
    sal_Int32 typeParameterIndex):
    m_kind(KIND_MEMBER), m_name(name),
    m_flags(translateSpecialTypeFlags(specialType, false, false)),
    m_index(index), m_polymorphicUnoType(polymorphicUnoType),
    m_typeParameterIndex(typeParameterIndex)
{
    OSL_ASSERT(
        polymorphicUnoType.kind == PolymorphicUnoType::KIND_NONE
        ? typeParameterIndex >= -1 : typeParameterIndex == -1);
}

TypeInfo::TypeInfo(
    Kind kind, rtl::OString const & name, SpecialType specialType,
    Flags flags, sal_Int32 index,
    PolymorphicUnoType const & polymorphicUnoType):
    m_kind(kind), m_name(name),
    m_flags(flags | translateSpecialTypeFlags(specialType, false, false)),
    m_index(index), m_polymorphicUnoType(polymorphicUnoType)
{
    OSL_ASSERT(kind == KIND_ATTRIBUTE || kind == KIND_METHOD);
}

TypeInfo::TypeInfo(
    rtl::OString const & parameterName, SpecialType specialType,
    bool inParameter, bool outParameter, rtl::OString const & methodName,
    sal_Int32 index, PolymorphicUnoType const & polymorphicUnoType):
    m_kind(KIND_PARAMETER), m_name(parameterName),
    m_flags(translateSpecialTypeFlags(specialType, inParameter, outParameter)),
    m_index(index), m_methodName(methodName),
    m_polymorphicUnoType(polymorphicUnoType)
{}

sal_uInt16 TypeInfo::generateCode(
    ClassFile::Code & code, Dependencies * dependencies) const
{
    OSL_ASSERT(dependencies != 0);
    switch (m_kind) {
    case KIND_MEMBER:
        code.instrNew(
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM(
                    "com/sun/star/lib/uno/typeinfo/MemberTypeInfo")));
        code.instrDup();
        code.loadStringConstant(m_name);
        code.loadIntegerConstant(m_index);
        code.loadIntegerConstant(m_flags);
        if (m_polymorphicUnoType.kind != PolymorphicUnoType::KIND_NONE) {
            generatePolymorphicUnoTypeCode(code, dependencies);
            code.loadIntegerConstant(m_typeParameterIndex);
            code.instrInvokespecial(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "com/sun/star/lib/uno/typeinfo/MemberTypeInfo")),
                rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "(Ljava/lang/String;IILcom/sun/star/uno/Type;I)V")));
            return 8;
        } else if (m_typeParameterIndex >= 0) {
            code.instrAconstNull();
            code.loadIntegerConstant(m_typeParameterIndex);
            code.instrInvokespecial(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "com/sun/star/lib/uno/typeinfo/MemberTypeInfo")),
                rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "(Ljava/lang/String;IILcom/sun/star/uno/Type;I)V")));
            return 6;
        } else {
            code.instrInvokespecial(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "com/sun/star/lib/uno/typeinfo/MemberTypeInfo")),
                rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("(Ljava/lang/String;II)V")));
            return 4;
        }

    case KIND_ATTRIBUTE:
        code.instrNew(
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM(
                    "com/sun/star/lib/uno/typeinfo/AttributeTypeInfo")));
        code.instrDup();
        code.loadStringConstant(m_name);
        code.loadIntegerConstant(m_index);
        code.loadIntegerConstant(m_flags);
        if (m_polymorphicUnoType.kind != PolymorphicUnoType::KIND_NONE) {
            generatePolymorphicUnoTypeCode(code, dependencies);
            code.instrInvokespecial(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "com/sun/star/lib/uno/typeinfo/AttributeTypeInfo")),
                rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "(Ljava/lang/String;IILcom/sun/star/uno/Type;)V")));
            return 8;
        } else {
            code.instrInvokespecial(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "com/sun/star/lib/uno/typeinfo/AttributeTypeInfo")),
                rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("(Ljava/lang/String;II)V")));
            return 4;
        }

    case KIND_METHOD:
        code.instrNew(
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM(
                    "com/sun/star/lib/uno/typeinfo/MethodTypeInfo")));
        code.instrDup();
        code.loadStringConstant(m_name);
        code.loadIntegerConstant(m_index);
        code.loadIntegerConstant(m_flags);
        if (m_polymorphicUnoType.kind != PolymorphicUnoType::KIND_NONE) {
            generatePolymorphicUnoTypeCode(code, dependencies);
            code.instrInvokespecial(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "com/sun/star/lib/uno/typeinfo/MethodTypeInfo")),
                rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "(Ljava/lang/String;IILcom/sun/star/uno/Type;)V")));
            return 8;
        } else {
            code.instrInvokespecial(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "com/sun/star/lib/uno/typeinfo/MethodTypeInfo")),
                rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("(Ljava/lang/String;II)V")));
            return 4;
        }

    case KIND_PARAMETER:
        code.instrNew(
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM(
                    "com/sun/star/lib/uno/typeinfo/ParameterTypeInfo")));
        code.instrDup();
        code.loadStringConstant(m_name);
        code.loadStringConstant(m_methodName);
        code.loadIntegerConstant(m_index);
        code.loadIntegerConstant(m_flags);
        if (m_polymorphicUnoType.kind != PolymorphicUnoType::KIND_NONE) {
            generatePolymorphicUnoTypeCode(code, dependencies);
            code.instrInvokespecial(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "com/sun/star/lib/uno/typeinfo/ParameterTypeInfo")),
                rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "(Ljava/lang/String;Ljava/lang/String;II"
                        "Lcom/sun/star/uno/Type;)V")));
            return 9;
        } else {
            code.instrInvokespecial(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "com/sun/star/lib/uno/typeinfo/ParameterTypeInfo")),
                rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "(Ljava/lang/String;Ljava/lang/String;II)V")));
            return 5;
        }

    default:
        OSL_ASSERT(false);
        return 0;
    }
}

void TypeInfo::generatePolymorphicUnoTypeCode(
    ClassFile::Code & code, Dependencies * dependencies) const
{
    OSL_ASSERT(
        dependencies != 0
        && m_polymorphicUnoType.kind != PolymorphicUnoType::KIND_NONE);
    code.instrNew(
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Type")));
    code.instrDup();
    code.loadStringConstant(m_polymorphicUnoType.name);
    if (m_polymorphicUnoType.kind == PolymorphicUnoType::KIND_STRUCT) {
        code.instrGetstatic(
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/TypeClass")),
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("STRUCT")),
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM("Lcom/sun/star/uno/TypeClass;")));
    } else {
        code.instrGetstatic(
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/TypeClass")),
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("SEQUENCE")),
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM("Lcom/sun/star/uno/TypeClass;")));
    }
    dependencies->insert(
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/TypeClass")));
    code.instrInvokespecial(
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Type")),
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
        rtl::OString(
            RTL_CONSTASCII_STRINGPARAM(
                "(Ljava/lang/String;Lcom/sun/star/uno/TypeClass;)V")));
}

void writeClassFile(
    JavaOptions /*TODO const*/ & options, rtl::OString const & type,
    ClassFile const & classFile)
{
    rtl::OString path;
    if (options.isValid(rtl::OString(RTL_CONSTASCII_STRINGPARAM("-O")))) {
        path = options.getOption(
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("-O")));
    }
    rtl::OString filename(
        createFileNameFromType(
            path, type, rtl::OString(RTL_CONSTASCII_STRINGPARAM(".class"))));
    bool check = false;
    if (fileExists(filename)) {
        if (options.isValid(rtl::OString(RTL_CONSTASCII_STRINGPARAM("-G")))) {
            return;
        }
        check = options.isValid(
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("-Gc")));
    }
    FileStream tempfile;
    tempfile.createTempFile(getTempDir(filename));
    if (!tempfile.isValid()) {
        throw CannotDumpException(
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM("Cannot create temporary file for "))
            + filename);
    }
    rtl::OString tempname(tempfile.getName());
    try {
        classFile.write(tempfile);
    } catch (...) {
        // Remove existing file for consistency:
        if (fileExists(filename)) {
            removeTypeFile(filename);
        }
        tempfile.close();
        removeTypeFile(tempname);
        throw;
    }
    tempfile.close();
    if (!makeValidTypeFile(filename, tempname, check)) {
        rtl::OStringBuffer msg;
        msg.append(RTL_CONSTASCII_STRINGPARAM("Cannot create "));
        msg.append(filename);
        msg.append(RTL_CONSTASCII_STRINGPARAM(" from temporary file "));
        msg.append(tempname);
        throw CannotDumpException(msg.makeStringAndClear());
    }
}

void addTypeInfo(
    rtl::OString const & className, std::vector< TypeInfo > const & typeInfo,
    Dependencies * dependencies, ClassFile * classFile)
{
    OSL_ASSERT(dependencies != 0 && classFile != 0);
    std::vector< TypeInfo >::size_type typeInfos = typeInfo.size();
    if (typeInfos > SAL_MAX_INT32) {
        throw CannotDumpException(
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM(
                    "UNOTYPEINFO array too big for Java class file format")));
    }
    if (typeInfos != 0) {
        classFile->addField(
            static_cast< ClassFile::AccessFlags >(
                ClassFile::ACC_PUBLIC | ClassFile::ACC_STATIC
                | ClassFile::ACC_FINAL),
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("UNOTYPEINFO")),
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM(
                    "[Lcom/sun/star/lib/uno/typeinfo/TypeInfo;")),
            0, rtl::OString());
        std::auto_ptr< ClassFile::Code > code(classFile->newCode());
        code->loadIntegerConstant(static_cast< sal_Int32 >(typeInfos));
        code->instrAnewarray(
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM(
                    "com/sun/star/lib/uno/typeinfo/TypeInfo")));
        sal_Int32 index = 0;
        sal_uInt16 stack = 0;
        for (std::vector< TypeInfo >::const_iterator i(typeInfo.begin());
             i != typeInfo.end(); ++i)
        {
            code->instrDup();
            code->loadIntegerConstant(index++);
            stack = std::max(stack, i->generateCode(*code, dependencies));
            code->instrAastore();
        }
        code->instrPutstatic(
            className, rtl::OString(RTL_CONSTASCII_STRINGPARAM("UNOTYPEINFO")),
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM(
                    "[Lcom/sun/star/lib/uno/typeinfo/TypeInfo;")));
        code->instrReturn();
        if (stack > SAL_MAX_UINT16 - 4) {
            throw CannotDumpException(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "Stack too big for Java class file format")));
        }
        code->setMaxStackAndLocals(static_cast< sal_uInt16 >(stack + 4), 0);
        classFile->addMethod(
            static_cast< ClassFile::AccessFlags >(
                ClassFile::ACC_PRIVATE | ClassFile::ACC_STATIC),
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("<clinit>")),
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("()V")), code.get(),
            std::vector< rtl::OString >(), rtl::OString());
    }
}

typedef void (* handleUnoTypeRegistryEntityFunction)(
    TypeManager const & manager, JavaOptions /*TODO const*/ & options,
    typereg::Reader const & reader, Dependencies * dependencies);

void handleEnumType(
    TypeManager const &, JavaOptions /*TODO const*/ & options,
    typereg::Reader const & reader, Dependencies *)
{
    sal_uInt16 fields = reader.getFieldCount();
    if (fields == 0 || reader.getSuperTypeCount() != 0
        || reader.getMethodCount() != 0 || reader.getReferenceCount() != 0)
    {
        throw CannotDumpException(
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("Bad type information")));
            //TODO
    }
    rtl::OString className(codemaker::convertString(reader.getTypeName()));
    std::auto_ptr< ClassFile > cf(
        new ClassFile(
            static_cast< ClassFile::AccessFlags >(
                ClassFile::ACC_PUBLIC | ClassFile::ACC_FINAL
                | ClassFile::ACC_SUPER),
            className,
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Enum")),
            rtl::OString()));
    rtl::OStringBuffer buf;
    buf.append('L');
    buf.append(className);
    buf.append(';');
    rtl::OString classDescriptor(buf.makeStringAndClear());
    {for (sal_uInt16 i = 0; i < fields; ++i) {
        RTConstValue fieldValue(reader.getFieldValue(i));
        if (fieldValue.m_type != RT_TYPE_INT32
            || reader.getFieldFlags(i) != RT_ACCESS_CONST
            || !reader.getFieldTypeName(i).isEmpty())
        {
            throw CannotDumpException(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
        }
        rtl::OString fieldName(
            codemaker::convertString(reader.getFieldName(i)));
        cf->addField(
            static_cast< ClassFile::AccessFlags >(
                ClassFile::ACC_PUBLIC | ClassFile::ACC_STATIC
                | ClassFile::ACC_FINAL),
            fieldName, classDescriptor, 0, rtl::OString());
        cf->addField(
            static_cast< ClassFile::AccessFlags >(
                ClassFile::ACC_PUBLIC | ClassFile::ACC_STATIC
                | ClassFile::ACC_FINAL),
            fieldName + rtl::OString(RTL_CONSTASCII_STRINGPARAM("_value")),
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("I")),
            cf->addIntegerInfo(fieldValue.m_value.aLong), rtl::OString());
    }}
    std::auto_ptr< ClassFile::Code > code(cf->newCode());
    code->loadLocalReference(0);
    code->loadLocalInteger(1);
    code->instrInvokespecial(
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Enum")),
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("(I)V")));
    code->instrReturn();
    code->setMaxStackAndLocals(2, 2);
    cf->addMethod(
        ClassFile::ACC_PRIVATE,
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("(I)V")), code.get(),
        std::vector< rtl::OString >(), rtl::OString());
    code.reset(cf->newCode());
    code->instrGetstatic(
        className,
        codemaker::convertString(reader.getFieldName(0)), classDescriptor);
    code->instrAreturn();
    code->setMaxStackAndLocals(1, 0);
    cf->addMethod(
        static_cast< ClassFile::AccessFlags >(
            ClassFile::ACC_PUBLIC | ClassFile::ACC_STATIC),
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("getDefault")),
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("()")) + classDescriptor,
        code.get(), std::vector< rtl::OString >(), rtl::OString());
    code.reset(cf->newCode());
    code->loadLocalInteger(0);
    std::map< sal_Int32, rtl::OString > map;
    sal_Int32 min = SAL_MAX_INT32;
    sal_Int32 max = SAL_MIN_INT32;
    {for (sal_uInt16 i = 0; i < fields; ++i) {
        sal_Int32 value = reader.getFieldValue(i).m_value.aLong;
        min = std::min(min, value);
        max = std::max(max, value);
        map.insert(
            std::map< sal_Int32, rtl::OString >::value_type(
                value, codemaker::convertString(reader.getFieldName(i))));
    }}
    sal_uInt64 size = static_cast< sal_uInt64 >(map.size());
    if ((static_cast< sal_uInt64 >(max) - static_cast< sal_uInt64 >(min)
         <= 2 * size)
        || size > SAL_MAX_INT32)
    {
        std::auto_ptr< ClassFile::Code > defCode(cf->newCode());
        defCode->instrAconstNull();
        defCode->instrAreturn();
        std::list< ClassFile::Code * > blocks;
            //FIXME: pointers contained in blocks may leak
        sal_Int32 last = SAL_MAX_INT32;
        for (std::map< sal_Int32, rtl::OString >::iterator i(map.begin());
             i != map.end(); ++i)
        {
            sal_Int32 value = i->first;
            if (last != SAL_MAX_INT32) {
                for (sal_Int32 j = last + 1; j < value; ++j) {
                    blocks.push_back(0);
                }
            }
            last = value;
            std::auto_ptr< ClassFile::Code > blockCode(cf->newCode());
            blockCode->instrGetstatic(className, i->second, classDescriptor);
            blockCode->instrAreturn();
            blocks.push_back(blockCode.get());
            blockCode.release();
        }
        code->instrTableswitch(defCode.get(), min, blocks);
        {for (std::list< ClassFile::Code * >::iterator i(blocks.begin());
              i != blocks.end(); ++i)
        {
            delete *i;
        }}
    } else {
        std::auto_ptr< ClassFile::Code > defCode(cf->newCode());
        defCode->instrAconstNull();
        defCode->instrAreturn();
        std::list< std::pair< sal_Int32, ClassFile::Code * > > blocks;
            //FIXME: pointers contained in blocks may leak
        for (std::map< sal_Int32, rtl::OString >::iterator i(map.begin());
             i != map.end(); ++i)
        {
            std::auto_ptr< ClassFile::Code > blockCode(cf->newCode());
            blockCode->instrGetstatic(className, i->second, classDescriptor);
            blockCode->instrAreturn();
            blocks.push_back(std::make_pair(i->first, blockCode.get()));
            blockCode.release();
        }
        code->instrLookupswitch(defCode.get(), blocks);
        {for (std::list< std::pair< sal_Int32, ClassFile::Code * > >::iterator
                  i(blocks.begin());
              i != blocks.end(); ++i)
        {
            delete i->second;
        }}
    }
    code->setMaxStackAndLocals(1, 1);
    cf->addMethod(
        static_cast< ClassFile::AccessFlags >(
            ClassFile::ACC_PUBLIC | ClassFile::ACC_STATIC),
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("fromInt")),
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("(I)")) + classDescriptor,
        code.get(), std::vector< rtl::OString >(), rtl::OString());
    code.reset(cf->newCode());
    {for (sal_uInt16 i = 0; i < fields; ++i) {
        code->instrNew(className);
        code->instrDup();
        code->loadIntegerConstant(reader.getFieldValue(i).m_value.aLong);
        code->instrInvokespecial(
            className, rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("(I)V")));
        code->instrPutstatic(
            className,
            codemaker::convertString(reader.getFieldName(i)),
            classDescriptor);
    }}
    code->instrReturn();
    code->setMaxStackAndLocals(3, 0);
    cf->addMethod(
        static_cast< ClassFile::AccessFlags >(
            ClassFile::ACC_PRIVATE | ClassFile::ACC_STATIC),
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("<clinit>")),
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("()V")), code.get(),
        std::vector< rtl::OString >(), rtl::OString());
    writeClassFile(options, className, *cf.get());
}

void addField(
    TypeManager const & manager, Dependencies * dependencies,
    ClassFile * classFile, std::vector< TypeInfo > * typeInfo,
    sal_Int32 typeParameterIndex, rtl::OString const & type,
    rtl::OString const & name, sal_Int32 index)
{
    OSL_ASSERT(dependencies != 0 && classFile != 0 && typeInfo != 0);
    rtl::OString descriptor;
    rtl::OString signature;
    SpecialType specialType;
    PolymorphicUnoType polymorphicUnoType;
    if (typeParameterIndex >= 0) {
        descriptor = rtl::OString(
            RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Object;"));
        rtl::OStringBuffer buf;
        buf.append('T');
        buf.append(type);
        buf.append(';');
        signature = buf.makeStringAndClear();
        specialType = SPECIAL_TYPE_NONE; //TODO: SPECIAL_TYPE_TYPE_PARAMETER?
    } else {
        specialType = getFieldDescriptor(
            manager, dependencies, type, &descriptor, &signature,
            &polymorphicUnoType);
    }
    classFile->addField(ClassFile::ACC_PUBLIC, name, descriptor, 0, signature);
    typeInfo->push_back(
        TypeInfo(
            name, specialType, index, polymorphicUnoType, typeParameterIndex));
}

sal_uInt16 addFieldInit(
    TypeManager const & manager, rtl::OString const & className,
    rtl::OString const & fieldName, bool typeParameter,
    rtl::OString const & fieldType, Dependencies * dependencies,
    ClassFile::Code * code)
{
    OSL_ASSERT(dependencies != 0 && code != 0);
    if (typeParameter) {
        return 0;
    } else {
        RTTypeClass typeClass;
        rtl::OString nucleus;
        sal_Int32 rank;
        std::vector< rtl::OString > args;
        codemaker::UnoType::Sort sort = codemaker::decomposeAndResolve(
            manager, fieldType, true, false, false, &typeClass, &nucleus, &rank,
            &args);
        if (rank == 0) {
            switch (sort) {
            case codemaker::UnoType::SORT_STRING:
                code->loadLocalReference(0);
                code->loadStringConstant(rtl::OString());
                code->instrPutfield(
                    className, fieldName,
                    rtl::OString(
                        RTL_CONSTASCII_STRINGPARAM("Ljava/lang/String;")));
                return 2;

            case codemaker::UnoType::SORT_TYPE:
                code->loadLocalReference(0);
                code->instrGetstatic(
                    rtl::OString(
                        RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Type")),
                    rtl::OString(RTL_CONSTASCII_STRINGPARAM("VOID")),
                    rtl::OString(
                        RTL_CONSTASCII_STRINGPARAM("Lcom/sun/star/uno/Type;")));
                code->instrPutfield(
                    className, fieldName,
                    rtl::OString(
                        RTL_CONSTASCII_STRINGPARAM("Lcom/sun/star/uno/Type;")));
                return 2;

            case codemaker::UnoType::SORT_ANY:
                code->loadLocalReference(0);
                code->instrGetstatic(
                    rtl::OString(
                        RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Any")),
                    rtl::OString(RTL_CONSTASCII_STRINGPARAM("VOID")),
                    rtl::OString(
                        RTL_CONSTASCII_STRINGPARAM("Lcom/sun/star/uno/Any;")));
                code->instrPutfield(
                    className, fieldName,
                    rtl::OString(
                        RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Object;")));
                return 2;

            case codemaker::UnoType::SORT_COMPLEX:
                switch (typeClass) {
                case RT_TYPE_ENUM:
                    {
                        code->loadLocalReference(0);
                        typereg::Reader reader(manager.getTypeReader(nucleus));
                        if (reader.getFieldCount() == 0) {
                            throw CannotDumpException(
                                rtl::OString(
                                    RTL_CONSTASCII_STRINGPARAM(
                                        "Bad type information"))); //TODO
                        }
                        rtl::OStringBuffer descBuf;
                        translateUnoTypeToDescriptor(
                            manager, sort, typeClass, nucleus, 0,
                            std::vector< rtl::OString >(), false, false,
                            dependencies, &descBuf, 0, 0, 0);
                        rtl::OString desc(descBuf.makeStringAndClear());
                        code->instrGetstatic(
                            nucleus,
                            codemaker::convertString(reader.getFieldName(0)),
                            desc);
                        code->instrPutfield(className, fieldName, desc);
                        return 2;
                    }

                case RT_TYPE_STRUCT:
                    {
                        code->loadLocalReference(0);
                        code->instrNew(nucleus);
                        code->instrDup();
                        code->instrInvokespecial(
                            nucleus,
                            rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                            rtl::OString(RTL_CONSTASCII_STRINGPARAM("()V")));
                        rtl::OStringBuffer desc;
                        translateUnoTypeToDescriptor(
                            manager, sort, typeClass, nucleus, 0,
                            std::vector< rtl::OString >(), false, false,
                            dependencies, &desc, 0, 0, 0);
                        code->instrPutfield(
                            className, fieldName, desc.makeStringAndClear());
                        return 3;
                    }

                default:
                    OSL_ASSERT(typeClass == RT_TYPE_INTERFACE);
                    return 0;
                }

            default:
                return 0;
            }
        } else {
            code->loadLocalReference(0);
            code->loadIntegerConstant(0);
            if (rank == 1) {
                if (sort >= codemaker::UnoType::SORT_BOOLEAN
                    && sort <= codemaker::UnoType::SORT_CHAR)
                {
                    code->instrNewarray(sort);
                } else {
                    code->instrAnewarray(
                        codemaker::java::translateUnoToJavaType(sort, typeClass,
                                                                nucleus, 0));
                }
            } else {
                rtl::OStringBuffer desc;
                translateUnoTypeToDescriptor(
                    manager, sort, typeClass, nucleus, rank - 1,
                    std::vector< rtl::OString >(), false, false, dependencies,
                    &desc, 0, 0, 0);
                code->instrAnewarray(desc.makeStringAndClear());
            }
            rtl::OStringBuffer desc;
            translateUnoTypeToDescriptor(
                manager, sort, typeClass, nucleus, rank,
                std::vector< rtl::OString >(), false, false, dependencies,
                &desc, 0, 0, 0);
            code->instrPutfield(
                className, fieldName, desc.makeStringAndClear());
            return 2;
        }
    }
}

sal_uInt16 addLoadLocal(
    TypeManager const & manager, ClassFile::Code * code, sal_uInt16 * index,
    bool typeParameter, rtl::OString const & type, bool any,
    Dependencies * dependencies)
{
    OSL_ASSERT(
        code != 0 && index != 0 && !(typeParameter && any)
        && dependencies != 0);
    sal_uInt16 stack = 1;
    sal_uInt16 size = 1;
    if (typeParameter) {
        code->loadLocalReference(*index);
        stack = size = 1;
    } else {
        RTTypeClass typeClass;
        rtl::OString nucleus;
        sal_Int32 rank;
        std::vector< rtl::OString > args;
        codemaker::UnoType::Sort sort = codemaker::decomposeAndResolve(
            manager, type, true, false, false, &typeClass, &nucleus, &rank, &args);
        if (rank == 0) {
            switch (sort) {
            case codemaker::UnoType::SORT_BOOLEAN:
                if (any) {
                    code->instrNew(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM("java/lang/Boolean")));
                    code->instrDup();
                    code->loadLocalInteger(*index);
                    code->instrInvokespecial(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM("java/lang/Boolean")),
                        rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                        rtl::OString(RTL_CONSTASCII_STRINGPARAM("(Z)V")));
                    stack = 3;
                } else {
                    code->loadLocalInteger(*index);
                    stack = 1;
                }
                size = 1;
                break;

            case codemaker::UnoType::SORT_BYTE:
                if (any) {
                    code->instrNew(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM("java/lang/Byte")));
                    code->instrDup();
                    code->loadLocalInteger(*index);
                    code->instrInvokespecial(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM("java/lang/Byte")),
                        rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                        rtl::OString(RTL_CONSTASCII_STRINGPARAM("(B)V")));
                    stack = 3;
                } else {
                    code->loadLocalInteger(*index);
                    stack = 1;
                }
                size = 1;
                break;

            case codemaker::UnoType::SORT_SHORT:
                if (any) {
                    code->instrNew(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM("java/lang/Short")));
                    code->instrDup();
                    code->loadLocalInteger(*index);
                    code->instrInvokespecial(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM("java/lang/Short")),
                        rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                        rtl::OString(RTL_CONSTASCII_STRINGPARAM("(S)V")));
                    stack = 3;
                } else {
                    code->loadLocalInteger(*index);
                    stack = 1;
                }
                size = 1;
                break;

            case codemaker::UnoType::SORT_UNSIGNED_SHORT:
                if (any) {
                    code->instrNew(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM(
                                "com/sun/star/uno/Any")));
                    code->instrDup();
                    code->instrGetstatic(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM(
                                "com/sun/star/uno/Type")),
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM("UNSIGNED_SHORT")),
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM(
                                "Lcom/sun/star/uno/Type;")));
                    code->instrNew(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM("java/lang/Short")));
                    code->instrDup();
                    code->loadLocalInteger(*index);
                    code->instrInvokespecial(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM("java/lang/Short")),
                        rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                        rtl::OString(RTL_CONSTASCII_STRINGPARAM("(S)V")));
                    code->instrInvokespecial(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Any")),
                        rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM(
                                "(Lcom/sun/star/uno/Type;Ljava/lang/Object;)"
                                "V")));
                    stack = 6;
                } else {
                    code->loadLocalInteger(*index);
                    stack = 1;
                }
                size = 1;
                break;

            case codemaker::UnoType::SORT_LONG:
                if (any) {
                    code->instrNew(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM("java/lang/Integer")));
                    code->instrDup();
                    code->loadLocalInteger(*index);
                    code->instrInvokespecial(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM("java/lang/Integer")),
                        rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                        rtl::OString(RTL_CONSTASCII_STRINGPARAM("(I)V")));
                    stack = 3;
                } else {
                    code->loadLocalInteger(*index);
                    stack = 1;
                }
                size = 1;
                break;

            case codemaker::UnoType::SORT_UNSIGNED_LONG:
                if (any) {
                    code->instrNew(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM(
                                "com/sun/star/uno/Any")));
                    code->instrDup();
                    code->instrGetstatic(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM(
                                "com/sun/star/uno/Type")),
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM("UNSIGNED_LONG")),
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM(
                                "Lcom/sun/star/uno/Type;")));
                    code->instrNew(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM("java/lang/Integer")));
                    code->instrDup();
                    code->loadLocalInteger(*index);
                    code->instrInvokespecial(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM("java/lang/Integer")),
                        rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                        rtl::OString(RTL_CONSTASCII_STRINGPARAM("(I)V")));
                    code->instrInvokespecial(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Any")),
                        rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM(
                                "(Lcom/sun/star/uno/Type;Ljava/lang/Object;)"
                                "V")));
                    stack = 6;
                } else {
                    code->loadLocalInteger(*index);
                    stack = 1;
                }
                size = 1;
                break;

            case codemaker::UnoType::SORT_HYPER:
                if (any) {
                    code->instrNew(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM("java/lang/Long")));
                    code->instrDup();
                    code->loadLocalLong(*index);
                    code->instrInvokespecial(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM("java/lang/Long")),
                        rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                        rtl::OString(RTL_CONSTASCII_STRINGPARAM("(J)V")));
                    stack = 4;
                } else {
                    code->loadLocalLong(*index);
                    stack = 2;
                }
                size = 2;
                break;

            case codemaker::UnoType::SORT_UNSIGNED_HYPER:
                if (any) {
                    code->instrNew(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM(
                                "com/sun/star/uno/Any")));
                    code->instrDup();
                    code->instrGetstatic(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM(
                                "com/sun/star/uno/Type")),
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM("UNSIGNED_HYPER")),
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM(
                                "Lcom/sun/star/uno/Type;")));
                    code->instrNew(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM("java/lang/Long")));
                    code->instrDup();
                    code->loadLocalLong(*index);
                    code->instrInvokespecial(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM("java/lang/Long")),
                        rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                        rtl::OString(RTL_CONSTASCII_STRINGPARAM("(J)V")));
                    code->instrInvokespecial(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Any")),
                        rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM(
                                "(Lcom/sun/star/uno/Type;Ljava/lang/Object;)"
                                "V")));
                    stack = 7;
                } else {
                    code->loadLocalLong(*index);
                    stack = 2;
                }
                size = 2;
                break;

            case codemaker::UnoType::SORT_FLOAT:
                if (any) {
                    code->instrNew(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM("java/lang/Float")));
                    code->instrDup();
                    code->loadLocalFloat(*index);
                    code->instrInvokespecial(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM("java/lang/Float")),
                        rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                        rtl::OString(RTL_CONSTASCII_STRINGPARAM("(F)V")));
                    stack = 3;
                } else {
                    code->loadLocalFloat(*index);
                    stack = 1;
                }
                size = 1;
                break;

            case codemaker::UnoType::SORT_DOUBLE:
                if (any) {
                    code->instrNew(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM("java/lang/Double")));
                    code->instrDup();
                    code->loadLocalDouble(*index);
                    code->instrInvokespecial(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM("java/lang/Double")),
                        rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                        rtl::OString(RTL_CONSTASCII_STRINGPARAM("(D)V")));
                    stack = 4;
                } else {
                    code->loadLocalDouble(*index);
                    stack = 2;
                }
                size = 2;
                break;

            case codemaker::UnoType::SORT_CHAR:
                if (any) {
                    code->instrNew(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM("java/lang/Character")));
                    code->instrDup();
                    code->loadLocalInteger(*index);
                    code->instrInvokespecial(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM("java/lang/Character")),
                        rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                        rtl::OString(RTL_CONSTASCII_STRINGPARAM("(C)V")));
                    stack = 3;
                } else {
                    code->loadLocalInteger(*index);
                    stack = 1;
                }
                size = 1;
                break;

            case codemaker::UnoType::SORT_STRING:
            case codemaker::UnoType::SORT_TYPE:
            case codemaker::UnoType::SORT_ANY:
                code->loadLocalReference(*index);
                stack = size = 1;
                break;

            case codemaker::UnoType::SORT_COMPLEX:
                switch (typeClass) {
                case RT_TYPE_ENUM:
                    // Assuming that no Java types are derived from Java types
                    // that are directly derived from com.sun.star.uno.Enum:
                    code->loadLocalReference(*index);
                    stack = size = 1;
                    break;

                case RT_TYPE_STRUCT:
                    if (any) {
                        code->instrNew(
                            rtl::OString(
                                RTL_CONSTASCII_STRINGPARAM(
                                    "com/sun/star/uno/Any")));
                        code->instrDup();
                        code->instrNew(
                            rtl::OString(
                                RTL_CONSTASCII_STRINGPARAM(
                                    "com/sun/star/uno/Type")));
                        code->instrDup();
                        code->loadStringConstant(
                            createUnoName(manager, nucleus, rank, args));
                        code->instrGetstatic(
                            rtl::OString(
                                RTL_CONSTASCII_STRINGPARAM(
                                    "com/sun/star/uno/TypeClass")),
                            rtl::OString(RTL_CONSTASCII_STRINGPARAM("STRUCT")),
                            rtl::OString(
                                RTL_CONSTASCII_STRINGPARAM(
                                    "Lcom/sun/star/uno/TypeClass;")));
                        dependencies->insert(
                            rtl::OString(
                                RTL_CONSTASCII_STRINGPARAM(
                                    "com/sun/star/uno/TypeClass")));
                        code->instrInvokespecial(
                            rtl::OString(
                                RTL_CONSTASCII_STRINGPARAM(
                                    "com/sun/star/uno/Type")),
                            rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                            rtl::OString(
                                RTL_CONSTASCII_STRINGPARAM(
                                    "(Ljava/lang/String;"
                                    "Lcom/sun/star/uno/TypeClass;)V")));
                        code->loadLocalReference(*index);
                        code->instrInvokespecial(
                            rtl::OString(
                                RTL_CONSTASCII_STRINGPARAM(
                                    "com/sun/star/uno/Any")),
                            rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                            rtl::OString(
                                RTL_CONSTASCII_STRINGPARAM(
                                    "(Lcom/sun/star/uno/Type;"
                                    "Ljava/lang/Object;)V")));
                        stack = 6;
                    } else {
                        code->loadLocalReference(*index);
                        stack = 1;
                    }
                    size = 1;
                    break;

                case RT_TYPE_INTERFACE:
                    if (any
                        && (nucleus
                            != rtl::OString(
                                RTL_CONSTASCII_STRINGPARAM(
                                    "com/sun/star/uno/XInterface"))))
                    {
                        code->instrNew(
                            rtl::OString(
                                RTL_CONSTASCII_STRINGPARAM(
                                    "com/sun/star/uno/Any")));
                        code->instrDup();
                        code->instrNew(
                            rtl::OString(
                                RTL_CONSTASCII_STRINGPARAM(
                                    "com/sun/star/uno/Type")));
                        code->instrDup();
                        code->loadStringConstant(nucleus.replace('/', '.'));
                        code->instrGetstatic(
                            rtl::OString(
                                RTL_CONSTASCII_STRINGPARAM(
                                    "com/sun/star/uno/TypeClass")),
                            rtl::OString(
                                RTL_CONSTASCII_STRINGPARAM("INTERFACE")),
                            rtl::OString(
                                RTL_CONSTASCII_STRINGPARAM(
                                    "Lcom/sun/star/uno/TypeClass;")));
                        dependencies->insert(
                            rtl::OString(
                                RTL_CONSTASCII_STRINGPARAM(
                                    "com/sun/star/uno/TypeClass")));
                        code->instrInvokespecial(
                            rtl::OString(
                                RTL_CONSTASCII_STRINGPARAM(
                                    "com/sun/star/uno/Type")),
                            rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                            rtl::OString(
                                RTL_CONSTASCII_STRINGPARAM(
                                    "(Ljava/lang/String;"
                                    "Lcom/sun/star/uno/TypeClass;)V")));
                        code->loadLocalReference(*index);
                        code->instrInvokespecial(
                            rtl::OString(
                                RTL_CONSTASCII_STRINGPARAM(
                                    "com/sun/star/uno/Any")),
                            rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                            rtl::OString(
                                RTL_CONSTASCII_STRINGPARAM(
                                    "(Lcom/sun/star/uno/Type;"
                                    "Ljava/lang/Object;)V")));
                        stack = 6;
                    } else {
                        code->loadLocalReference(*index);
                        stack = 1;
                    }
                    size = 1;
                    break;

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

            default:
                OSL_ASSERT(false);
                break;
            }
        } else {
            bool wrap = false;
            if (any) {
                switch (sort) {
                case codemaker::UnoType::SORT_BOOLEAN:
                case codemaker::UnoType::SORT_BYTE:
                case codemaker::UnoType::SORT_SHORT:
                case codemaker::UnoType::SORT_LONG:
                case codemaker::UnoType::SORT_HYPER:
                case codemaker::UnoType::SORT_FLOAT:
                case codemaker::UnoType::SORT_DOUBLE:
                case codemaker::UnoType::SORT_CHAR:
                case codemaker::UnoType::SORT_STRING:
                case codemaker::UnoType::SORT_TYPE:
                        // assuming that no Java types are derived from
                        // com.sun.star.uno.Type
                    break;

                case codemaker::UnoType::SORT_UNSIGNED_SHORT:
                case codemaker::UnoType::SORT_UNSIGNED_LONG:
                case codemaker::UnoType::SORT_UNSIGNED_HYPER:
                case codemaker::UnoType::SORT_ANY:
                    wrap = true;
                    break;

                case codemaker::UnoType::SORT_COMPLEX:
                    switch (typeClass) {
                    case RT_TYPE_ENUM:
                            // assuming that no Java types are derived from Java
                            // types that are directly derived from
                            // com.sun.star.uno.Enum
                        break;

                    case RT_TYPE_STRUCT:
                    case RT_TYPE_INTERFACE:
                        wrap = true;
                        break;

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

                default:
                    OSL_ASSERT(false);
                    break;
                }
            }
            if (wrap) {
                code->instrNew(
                    rtl::OString(
                        RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Any")));
                code->instrDup();
                code->instrNew(
                    rtl::OString(
                        RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Type")));
                code->instrDup();
                code->loadStringConstant(
                    createUnoName(manager, nucleus, rank, args));
                code->instrInvokespecial(
                    rtl::OString(
                        RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Type")),
                    rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                    rtl::OString(
                        RTL_CONSTASCII_STRINGPARAM("(Ljava/lang/String;)V")));
                code->loadLocalReference(*index);
                code->instrInvokespecial(
                    rtl::OString(
                        RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Any")),
                    rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                    rtl::OString(
                        RTL_CONSTASCII_STRINGPARAM(
                            "(Lcom/sun/star/uno/Type;Ljava/lang/Object;)V")));
                stack = 5;
            } else {
                code->loadLocalReference(*index);
                stack = 1;
            }
            size = 1;
        }
    }
    if (*index > SAL_MAX_UINT16 - size) {
        throw CannotDumpException(
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM(
                    "Too many local variables for Java class file format")));
    }
    *index = *index + size;
    return stack;
}

void addBaseArguments(
    TypeManager const & manager, Dependencies * dependencies,
    MethodDescriptor * methodDescriptor, ClassFile::Code * code,
    RTTypeClass typeClass, rtl::OString const & type, sal_uInt16 * index)
{
    OSL_ASSERT(
        dependencies != 0 && methodDescriptor != 0 && code != 0 && index != 0);
    typereg::Reader reader(manager.getTypeReader(type));
    if (!reader.isValid() || reader.getTypeClass() != typeClass
        || codemaker::convertString(reader.getTypeName()) != type
        || reader.getMethodCount() != 0 || reader.getReferenceCount() != 0)
    {
        throw CannotDumpException(
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("Bad type information")));
            //TODO
    }
    sal_uInt16 superTypes = reader.getSuperTypeCount();
    sal_uInt16 fields = reader.getFieldCount();
    sal_uInt16 firstField = 0;
    if (type
        == rtl::OString(
            RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Exception")))
    {
        if (typeClass != RT_TYPE_EXCEPTION || superTypes != 0 || fields != 2) {
            throw CannotDumpException(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
        }
        firstField = 1;
    } else {
        if (
            (typeClass == RT_TYPE_STRUCT && (superTypes > 1 || fields == 0)) ||
            (typeClass == RT_TYPE_EXCEPTION && superTypes != 1)
           )
        {
            throw CannotDumpException(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
        }
        if (superTypes == 1) {
            addBaseArguments(
                manager, dependencies, methodDescriptor, code, typeClass,
                codemaker::convertString(reader.getSuperTypeName(0)), index);
        }
    }
    for (sal_uInt16 i = firstField; i < fields; ++i) {
        if (reader.getFieldFlags(i) != RT_ACCESS_READWRITE
            || reader.getFieldValue(i).m_type != RT_TYPE_NONE)
        {
            throw CannotDumpException(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
        }
        rtl::OString fieldType(
            codemaker::convertString(reader.getFieldTypeName(i)));
        methodDescriptor->addParameter(fieldType, false, true, 0);
        addLoadLocal(
            manager, code, index, false, fieldType, false, dependencies);
    }
}

sal_uInt16 addDirectArgument(
    TypeManager const & manager, Dependencies * dependencies,
    MethodDescriptor * methodDescriptor, ClassFile::Code * code,
    sal_uInt16 * index, rtl::OString const & className,
    rtl::OString const & fieldName, bool typeParameter,
    rtl::OString const & fieldType)
{
    OSL_ASSERT(
        dependencies != 0 && methodDescriptor != 0 && code != 0 && index != 0);
    rtl::OString desc;
    if (typeParameter) {
        methodDescriptor->addTypeParameter(fieldType);
        desc = rtl::OString(RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Object;"));
    } else {
        methodDescriptor->addParameter(fieldType, false, true, 0);
        getFieldDescriptor(manager, dependencies, fieldType, &desc, 0, 0);
    }
    code->loadLocalReference(0);
    sal_uInt16 stack = addLoadLocal(
        manager, code, index, typeParameter, fieldType, false, dependencies);
    code->instrPutfield(className, fieldName, desc);
    return stack + 1;
}

void handleAggregatingType(
    TypeManager const & manager, JavaOptions /*TODO const*/ & options,
    typereg::Reader const & reader, Dependencies * dependencies)
{
    OSL_ASSERT(dependencies != 0);
    if (reader.getMethodCount() != 0)
    {
        throw CannotDumpException(
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("Bad type information")));
            //TODO
    }
    RTTypeClass typeClass = reader.getTypeClass();
    rtl::OString className(codemaker::convertString(reader.getTypeName()));
    sal_uInt16 superTypes = reader.getSuperTypeCount();
    sal_uInt16 fields = reader.getFieldCount();
    sal_uInt16 firstField = 0;
    sal_uInt16 references = reader.getReferenceCount();
    bool runtimeException = false;
    rtl::OString superClass;
    if (className
        == rtl::OString(
            RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Exception")))
    {
        if (typeClass != RT_TYPE_EXCEPTION || superTypes != 0 || fields != 2
            || references != 0)
        {
            throw CannotDumpException(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
        }
        firstField = 1;
        superClass = rtl::OString(
            RTL_CONSTASCII_STRINGPARAM("java/lang/Exception"));
    } else if (className
               == rtl::OString(
                   RTL_CONSTASCII_STRINGPARAM(
                       "com/sun/star/uno/RuntimeException")))
    {
        if (typeClass != RT_TYPE_EXCEPTION || superTypes != 1 || fields != 0
            || references != 0)
        {
            throw CannotDumpException(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
        }
        superTypes = 0;
        superClass = rtl::OString(
            RTL_CONSTASCII_STRINGPARAM("java/lang/RuntimeException"));
        runtimeException = true;
    } else {
        if (
             (
              typeClass == RT_TYPE_STRUCT && 
              (
               fields == 0 ||
               (references == 0 ? superTypes > 1 : superTypes != 0)
              )
             ) ||
             (typeClass == RT_TYPE_EXCEPTION && superTypes != 1)
           )
        {
            throw CannotDumpException(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
        }
        if (superTypes == 0) {
            superClass = rtl::OString(
                RTL_CONSTASCII_STRINGPARAM("java/lang/Object"));
        } else {
            superClass = codemaker::convertString(reader.getSuperTypeName(0));
            dependencies->insert(superClass);
        }
    }
    rtl::OString sig;
    std::map< rtl::OString, sal_Int32 > typeParameters;
    if (references != 0) {
        rtl::OStringBuffer buf;
        buf.append('<');
        for (sal_uInt16 i = 0; i < references; ++i) {
            if (reader.getReferenceFlags(i) != RT_ACCESS_INVALID
                || reader.getReferenceSort(i) != RT_REF_TYPE_PARAMETER)
            {
                throw CannotDumpException(
                    rtl::OString(
                        RTL_CONSTASCII_STRINGPARAM("Bad type information")));
                    //TODO
            }
            rtl::OString name(
                codemaker::convertString(reader.getReferenceTypeName(i)));
            buf.append(name);
            buf.append(RTL_CONSTASCII_STRINGPARAM(":Ljava/lang/Object;"));
            if (!typeParameters.insert(
                    std::map< rtl::OString, sal_Int32 >::value_type(name, i)).
                second)
            {
                throw CannotDumpException(
                    rtl::OString(
                        RTL_CONSTASCII_STRINGPARAM("Bad type information")));
                    //TODO
            }
        }
        buf.append(RTL_CONSTASCII_STRINGPARAM(">Ljava/lang/Object;"));
        sig = buf.makeStringAndClear();
    }
    std::auto_ptr< ClassFile > cf(
        new ClassFile(
            static_cast< ClassFile::AccessFlags >(
                ClassFile::ACC_PUBLIC | ClassFile::ACC_SUPER),
            className, superClass, sig));
    std::vector< TypeInfo > typeInfo;
    {for (sal_uInt16 i = firstField; i < fields; ++i) {
        RTFieldAccess flags = reader.getFieldFlags(i);
        if ((flags != RT_ACCESS_READWRITE
             && flags != (RT_ACCESS_READWRITE | RT_ACCESS_PARAMETERIZED_TYPE))
            || ((flags & RT_ACCESS_PARAMETERIZED_TYPE) != 0 && references == 0)
            || reader.getFieldValue(i).m_type != RT_TYPE_NONE)
        {
            throw CannotDumpException(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
        }
        rtl::OString type(
            codemaker::convertString(reader.getFieldTypeName(i)));
        sal_Int32 typeParameterIndex;
        if ((flags & RT_ACCESS_PARAMETERIZED_TYPE) == 0) {
            typeParameterIndex = -1;
        } else {
            std::map< rtl::OString, sal_Int32 >::iterator it(
                typeParameters.find(type));
            if (it == typeParameters.end()) {
                throw CannotDumpException(
                    rtl::OString(
                        RTL_CONSTASCII_STRINGPARAM("Bad type information")));
                    //TODO
            }
            typeParameterIndex = it->second;
        }
        addField(
            manager, dependencies, cf.get(), &typeInfo, typeParameterIndex,
            type, codemaker::convertString(reader.getFieldName(i)), i - firstField);
    }}
    if (runtimeException) {
        addField(
            manager, dependencies, cf.get(), &typeInfo, -1,
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/XInterface")),
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("Context")), 0);
    }
    std::auto_ptr< ClassFile::Code > code(cf->newCode());
    code->loadLocalReference(0);
    code->instrInvokespecial(
        superClass, rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("()V")));
    sal_uInt16 stack = 0;
    {for (sal_uInt16 i = firstField; i < fields; ++i) {
        stack = std::max(
            stack,
            addFieldInit(
                manager, className,
                codemaker::convertString(reader.getFieldName(i)),
                (reader.getFieldFlags(i) & RT_ACCESS_PARAMETERIZED_TYPE) != 0,
                codemaker::convertString(reader.getFieldTypeName(i)),
                dependencies, code.get()));
    }}
    if (runtimeException) {
        stack = std::max(
            stack,
            addFieldInit(
                manager, className,
                rtl::OString(RTL_CONSTASCII_STRINGPARAM("Context")), false,
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/XInterface")),
                dependencies, code.get()));
    }
    code->instrReturn();
    code->setMaxStackAndLocals(stack + 1, 1);
    cf->addMethod(
        ClassFile::ACC_PUBLIC,
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("()V")), code.get(),
        std::vector< rtl::OString >(), rtl::OString());
    if (typeClass == RT_TYPE_EXCEPTION) {
        code.reset(cf->newCode());
        code->loadLocalReference(0);
        code->loadLocalReference(1);
        code->instrInvokespecial(
            superClass, rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("(Ljava/lang/String;)V")));
        stack = 0;
        for (sal_uInt16 i = firstField; i < fields; ++i) {
            stack = std::max(
                stack,
                addFieldInit(
                    manager, className,
                    codemaker::convertString(reader.getFieldName(i)),
                    ((reader.getFieldFlags(i) & RT_ACCESS_PARAMETERIZED_TYPE)
                     != 0),
                    codemaker::convertString(reader.getFieldTypeName(i)),
                    dependencies, code.get()));
        }
        if (runtimeException) {
            stack = std::max(
                stack,
                addFieldInit(
                    manager, className,
                    rtl::OString(RTL_CONSTASCII_STRINGPARAM("Context")), false,
                    rtl::OString(
                        RTL_CONSTASCII_STRINGPARAM(
                            "com/sun/star/uno/XInterface")),
                    dependencies, code.get()));
        }
        code->instrReturn();
        code->setMaxStackAndLocals(stack + 2, 2);
        cf->addMethod(
            ClassFile::ACC_PUBLIC,
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("(Ljava/lang/String;)V")),
            code.get(), std::vector< rtl::OString >(), rtl::OString());
    }
    MethodDescriptor desc(
        manager, dependencies, rtl::OString(RTL_CONSTASCII_STRINGPARAM("void")),
        0, 0);
    code.reset(cf->newCode());
    code->loadLocalReference(0);
    sal_uInt16 index = 1;
    if (typeClass == RT_TYPE_EXCEPTION) {
        desc.addParameter(
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("string")), false, true, 0);
        code->loadLocalReference(index++);
    }
    if (superTypes != 0) {
        addBaseArguments(
            manager, dependencies, &desc, code.get(), typeClass, superClass,
            &index);
    }
    code->instrInvokespecial(
        superClass, rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
        desc.getDescriptor());
    sal_uInt16 maxSize = index;
    {for (sal_uInt16 i = firstField; i < fields; ++i) {
        maxSize = std::max(
            maxSize,
            addDirectArgument(
                manager, dependencies, &desc, code.get(), &index, className,
                codemaker::convertString(reader.getFieldName(i)),
                (reader.getFieldFlags(i) & RT_ACCESS_PARAMETERIZED_TYPE) != 0,
                codemaker::convertString(reader.getFieldTypeName(i))));
    }}
    if (runtimeException) {
        maxSize = std::max(
            maxSize,
            addDirectArgument(
                manager, dependencies, &desc, code.get(), &index, className,
                rtl::OString(RTL_CONSTASCII_STRINGPARAM("Context")), false,
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "com/sun/star/uno/XInterface"))));
    }
    code->instrReturn();
    code->setMaxStackAndLocals(maxSize, index);
    cf->addMethod(
        ClassFile::ACC_PUBLIC,
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
        desc.getDescriptor(), code.get(), std::vector< rtl::OString >(),
        desc.getSignature());
    addTypeInfo(className, typeInfo, dependencies, cf.get());
    writeClassFile(options, className, *cf.get());
}

void createExceptionsAttribute(
    TypeManager const & manager, typereg::Reader const & reader,
    sal_uInt16 methodIndex, Dependencies * dependencies,
    std::vector< rtl::OString > * exceptions, codemaker::ExceptionTree * tree)
{
    OSL_ASSERT(dependencies != 0 && exceptions != 0);
    sal_uInt16 n = reader.getMethodExceptionCount(methodIndex);
    for (sal_uInt16 i = 0; i < n; ++i) {
        rtl::OString type(
            codemaker::convertString(
                reader.getMethodExceptionTypeName(methodIndex, i)));
        dependencies->insert(type);
        exceptions->push_back(type);
        if (tree != 0) {
            tree->add(type, manager);
        }
    }
}

void handleInterfaceType(
    TypeManager const & manager, JavaOptions /*TODO const*/ & options,
    typereg::Reader const & reader, Dependencies * dependencies)
{
    OSL_ASSERT(dependencies != 0);

    rtl::OString className(codemaker::convertString(reader.getTypeName()));
    sal_uInt16 superTypes = reader.getSuperTypeCount();
    sal_uInt16 fields = reader.getFieldCount();
    sal_uInt16 methods = reader.getMethodCount();
    if (className
        == rtl::OString(
            RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/XInterface")))
    {
        if (superTypes != 0 || fields != 0 || methods != 3) {
            throw CannotDumpException(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
        }
        methods = 0;
    } else if (superTypes == 0) {
        throw CannotDumpException(
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("Bad type information")));
            //TODO
    }
    std::auto_ptr< ClassFile > cf(
        new ClassFile(
            static_cast< ClassFile::AccessFlags >(
                ClassFile::ACC_PUBLIC | ClassFile::ACC_INTERFACE
                | ClassFile::ACC_ABSTRACT),
            className,
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("java/lang/Object")),
            rtl::OString()));
    {for (sal_uInt16 i = 0; i < superTypes; ++i) {
        rtl::OString t(codemaker::convertString(reader.getSuperTypeName(i)));
        dependencies->insert(t);
        cf->addInterface(t);
    }}
    // As a special case, let com.sun.star.lang.XEventListener extend
    // java.util.EventListener ("A tagging interface that all event listener
    // interfaces must extend"):
    if (className ==
        rtl::OString(
            RTL_CONSTASCII_STRINGPARAM("com/sun/star/lang/XEventListener")))
    {
        cf->addInterface(
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM("java/util/EventListener")));
    }
    std::vector< TypeInfo > typeInfo;
    sal_Int32 index = 0;
    {for (sal_uInt16 i = 0; i < fields; ++i) {
        RTFieldAccess flags = reader.getFieldFlags(i);
        //TODO: ok if both READONLY and BOUND?
        if (((((flags & RT_ACCESS_READWRITE) != 0)
              ^ ((flags & RT_ACCESS_READONLY) != 0))
             == 0)
            || ((flags
                 & ~(RT_ACCESS_READWRITE | RT_ACCESS_READONLY
                     | RT_ACCESS_BOUND))
                != 0)
            || reader.getFieldValue(i).m_type != RT_TYPE_NONE)
        {
            throw CannotDumpException(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
        }
        //TODO: exploit the fact that attribute getter/setter methods precede
        // real methods
        rtl::OUString attrNameUtf16(reader.getFieldName(i));
        sal_uInt16 getter = SAL_MAX_UINT16;
        sal_uInt16 setter = SAL_MAX_UINT16;
        for (sal_uInt16 j = 0; j < methods; ++j) {
            RTMethodMode mflags = reader.getMethodFlags(j);
            if ((mflags == RT_MODE_ATTRIBUTE_GET
                 || mflags == RT_MODE_ATTRIBUTE_SET)
                && reader.getMethodName(j) == attrNameUtf16)
            {
                if (!reader.getMethodReturnTypeName(j).equalsAsciiL(
                        RTL_CONSTASCII_STRINGPARAM("void"))
                    || reader.getMethodParameterCount(j) != 0
                    || (mflags == RT_MODE_ATTRIBUTE_GET
                        ? getter != SAL_MAX_UINT16
                        : (setter != SAL_MAX_UINT16
                           || (flags & RT_ACCESS_READONLY) != 0)))
                {
                    throw CannotDumpException(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM(
                                "Bad type information"))); //TODO
                }
                OSL_ASSERT(j != SAL_MAX_UINT16);
                (mflags == RT_MODE_ATTRIBUTE_GET ? getter : setter) = j;
            }
        }
        rtl::OString fieldType(
            codemaker::convertString(reader.getFieldTypeName(i)));
        SpecialType specialType;
        PolymorphicUnoType polymorphicUnoType;
        MethodDescriptor gdesc(
            manager, dependencies, fieldType, &specialType,
            &polymorphicUnoType);
        std::vector< rtl::OString > exc;
        if (getter != SAL_MAX_UINT16) {
            createExceptionsAttribute(
                manager, reader, getter, dependencies, &exc, 0);
        }
        rtl::OString attrName(codemaker::convertString(attrNameUtf16));
        cf->addMethod(
            static_cast< ClassFile::AccessFlags >(
                ClassFile::ACC_PUBLIC | ClassFile::ACC_ABSTRACT),
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("get")) + attrName,
            gdesc.getDescriptor(), 0, exc, gdesc.getSignature());
        if ((flags & RT_ACCESS_READONLY) == 0) {
            MethodDescriptor sdesc(
                manager, dependencies,
                rtl::OString(RTL_CONSTASCII_STRINGPARAM("void")), 0, 0);
            sdesc.addParameter(fieldType, false, true, 0);
            std::vector< rtl::OString > exc2;
            if (setter != SAL_MAX_UINT16) {
                createExceptionsAttribute(
                    manager, reader, setter, dependencies, &exc2, 0);
            }
            cf->addMethod(
                static_cast< ClassFile::AccessFlags >(
                    ClassFile::ACC_PUBLIC | ClassFile::ACC_ABSTRACT),
                rtl::OString(RTL_CONSTASCII_STRINGPARAM("set")) + attrName,
                sdesc.getDescriptor(), 0, exc2, sdesc.getSignature());
        }
        typeInfo.push_back(
            TypeInfo(
                TypeInfo::KIND_ATTRIBUTE, attrName, specialType,
                static_cast< TypeInfo::Flags >(
                    ((flags & RT_ACCESS_READONLY) == 0
                     ? 0 : TypeInfo::FLAG_READONLY)
                    | ((flags & RT_ACCESS_BOUND) == 0
                       ? 0 : TypeInfo::FLAG_BOUND)),
                index, polymorphicUnoType));
        index += ((flags & RT_ACCESS_READONLY) == 0 ? 2 : 1);
    }}
    {for (sal_uInt16 i = 0; i < methods; ++i) {
        RTMethodMode flags = reader.getMethodFlags(i);
        switch (flags) {
        case RT_MODE_ONEWAY:
        case RT_MODE_TWOWAY:
            {
                rtl::OString methodName(
                    codemaker::convertString(reader.getMethodName(i)));
                SpecialType specialReturnType;
                PolymorphicUnoType polymorphicUnoReturnType;
                MethodDescriptor desc(
                    manager, dependencies,
                    codemaker::convertString(
                        reader.getMethodReturnTypeName(i)),
                    &specialReturnType, &polymorphicUnoReturnType);
                typeInfo.push_back(
                    TypeInfo(
                        TypeInfo::KIND_METHOD, methodName, specialReturnType,
                        static_cast< TypeInfo::Flags >(
                            flags == RT_MODE_ONEWAY
                            ? TypeInfo::FLAG_ONEWAY : 0),
                        index++, polymorphicUnoReturnType));
                for (sal_uInt16 j = 0; j < reader.getMethodParameterCount(i);
                     ++j)
                {
                    bool in;
                    bool out;
                    switch (reader.getMethodParameterFlags(i, j)) {
                    case RT_PARAM_IN:
                        in = true;
                        out = false;
                        break;

                    case RT_PARAM_OUT:
                        in = false;
                        out = true;
                        break;

                    case RT_PARAM_INOUT:
                        in = true;
                        out = true;
                        break;

                    default:
                        throw CannotDumpException(
                            rtl::OString(
                                RTL_CONSTASCII_STRINGPARAM(
                                    "Bad type information"))); //TODO
                    }
                    PolymorphicUnoType polymorphicUnoType;
                    SpecialType specialType = desc.addParameter(
                        codemaker::convertString(
                            reader.getMethodParameterTypeName(i, j)),
                        out, true, &polymorphicUnoType);
                    if (out || isSpecialType(specialType)
                        || (polymorphicUnoType.kind
                            != PolymorphicUnoType::KIND_NONE))
                    {
                        typeInfo.push_back(
                            TypeInfo(
                                codemaker::convertString(
                                    reader.getMethodParameterName(i, j)),
                                specialType, in, out, methodName, j,
                                polymorphicUnoType));
                    }
                }
                std::vector< rtl::OString > exc2;
                createExceptionsAttribute(
                    manager, reader, i, dependencies, &exc2, 0);
                cf->addMethod(
                    static_cast< ClassFile::AccessFlags >(
                        ClassFile::ACC_PUBLIC | ClassFile::ACC_ABSTRACT),
                    methodName, desc.getDescriptor(), 0, exc2,
                    desc.getSignature());
                break;
            }

        case RT_MODE_ATTRIBUTE_GET:
        case RT_MODE_ATTRIBUTE_SET:
            {
                //TODO: exploit the fact that attribute getter/setter methods
                // are ordered the same way as the attribute fields themselves
                rtl::OUString methodNameUtf16(reader.getMethodName(i));
                bool found = false;
                for (sal_uInt16 j = 0; j < fields; ++j) {
                    if (reader.getFieldName(j) == methodNameUtf16) {
                        found = true;
                        break;
                    }
                }
                if (found) {
                    break;
                }
            }
        default:
            throw CannotDumpException(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
        }
    }}
    addTypeInfo(className, typeInfo, dependencies, cf.get());
    writeClassFile(options, className, *cf.get());
}

void handleTypedef(
    TypeManager const & manager, JavaOptions /*TODO const*/ &,
    typereg::Reader const & reader, Dependencies * dependencies)
{
    OSL_ASSERT(dependencies != 0);
    if (reader.getSuperTypeCount() != 1 || reader.getFieldCount() != 0
        || reader.getMethodCount() != 0 || reader.getReferenceCount() != 0)
    {
        throw CannotDumpException(
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("Bad type information")));
            //TODO
    }
    RTTypeClass typeClass;
    rtl::OString nucleus;
    sal_Int32 rank;
    std::vector< rtl::OString > args;
    if (codemaker::decomposeAndResolve(
            manager, codemaker::convertString(reader.getSuperTypeName(0)),
            false, false, false, &typeClass, &nucleus, &rank, &args)
        == codemaker::UnoType::SORT_COMPLEX)
    {
        switch (typeClass) {
        case RT_TYPE_STRUCT:
            if (!args.empty()) {
                throw CannotDumpException(
                    rtl::OString(
                        RTL_CONSTASCII_STRINGPARAM("Bad type information")));
                    //TODO
            }
        case RT_TYPE_ENUM:
        case RT_TYPE_INTERFACE:
        case RT_TYPE_TYPEDEF:
            dependencies->insert(nucleus);
            break;

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

void addConstant(
    TypeManager const & manager, typereg::Reader const & reader,
    bool publishable, sal_uInt16 index, Dependencies * dependencies,
    ClassFile * classFile)
{
    OSL_ASSERT(dependencies != 0 && classFile != 0);
    RTFieldAccess flags = reader.getFieldFlags(index);
    if (flags != RT_ACCESS_CONST
        && (!publishable || flags != (RT_ACCESS_CONST | RT_ACCESS_PUBLISHED)))
    {
        throw CannotDumpException(
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("Bad type information")));
            //TODO
    }
    RTConstValue fieldValue(reader.getFieldValue(index));
    sal_uInt16 valueIndex;
    RTTypeClass typeClass;
    rtl::OString nucleus;
    sal_Int32 rank;
    std::vector< rtl::OString > args;
    switch (codemaker::decomposeAndResolve(
                manager,
                codemaker::convertString(reader.getFieldTypeName(index)),
                true, false, false, &typeClass, &nucleus, &rank, &args))
    {
    case codemaker::UnoType::SORT_BOOLEAN:
        if (fieldValue.m_type != RT_TYPE_BOOL) {
            throw CannotDumpException(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
        }
        valueIndex = classFile->addIntegerInfo(fieldValue.m_value.aBool);
        break;

    case codemaker::UnoType::SORT_BYTE:
        if (fieldValue.m_type != RT_TYPE_BYTE) {
            throw CannotDumpException(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
        }
        valueIndex = classFile->addIntegerInfo(fieldValue.m_value.aByte);
        break;

    case codemaker::UnoType::SORT_SHORT:
        if (fieldValue.m_type != RT_TYPE_INT16) {
            throw CannotDumpException(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
        }
        valueIndex = classFile->addIntegerInfo(fieldValue.m_value.aShort);
        break;

    case codemaker::UnoType::SORT_UNSIGNED_SHORT:
    case codemaker::UnoType::SORT_CHAR:
        if (fieldValue.m_type != RT_TYPE_UINT16) {
            throw CannotDumpException(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
        }
        valueIndex = classFile->addIntegerInfo(fieldValue.m_value.aUShort);
        break;

    case codemaker::UnoType::SORT_LONG:
        if (fieldValue.m_type != RT_TYPE_INT32) {
            throw CannotDumpException(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
        }
        valueIndex = classFile->addIntegerInfo(fieldValue.m_value.aLong);
        break;

    case codemaker::UnoType::SORT_UNSIGNED_LONG:
        if (fieldValue.m_type != RT_TYPE_UINT32) {
            throw CannotDumpException(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
        }
        valueIndex = classFile->addIntegerInfo(
            static_cast< sal_Int32 >(fieldValue.m_value.aULong));
        break;

    case codemaker::UnoType::SORT_HYPER:
        if (fieldValue.m_type != RT_TYPE_INT64) {
            throw CannotDumpException(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
        }
        valueIndex = classFile->addLongInfo(fieldValue.m_value.aHyper);
        break;

    case codemaker::UnoType::SORT_UNSIGNED_HYPER:
        if (fieldValue.m_type != RT_TYPE_UINT64) {
            throw CannotDumpException(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
        }
        valueIndex = classFile->addLongInfo(
            static_cast< sal_Int64 >(fieldValue.m_value.aUHyper));
        break;

    case codemaker::UnoType::SORT_FLOAT:
        if (fieldValue.m_type != RT_TYPE_FLOAT) {
            throw CannotDumpException(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
        }
        valueIndex = classFile->addFloatInfo(fieldValue.m_value.aFloat);
        break;

    case codemaker::UnoType::SORT_DOUBLE:
        if (fieldValue.m_type != RT_TYPE_DOUBLE) {
            throw CannotDumpException(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
        }
        valueIndex = classFile->addDoubleInfo(fieldValue.m_value.aDouble);
        break;

    default:
        throw CannotDumpException(
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("Bad type information")));
            //TODO
    }
    rtl::OString desc;
    rtl::OString sig;
    getFieldDescriptor(
        manager, dependencies,
        codemaker::convertString(reader.getFieldTypeName(index)),
        &desc, &sig, 0);
    classFile->addField(
        static_cast< ClassFile::AccessFlags >(
            ClassFile::ACC_PUBLIC | ClassFile::ACC_STATIC
            | ClassFile::ACC_FINAL),
        codemaker::convertString(reader.getFieldName(index)),
        desc, valueIndex, sig);
}

void handleConstantGroup(
    TypeManager const & manager, JavaOptions /*TODO const*/ & options,
    typereg::Reader const & reader, Dependencies * dependencies)
{
    OSL_ASSERT(dependencies != 0);
    if (reader.getSuperTypeCount() != 0 || reader.getMethodCount() != 0
        || reader.getReferenceCount() != 0)
    {
        throw CannotDumpException(
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("Bad type information")));
            //TODO
    }
    rtl::OString className(codemaker::convertString(reader.getTypeName()));
    std::auto_ptr< ClassFile > cf(
        new ClassFile(
            static_cast< ClassFile::AccessFlags >(
                ClassFile::ACC_PUBLIC | ClassFile::ACC_INTERFACE
                | ClassFile::ACC_ABSTRACT),
            className,
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("java/lang/Object")),
            rtl::OString()));
    sal_uInt16 fields = reader.getFieldCount();
    for (sal_uInt16 i = 0; i < fields; ++i) {
        addConstant(manager, reader, false, i, dependencies, cf.get());
    }
    writeClassFile(options, className, *cf.get());
}

void handleModule(
    TypeManager const & manager, JavaOptions /*TODO const*/ & options,
    typereg::Reader const & reader, Dependencies * dependencies)
{
    OSL_ASSERT(dependencies != 0);
    if (reader.getSuperTypeCount() != 0 || reader.getMethodCount() != 0
        || reader.getReferenceCount() != 0)
    {
        throw CannotDumpException(
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("Bad type information")));
            //TODO
    }
    rtl::OStringBuffer buf(codemaker::convertString(reader.getTypeName()));
    buf.append('/');
    rtl::OString prefix(buf.makeStringAndClear());
    sal_uInt16 fields = reader.getFieldCount();
    for (sal_uInt16 i = 0; i < fields; ++i) {
        rtl::OString className(
            prefix + codemaker::convertString(reader.getFieldName(i)));
        std::auto_ptr< ClassFile > cf(
            new ClassFile(
                static_cast< ClassFile::AccessFlags >(
                    ClassFile::ACC_PUBLIC | ClassFile::ACC_INTERFACE
                    | ClassFile::ACC_ABSTRACT),
                className,
                rtl::OString(RTL_CONSTASCII_STRINGPARAM("java/lang/Object")),
                rtl::OString()));
        addConstant(manager, reader, true, i, dependencies, cf.get());
        writeClassFile(options, className, *cf.get());
    }
}

void addExceptionHandlers(
    codemaker::ExceptionTreeNode const * node,
    ClassFile::Code::Position start, ClassFile::Code::Position end,
    ClassFile::Code::Position handler, ClassFile::Code * code)
{
    OSL_ASSERT(node != 0 && code != 0);
    if (node->present) {
        code->addException(start, end, handler, node->name);
    } else {
        for (codemaker::ExceptionTreeNode::Children::const_iterator i(
                 node->children.begin());
             i != node->children.end(); ++i)
        {
            addExceptionHandlers(*i, start, end, handler, code);
        }
    }
}

void addConstructor(
    TypeManager const & manager, rtl::OString const & realJavaBaseName,
    rtl::OString const & unoName, rtl::OString const & className,
    typereg::Reader const & reader, sal_uInt16 methodIndex,
    rtl::OString const & methodName, rtl::OString const & returnType,
    bool defaultConstructor, Dependencies * dependencies, ClassFile * classFile)
{
    OSL_ASSERT(dependencies != 0 && classFile != 0);
    MethodDescriptor desc(manager, dependencies, returnType, 0, 0);
    desc.addParameter(
        rtl::OString(
            RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/XComponentContext")),
        false, false, 0);
    std::auto_ptr< ClassFile::Code > code(classFile->newCode());
    code->loadLocalReference(0);
    // stack: context
    code->instrInvokestatic(
        className, rtl::OString(RTL_CONSTASCII_STRINGPARAM("$getFactory")),
        rtl::OString(
            RTL_CONSTASCII_STRINGPARAM(
                "(Lcom/sun/star/uno/XComponentContext;)"
                "Lcom/sun/star/lang/XMultiComponentFactory;")));
    // stack: factory
    code->loadStringConstant(unoName);
    // stack: factory serviceName
    codemaker::ExceptionTree tree;
    ClassFile::Code::Position tryStart;
    ClassFile::Code::Position tryEnd;
    std::vector< rtl::OString > exc;
    sal_uInt16 stack;
    sal_uInt16 localIndex = 1;
    ClassFile::AccessFlags access = static_cast< ClassFile::AccessFlags >(
        ClassFile::ACC_PUBLIC | ClassFile::ACC_STATIC);
    if (defaultConstructor) {
        code->loadLocalReference(0);
        // stack: factory serviceName context
        tryStart = code->getPosition();
        code->instrInvokeinterface(
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM(
                    "com/sun/star/lang/XMultiComponentFactory")),
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM(
                    "createInstanceWithContext")),
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM(
                    "(Ljava/lang/String;Lcom/sun/star/uno/XComponentContext;)"
                    "Ljava/lang/Object;")),
            3);
        tryEnd = code->getPosition();
        // stack: instance
        stack = 3;
    } else {
        sal_uInt16 parameters = reader.getMethodParameterCount(methodIndex);
        if (parameters == 1
            && (reader.getMethodParameterFlags(methodIndex, 0)
                == (RT_PARAM_IN | RT_PARAM_REST))
            && (reader.getMethodParameterTypeName(methodIndex, 0)
                == rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("any"))))
        {
            desc.addParameter(
                rtl::OString(RTL_CONSTASCII_STRINGPARAM("any")), true, true, 0);
            code->loadLocalReference(localIndex++);
            // stack: factory serviceName args
            stack = 4;
            access = static_cast< ClassFile::AccessFlags >(
                access | ClassFile::ACC_VARARGS);
        } else {
            code->loadIntegerConstant(parameters);
            // stack: factory serviceName N
            code->instrAnewarray(
                rtl::OString(RTL_CONSTASCII_STRINGPARAM("java/lang/Object")));
            // stack: factory serviceName args
            stack = 0;
            for (sal_uInt16 i = 0; i < parameters; ++i) {
                RTParamMode flags = reader.getMethodParameterFlags(
                    methodIndex, i);
                rtl::OString paramType(
                    codemaker::convertString(
                        reader.getMethodParameterTypeName(methodIndex, i)));
                if ((flags != RT_PARAM_IN
                     && flags != (RT_PARAM_IN | RT_PARAM_REST))
                    || ((flags & RT_PARAM_REST) != 0
                        && (parameters != 1
                            || (paramType
                                != rtl::OString(
                                    RTL_CONSTASCII_STRINGPARAM("any"))))))
                {
                    throw CannotDumpException(
                        rtl::OString(
                            RTL_CONSTASCII_STRINGPARAM(
                                "Bad type information"))); //TODO
                }
                desc.addParameter(paramType, false, true, 0);
                code->instrDup();
                // stack: factory serviceName args args
                code->loadIntegerConstant(i);
                // stack: factory serviceName args args i
                stack = std::max(
                    stack,
                    addLoadLocal(
                        manager, code.get(), &localIndex, false, paramType,
                        true, dependencies));
                // stack: factory serviceName args args i any
                code->instrAastore();
                // stack: factory serviceName args
            }
            stack += 5;
        }
        code->loadLocalReference(0);
        // stack: factory serviceName args context
        tryStart = code->getPosition();
        code->instrInvokeinterface(
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM(
                    "com/sun/star/lang/XMultiComponentFactory")),
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM(
                    "createInstanceWithArgumentsAndContext")),
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM(
                    "(Ljava/lang/String;[Ljava/lang/Object;"
                    "Lcom/sun/star/uno/XComponentContext;)Ljava/lang/Object;")),
            4);
        tryEnd = code->getPosition();
        // stack: instance
        createExceptionsAttribute(
            manager, reader, methodIndex, dependencies, &exc, &tree);
    }
    code->loadLocalReference(0);
    // stack: instance context
    code->instrInvokestatic(
        className, rtl::OString(RTL_CONSTASCII_STRINGPARAM("$castInstance")),
        rtl::OString(
            RTL_CONSTASCII_STRINGPARAM(
                "(Ljava/lang/Object;Lcom/sun/star/uno/XComponentContext;)"
                "Ljava/lang/Object;")));
    // stack: instance
    code->instrCheckcast(returnType);
    // stack: instance
    code->instrAreturn();
    if (!tree.getRoot()->present) {
        ClassFile::Code::Position pos1 = code->getPosition();
        // stack: e
        code->instrInvokevirtual(
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("java/lang/Throwable")),
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("toString")),
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("()Ljava/lang/String;")));
        // stack: str
        localIndex = std::max< sal_uInt16 >(localIndex, 2);
        code->storeLocalReference(1);
        // stack: -
        code->instrNew(
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM(
                    "com/sun/star/uno/DeploymentException")));
        // stack: ex
        code->instrDup();
        // stack: ex ex
        rtl::OStringBuffer msg;
        msg.append(
            RTL_CONSTASCII_STRINGPARAM(
                "component context fails to supply service "));
        msg.append(unoName);
        msg.append(RTL_CONSTASCII_STRINGPARAM(" of type "));
        msg.append(realJavaBaseName);
        msg.append(RTL_CONSTASCII_STRINGPARAM(": "));
        code->loadStringConstant(msg.makeStringAndClear());
        // stack: ex ex "..."
        code->loadLocalReference(1);
        // stack: ex ex "..." str
        code->instrInvokevirtual(
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("java/lang/String")),
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("concat")),
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM(
                    "(Ljava/lang/String;)Ljava/lang/String;")));
        // stack: ex ex "..."
        code->loadLocalReference(0);
        // stack: ex ex "..." context
        code->instrInvokespecial(
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM(
                    "com/sun/star/uno/DeploymentException")),
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM(
                    "(Ljava/lang/String;Ljava/lang/Object;)V")));
        // stack: ex
        ClassFile::Code::Position pos2 = code->getPosition();
        code->instrAthrow();
        addExceptionHandlers(
            tree.getRoot(), tryStart, tryEnd, pos2, code.get());
        code->addException(
            tryStart, tryEnd, pos1,
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Exception")));
        dependencies->insert(
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Exception")));
        stack = std::max< sal_uInt16 >(stack, 4);
    }
    code->setMaxStackAndLocals(stack, localIndex);
    classFile->addMethod(
        access, methodName, desc.getDescriptor(), code.get(), exc,
        desc.getSignature());
}

void handleService(
    TypeManager const & manager, JavaOptions /*TODO const*/ & options,
    typereg::Reader const & reader, Dependencies * dependencies)
{
    OSL_ASSERT(dependencies != 0);
    sal_uInt16 superTypes = reader.getSuperTypeCount();
    sal_uInt16 methods = reader.getMethodCount();
    if (superTypes == 0
        ? methods != 0
        : (superTypes != 1 || reader.getFieldCount() != 0
           || reader.getReferenceCount() != 0))
    {
        throw CannotDumpException(
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("Bad type information")));
            //TODO
    }
    if (superTypes == 0) {
        return;
    }
    rtl::OString unoName(codemaker::convertString(reader.getTypeName()));
    rtl::OString className(
        translateUnoTypeToJavaFullyQualifiedName(
            unoName, rtl::OString(RTL_CONSTASCII_STRINGPARAM("service"))));
    unoName = unoName.replace('/', '.');
    std::auto_ptr< ClassFile > cf(
        new ClassFile(
            static_cast< ClassFile::AccessFlags >(
                ClassFile::ACC_PUBLIC | ClassFile::ACC_FINAL
                | ClassFile::ACC_SUPER),
            className,
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("java/lang/Object")),
            rtl::OString()));
    if (methods > 0) {
        rtl::OString base(codemaker::convertString(
                              reader.getSuperTypeName(0)));
        rtl::OString realJavaBaseName(base.replace('/', '.'));
        dependencies->insert(base);
        dependencies->insert(
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM(
                    "com/sun/star/lang/XMultiComponentFactory")));
        dependencies->insert(
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM(
                    "com/sun/star/uno/DeploymentException")));
        dependencies->insert(
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/TypeClass")));
        dependencies->insert(
            rtl::OString(
                RTL_CONSTASCII_STRINGPARAM(
                    "com/sun/star/uno/XComponentContext")));
        for (sal_uInt16 i = 0; i < methods; ++i) {
            rtl::OString name(codemaker::convertString(
                                  reader.getMethodName(i)));
            bool defaultCtor = name.isEmpty();
            if (reader.getMethodFlags(i) != RT_MODE_TWOWAY
                || (!reader.getMethodReturnTypeName(i).equalsAsciiL(
                        RTL_CONSTASCII_STRINGPARAM("void")))
                || (defaultCtor
                    && (methods != 1 || reader.getMethodParameterCount(i) != 0
                        || reader.getMethodExceptionCount(i) != 0)))
            {
                throw CannotDumpException(
                    rtl::OString(
                        RTL_CONSTASCII_STRINGPARAM("Bad type information")));
                    //TODO
            }
            if (defaultCtor) {
                name = rtl::OString(RTL_CONSTASCII_STRINGPARAM("create"));
            } else {
                name = codemaker::java::translateUnoToJavaIdentifier(
                    name, rtl::OString(RTL_CONSTASCII_STRINGPARAM("method")));
            }
            addConstructor(
                manager, realJavaBaseName, unoName, className, reader, i, name,
                base, defaultCtor, dependencies, cf.get());
        }
        // Synthetic getFactory method:
        {
            std::auto_ptr< ClassFile::Code > code(cf->newCode());
            code->loadLocalReference(0);
            // stack: context
            code->instrInvokeinterface(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "com/sun/star/uno/XComponentContext")),
                rtl::OString(RTL_CONSTASCII_STRINGPARAM("getServiceManager")),
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "()Lcom/sun/star/lang/XMultiComponentFactory;")),
                1);
            // stack: factory
            code->instrDup();
            // stack: factory factory
            ClassFile::Code::Branch branch = code->instrIfnull();
            // stack: factory
            code->instrAreturn();
            code->branchHere(branch);
            code->instrPop();
            // stack: -
            code->instrNew(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "com/sun/star/uno/DeploymentException")));
            // stack: ex
            code->instrDup();
            // stack: ex ex
            code->loadStringConstant(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "component context fails to supply service manager")));
            // stack: ex ex "..."
            code->loadLocalReference(0);
            // stack: ex ex "..." context
            code->instrInvokespecial(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "com/sun/star/uno/DeploymentException")),
                rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "(Ljava/lang/String;Ljava/lang/Object;)V")));
            // stack: ex
            code->instrAthrow();
            code->setMaxStackAndLocals(4, 1);
            cf->addMethod(
                static_cast< ClassFile::AccessFlags >(
                    ClassFile::ACC_PRIVATE | ClassFile::ACC_STATIC
                    | ClassFile::ACC_SYNTHETIC),
                rtl::OString(RTL_CONSTASCII_STRINGPARAM("$getFactory")),
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "(Lcom/sun/star/uno/XComponentContext;)"
                        "Lcom/sun/star/lang/XMultiComponentFactory;")),
                code.get(), std::vector< rtl::OString >(), rtl::OString());
        }
        // Synthetic castInstance method:
        {
            std::auto_ptr< ClassFile::Code > code(cf->newCode());
            code->instrNew(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Type")));
            // stack: type
            code->instrDup();
            // stack: type type
            code->loadStringConstant(realJavaBaseName);
            // stack: type type "..."
            code->instrGetstatic(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/TypeClass")),
                rtl::OString(RTL_CONSTASCII_STRINGPARAM("INTERFACE")),
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "Lcom/sun/star/uno/TypeClass;")));
            // stack: type type "..." INTERFACE
            code->instrInvokespecial(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Type")),
                rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "(Ljava/lang/String;Lcom/sun/star/uno/TypeClass;)V")));
            // stack: type
            code->loadLocalReference(0);
            // stack: type instance
            code->instrInvokestatic(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/UnoRuntime")),
                rtl::OString(RTL_CONSTASCII_STRINGPARAM("queryInterface")),
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "(Lcom/sun/star/uno/Type;Ljava/lang/Object;)"
                        "Ljava/lang/Object;")));
            // stack: instance
            code->instrDup();
            // stack: instance instance
            ClassFile::Code::Branch branch = code->instrIfnull();
            // stack: instance
            code->instrAreturn();
            code->branchHere(branch);
            code->instrPop();
            // stack: -
            code->instrNew(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "com/sun/star/uno/DeploymentException")));
            // stack: ex
            code->instrDup();
            // stack: ex ex
            rtl::OStringBuffer msg;
            msg.append(
                RTL_CONSTASCII_STRINGPARAM(
                    "component context fails to supply service "));
            msg.append(unoName);
            msg.append(RTL_CONSTASCII_STRINGPARAM(" of type "));
            msg.append(realJavaBaseName);
            code->loadStringConstant(msg.makeStringAndClear());
            // stack: ex ex "..."
            code->loadLocalReference(1);
            // stack: ex ex "..." context
            code->instrInvokespecial(
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "com/sun/star/uno/DeploymentException")),
                rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "(Ljava/lang/String;Ljava/lang/Object;)V")));
            // stack: ex
            code->instrAthrow();
            code->setMaxStackAndLocals(4, 2);
            cf->addMethod(
                static_cast< ClassFile::AccessFlags >(
                    ClassFile::ACC_PRIVATE | ClassFile::ACC_STATIC
                    | ClassFile::ACC_SYNTHETIC),
                rtl::OString(RTL_CONSTASCII_STRINGPARAM("$castInstance")),
                rtl::OString(
                    RTL_CONSTASCII_STRINGPARAM(
                        "(Ljava/lang/Object;Lcom/sun/star/uno/"
                        "XComponentContext;)Ljava/lang/Object;")),
                code.get(), std::vector< rtl::OString >(), rtl::OString());
        }
    }
    writeClassFile(options, className, *cf.get());
}

void handleSingleton(
    TypeManager const & manager, JavaOptions /*TODO const*/ & options,
    typereg::Reader const & reader, Dependencies * dependencies)
{
    OSL_ASSERT(dependencies != 0);
    if (reader.getSuperTypeCount() != 1 || reader.getFieldCount() != 0
        || reader.getMethodCount() != 0 || reader.getReferenceCount() != 0)
    {
        throw CannotDumpException(
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("Bad type information")));
            //TODO
    }
    rtl::OString base(codemaker::convertString(reader.getSuperTypeName(0)));
    rtl::OString realJavaBaseName(base.replace('/', '.'));
    switch (manager.getTypeReader(base).getTypeClass()) {
    case RT_TYPE_INTERFACE:
        break;

    case RT_TYPE_SERVICE:
        return;

    default:
        throw CannotDumpException(
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("Bad type information")));
            //TODO
    }
    dependencies->insert(base);
    rtl::OString unoName(codemaker::convertString(reader.getTypeName()));
    rtl::OString className(
        translateUnoTypeToJavaFullyQualifiedName(
            unoName, rtl::OString(RTL_CONSTASCII_STRINGPARAM("singleton"))));
    unoName = unoName.replace('/', '.');
    dependencies->insert(
        rtl::OString(
            RTL_CONSTASCII_STRINGPARAM(
                "com/sun/star/uno/DeploymentException")));
    dependencies->insert(
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/TypeClass")));
    dependencies->insert(
        rtl::OString(
            RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/XComponentContext")));
    std::auto_ptr< ClassFile > cf(
        new ClassFile(
            static_cast< ClassFile::AccessFlags >(
                ClassFile::ACC_PUBLIC | ClassFile::ACC_FINAL
                | ClassFile::ACC_SUPER),
            className,
            rtl::OString(RTL_CONSTASCII_STRINGPARAM("java/lang/Object")),
            rtl::OString()));
    MethodDescriptor desc(manager, dependencies, base, 0, 0);
    desc.addParameter(
        rtl::OString(
            RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/XComponentContext")),
        false, false, 0);
    std::auto_ptr< ClassFile::Code > code(cf->newCode());
    code->loadLocalReference(0);
    // stack: context
    code->loadStringConstant(
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("/singletons/")) + unoName);
    // stack: context "..."
    code->instrInvokeinterface(
        rtl::OString(
            RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/XComponentContext")),
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("getValueByName")),
        rtl::OString(
            RTL_CONSTASCII_STRINGPARAM(
                "(Ljava/lang/String;)Ljava/lang/Object;")),
        2);
    // stack: value
    code->instrDup();
    // stack: value value
    code->instrInstanceof(
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Any")));
    // stack: value 0/1
    ClassFile::Code::Branch branch1 = code->instrIfeq();
    // stack: value
    code->instrCheckcast(
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Any")));
    // stack: value
    code->instrDup();
    // stack: value value
    code->instrInvokevirtual(
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Any")),
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("getType")),
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("()Lcom/sun/star/uno/Type;")));
    // stack: value type
    code->instrInvokevirtual(
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Type")),
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("getTypeClass")),
        rtl::OString(
            RTL_CONSTASCII_STRINGPARAM("()Lcom/sun/star/uno/TypeClass;")));
    // stack: value typeClass
    code->instrGetstatic(
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/TypeClass")),
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("INTERFACE")),
        rtl::OString(
            RTL_CONSTASCII_STRINGPARAM("Lcom/sun/star/uno/TypeClass;")));
    // stack: value typeClass INTERFACE
    ClassFile::Code::Branch branch2 = code->instrIfAcmpne();
    // stack: value
    code->instrInvokevirtual(
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Any")),
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("getObject")),
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("()Ljava/lang/Object;")));
    // stack: value
    code->branchHere(branch1);
    code->instrNew(
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Type")));
    // stack: value type
    code->instrDup();
    // stack: value type type
    code->loadStringConstant(realJavaBaseName);
    // stack: value type type "..."
    code->instrGetstatic(
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/TypeClass")),
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("INTERFACE")),
        rtl::OString(
            RTL_CONSTASCII_STRINGPARAM("Lcom/sun/star/uno/TypeClass;")));
    // stack: value type type "..." INTERFACE
    code->instrInvokespecial(
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Type")),
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
        rtl::OString(
            RTL_CONSTASCII_STRINGPARAM(
                "(Ljava/lang/String;Lcom/sun/star/uno/TypeClass;)V")));
    // stack: value type
    code->instrSwap();
    // stack: type value
    code->instrInvokestatic(
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/UnoRuntime")),
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("queryInterface")),
        rtl::OString(
            RTL_CONSTASCII_STRINGPARAM(
                "(Lcom/sun/star/uno/Type;Ljava/lang/Object;)"
                "Ljava/lang/Object;")));
    // stack: instance
    code->instrDup();
    // stack: instance instance
    ClassFile::Code::Branch branch3 = code->instrIfnull();
    // stack: instance
    code->instrCheckcast(base);
    // stack: instance
    code->instrAreturn();
    code->branchHere(branch2);
    code->branchHere(branch3);
    code->instrPop();
    // stack: -
    code->instrNew(
        rtl::OString(
            RTL_CONSTASCII_STRINGPARAM(
                "com/sun/star/uno/DeploymentException")));
    // stack: ex
    code->instrDup();
    // stack: ex ex
    rtl::OStringBuffer msg;
    msg.append(
        RTL_CONSTASCII_STRINGPARAM(
            "component context fails to supply singleton "));
    msg.append(unoName);
    msg.append(RTL_CONSTASCII_STRINGPARAM(" of type "));
    msg.append(realJavaBaseName);
    code->loadStringConstant(msg.makeStringAndClear());
    // stack: ex ex "..."
    code->loadLocalReference(0);
    // stack: ex ex "..." context
    code->instrInvokespecial(
        rtl::OString(
            RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/DeploymentException")),
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
        rtl::OString(
            RTL_CONSTASCII_STRINGPARAM(
                "(Ljava/lang/String;Ljava/lang/Object;)V")));
    // stack: ex
    code->instrAthrow();
    code->setMaxStackAndLocals(5, 1);
    cf->addMethod(
        static_cast< ClassFile::AccessFlags >(
            ClassFile::ACC_PUBLIC | ClassFile::ACC_STATIC),
        rtl::OString(RTL_CONSTASCII_STRINGPARAM("get")), desc.getDescriptor(),
        code.get(), std::vector< rtl::OString >(), desc.getSignature());
    writeClassFile(options, className, *cf.get());
}

}

bool produceType(
    rtl::OString const & type, TypeManager const & manager,
    codemaker::GeneratedTypeSet & generated, JavaOptions * options)
{
    OSL_ASSERT(options != 0);
    if (type.equals("/")
        || type.equals(manager.getBase())
        || generated.contains(type))
    {
        return true;
    }
    sal_Bool extra = sal_False;
    typereg::Reader reader(manager.getTypeReader(type, &extra));
    if (extra) {
        generated.add(type);
        return true;
    }
    if (!reader.isValid()) {
        return false;
    }

    handleUnoTypeRegistryEntityFunction handler;
    switch (reader.getTypeClass()) {
    case RT_TYPE_ENUM:
        handler = handleEnumType;
        break;

    case RT_TYPE_STRUCT:
    case RT_TYPE_EXCEPTION:
        handler = handleAggregatingType;
        break;

    case RT_TYPE_INTERFACE:
        handler = handleInterfaceType;
        break;

    case RT_TYPE_TYPEDEF:
        handler = handleTypedef;
        break;

    case RT_TYPE_CONSTANTS:
        handler = handleConstantGroup;
        break;

    case RT_TYPE_MODULE:
        handler = handleModule;
        break;

    case RT_TYPE_SERVICE:
        handler = handleService;
        break;

    case RT_TYPE_SINGLETON:
        handler = handleSingleton;
        break;

    default:
        return false;
    }
    Dependencies deps;
    handler(manager, *options, reader, &deps);
    generated.add(type);
    if (!options->isValid(rtl::OString(RTL_CONSTASCII_STRINGPARAM("-nD")))) {
        for (Dependencies::iterator i(deps.begin()); i != deps.end(); ++i) {
            if (!produceType(*i, manager, generated, options)) {
                return false;
            }
        }
    }
    return true;
}

bool produceType(
    RegistryKey & rTypeKey, bool bIsExtraType, TypeManager const & manager,
    codemaker::GeneratedTypeSet & generated, JavaOptions * options)
{
    ::rtl::OString typeName = manager.getTypeName(rTypeKey);
    
    OSL_ASSERT(options != 0);
    if (typeName.equals("/")
        || typeName.equals(manager.getBase())
        || generated.contains(typeName))
    {
        return true;
    }
    typereg::Reader reader(manager.getTypeReader(rTypeKey));
    if (bIsExtraType) {
        generated.add(typeName);
        return true;
    }
    if (!reader.isValid()) {
        return false;
    }
    handleUnoTypeRegistryEntityFunction handler;
    switch (reader.getTypeClass()) {
    case RT_TYPE_ENUM:
        handler = handleEnumType;
        break;

    case RT_TYPE_STRUCT:
    case RT_TYPE_EXCEPTION:
        handler = handleAggregatingType;
        break;

    case RT_TYPE_INTERFACE:
        handler = handleInterfaceType;
        break;

    case RT_TYPE_TYPEDEF:
        handler = handleTypedef;
        break;

    case RT_TYPE_CONSTANTS:
        handler = handleConstantGroup;
        break;

    case RT_TYPE_MODULE:
        handler = handleModule;
        break;

    case RT_TYPE_SERVICE:
        handler = handleService;
        break;

    case RT_TYPE_SINGLETON:
        handler = handleSingleton;
        break;

    default:
        return false;
    }
    Dependencies deps;
    handler(manager, *options, reader, &deps);
    generated.add(typeName);
    if (!options->isValid(rtl::OString(RTL_CONSTASCII_STRINGPARAM("-nD")))) {
        for (Dependencies::iterator i(deps.begin()); i != deps.end(); ++i) {
            if (!produceType(*i, manager, generated, options)) {
                return false;
            }
        }
    }
    return true;
}