diff options
Diffstat (limited to 'unodevtools/source/skeletonmaker/javatypemaker.cxx')
-rw-r--r-- | unodevtools/source/skeletonmaker/javatypemaker.cxx | 707 |
1 files changed, 707 insertions, 0 deletions
diff --git a/unodevtools/source/skeletonmaker/javatypemaker.cxx b/unodevtools/source/skeletonmaker/javatypemaker.cxx new file mode 100644 index 000000000000..5b8ed625741d --- /dev/null +++ b/unodevtools/source/skeletonmaker/javatypemaker.cxx @@ -0,0 +1,707 @@ +/************************************************************************* + * + * $RCSfile: javatypemaker.cxx,v $ + * + * $Revision: 1.1 $ + * + * last change: $Author: jsc $ $Date: 2005-08-23 08:30:21 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (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.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#include "skeletonjava.hxx" + +namespace skeletonmaker { namespace java { + +void printType(std::ostream & o, + ProgramOptions const & options, TypeManager const & manager, + rtl::OString const & type, bool referenceType, + bool defaultvalue); + +void printType(std::ostream & o, + ProgramOptions const & options, TypeManager const & manager, + codemaker::UnoType::Sort sort, RTTypeClass typeClass, + rtl::OString const & name, sal_Int32 rank, + std::vector< rtl::OString > const & arguments, bool referenceType, + bool defaultvalue) +{ + if (defaultvalue && rank == 0 && sort <= codemaker::UnoType::SORT_CHAR) { + switch (sort) { + case codemaker::UnoType::SORT_BOOLEAN: + o << "false"; + return; + case codemaker::UnoType::SORT_CHAR: + case codemaker::UnoType::SORT_BYTE: + case codemaker::UnoType::SORT_SHORT: + case codemaker::UnoType::SORT_UNSIGNED_SHORT: + case codemaker::UnoType::SORT_LONG: + case codemaker::UnoType::SORT_UNSIGNED_LONG: + case codemaker::UnoType::SORT_HYPER: + case codemaker::UnoType::SORT_UNSIGNED_HYPER: + case codemaker::UnoType::SORT_FLOAT: + case codemaker::UnoType::SORT_DOUBLE: + o << "0"; + return; + } + } + + if (defaultvalue) { + if (sort == codemaker::UnoType::SORT_COMPLEX) { + o << "null"; + return; + } else + o << "new "; + } + + o << (codemaker::java::translateUnoToJavaType( + sort, typeClass, name, referenceType). + replace('/', '.').getStr()); + if (!arguments.empty() && options.java5) { + o << '<'; + for (std::vector< rtl::OString >::const_iterator i(arguments.begin()); + i != arguments.end(); ++i) + { + if (i != arguments.begin()) { + o << ", "; + } + printType(o, options, manager, *i, true, defaultvalue); + } + o << '>'; + } + for (sal_Int32 i = 0; i < rank; ++i) { + if (defaultvalue) + o << "[0]"; + else + o << "[]"; + } + + if (defaultvalue && sort > codemaker::UnoType::SORT_CHAR && rank == 0) + o << "()"; +} + +void printType(std::ostream & o, + ProgramOptions const & options, TypeManager const & manager, + rtl::OString const & type, bool referenceType, bool defaultvalue) +{ + RTTypeClass typeClass; + rtl::OString name; + sal_Int32 rank; + std::vector< rtl::OString > arguments; + codemaker::UnoType::Sort sort = codemaker::decomposeAndResolve( + manager, type, true, true, true, &typeClass, &name, &rank, &arguments); + printType(o, + options, manager, sort, typeClass, name, rank, arguments, + referenceType, defaultvalue); +} + +bool printConstructorParameters(std::ostream & o, + ProgramOptions const & options, TypeManager const & manager, + typereg::Reader const & reader, typereg::Reader const & outerReader, + std::vector< rtl::OString > const & arguments) +{ + bool previous = false; + if (reader.getSuperTypeCount() != 0) { + rtl::OString super( + codemaker::convertString(reader.getSuperTypeName(0))); + typereg::Reader superReader(manager.getTypeReader(super)); + if (!superReader.isValid()) { + throw CannotDumpException("Bad type library entity " + super); + } + previous = printConstructorParameters(o, + options, manager, superReader, outerReader, arguments); + } + for (sal_uInt16 i = 0; i < reader.getFieldCount(); ++i) { + if (previous) { + o << ", "; + } + previous = true; + if ((reader.getFieldFlags(i) & RT_ACCESS_PARAMETERIZED_TYPE) == 0) { + printType(o, + options, manager, + codemaker::convertString(reader.getFieldTypeName(i)), + false); + } else if (arguments.empty()) { + o << "java.lang.Object"; + } else { + sal_uInt16 tparam = 0; + while (outerReader.getReferenceTypeName(tparam) + != reader.getFieldTypeName(i)) + { + ++tparam; + OSL_ASSERT(tparam < outerReader.getReferenceCount()); + } + // assume std::vector< rtl::OString >::size_type is at least as + // large as sal_uInt16: + printType(o, options, manager, arguments[tparam], true); + } + o + << ' ' + << (codemaker::java::translateUnoToJavaIdentifier( + codemaker::convertString(reader.getFieldName(i)), + "param"). + getStr()); + } + return previous; +} + +void printConstructor(std::ostream & o, + ProgramOptions const & options, TypeManager const & manager, + typereg::Reader const & reader, + std::vector< rtl::OString > const & arguments) +{ + rtl::OString type(codemaker::convertString(reader.getTypeName())); + o << "public " << type.copy(type.lastIndexOf('/') + 1) << '('; + printConstructorParameters(o, options, manager, reader, reader, arguments); + o << ");\n"; +} + +void printMethodParameters(std::ostream & o, + ProgramOptions const & options, TypeManager const & manager, + typereg::Reader const & reader, sal_uInt16 method, bool previous, + bool withtype, bool shortname) +{ + for (sal_uInt16 i = 0; i < reader.getMethodParameterCount(method); ++i) { + if (previous) { + o << ", "; + } + previous = true; + if (withtype) { + printType(o, options, manager, + codemaker::convertString( + reader.getMethodParameterTypeName(method, i)), + false); + if (reader.getMethodParameterFlags(method, i) == RT_PARAM_OUT + || reader.getMethodParameterFlags(method, i) == RT_PARAM_INOUT) + { + o << "[]"; + } else if ((reader.getMethodParameterFlags(method, i) & RT_PARAM_REST) + != 0) + { + o << (options.java5 ? "..." : "[]"); + } + } + o << ' ' + << (codemaker::java::translateUnoToJavaIdentifier( + codemaker::convertString( + reader.getMethodParameterName(method, i)), + "param"). + getStr()); + } +} + +void printExceptionSpecification(std::ostream & o, + ProgramOptions const & options, TypeManager const & manager, + typereg::Reader const & reader, sal_uInt16 method) +{ + if (reader.getMethodExceptionCount(method) > 0) { + o << " throws "; + for (sal_uInt16 i = 0; i < reader.getMethodExceptionCount(method); ++i) + { + if (i != 0) { + o << ", "; + } + printType(o, + options, manager, + codemaker::convertString( + reader.getMethodExceptionTypeName(method, i)), + false); + } + } +} + +void printMethods(std::ostream & o, + ProgramOptions const & options, TypeManager const & manager, + typereg::Reader const & reader, codemaker::GeneratedTypeSet & generated, + rtl::OString const & delegate, rtl::OString const & indentation, + bool defaultvalue) +{ + rtl::OString type(codemaker::convertString(reader.getTypeName())); + if (generated.contains(type) || type == "com/sun/star/uno/XInterface" || + (defaultvalue && + ( type.equals("com/sun/star/lang/XComponent") || + type.equals("com/sun/star/lang/XTypeProvider") || + type.equals("com/sun/star/uno/XWeak")) ) ) { + return; + } + + static rtl::OString sd(RTL_CONSTASCII_STRINGPARAM("_")); + bool body = ((delegate.getLength() > 0) ? true : false); + bool defaultbody = ((delegate.equals(sd)) ? true : false); + + generated.add(type); + if (options.all || defaultvalue) { + for (sal_uInt16 i = 0; i < reader.getSuperTypeCount(); ++i) { + typereg::Reader super( + manager.getTypeReader( + codemaker::convertString( + reader.getSuperTypeName(i)))); + if (!super.isValid()) { + throw CannotDumpException( + "Bad type library entity " + + codemaker::convertString( + reader.getSuperTypeName(i))); + } + printMethods(o, options, manager, super, generated, delegate, + indentation, defaultvalue); + } + if (reader.getFieldCount() > 0 || reader.getMethodCount() > 0) { + o << indentation << "/* "; + printType(o, options, manager, type, false); + o << ": */\n"; + } + } + sal_uInt16 method = 0; + for (sal_uInt16 i = 0; i < reader.getFieldCount(); ++i) { + o << indentation << "public "; + printType(o, + options, manager, + codemaker::convertString(reader.getFieldTypeName(i)), false); + o << " get" + << codemaker::convertString(reader.getFieldName(i)).getStr() + << "()"; + if (method < reader.getMethodCount() + && reader.getMethodFlags(method) == RT_MODE_ATTRIBUTE_GET + && reader.getMethodName(method) == reader.getFieldName(i)) + { + printExceptionSpecification(o, options, manager, reader, method++); + } + if (body) { + if (defaultbody) { + o << "\n" << indentation << "{\n" << indentation << " return "; + printType(o, + options, manager, + codemaker::convertString(reader.getFieldTypeName(i)), + false, defaultvalue); + o << ";\n" << indentation << "}\n\n"; + } else { + o << "\n" << indentation << " { return " + << delegate.getStr() << "get" + << codemaker::convertString(reader.getFieldName(i)).getStr() + << "();\n" << indentation << "}\n\n"; + } + } else { + o << ";\n"; + } + + // REMOVE next line + rtl::OUString tmp = reader.getFieldName(i); + if ((reader.getFieldFlags(i) & RT_ACCESS_READONLY) == 0) { + o << indentation << "public void set" + << (codemaker::convertString(reader.getFieldName(i)). + getStr()) + << '('; + printType(o, + options, manager, + codemaker::convertString(reader.getFieldTypeName(i)), + false); + o << " the_value)"; + if (method < reader.getMethodCount() + && reader.getMethodFlags(method) == RT_MODE_ATTRIBUTE_SET + && reader.getMethodName(method) == reader.getFieldName(i)) + { + printExceptionSpecification(o, options, manager, reader, method++); + } + if (body) { + if (defaultbody) { + o << "\n" << indentation << "{\n\n" << indentation << "}\n\n"; + } else { + o << "\n" << indentation << " { " + << delegate.getStr() << "set" + << codemaker::convertString(reader.getFieldName(i)).getStr() + << "(the_value);\n" << indentation << "}"; + } + } else { + o << ";\n"; + } + } + } + for (; method < reader.getMethodCount(); ++method) { + o << indentation << "public "; + printType(o, + options, manager, + codemaker::convertString( + reader.getMethodReturnTypeName(method)), + false); + o << ' ' + << (codemaker::convertString(reader.getMethodName(method)). + getStr()) + << '('; + printMethodParameters(o, options, manager, reader, method, false, true); + o << ')'; + printExceptionSpecification(o, options, manager, reader, method); + if (body) { + static rtl::OUString s(RTL_CONSTASCII_USTRINGPARAM("void")); + if (defaultbody) { + o << "\n" << indentation << "{\n"; + if (!reader.getMethodReturnTypeName(method).equals(s)) { + o << indentation << " return "; + printType(o, + options, manager, + codemaker::convertString( + reader.getMethodReturnTypeName(method)), + false, defaultvalue); + o << ";"; + } + o << "\n" << indentation << "}\n\n"; + } else { + o << "\n" << indentation << " { "; + if (!reader.getMethodReturnTypeName(method).equals(s)) + o << "return "; + o << delegate.getStr() + << (codemaker::convertString( + reader.getMethodName(method)).getStr()) + << '('; + printMethodParameters(o, options, manager, reader, method, + false, false); + o << ");\n" << indentation << "}\n"; + } + } else + o << ";\n"; + } +} + +void printConstructionMethods(std::ostream & o, + ProgramOptions const & options, TypeManager const & manager, + typereg::Reader const & reader) +{ + for (sal_uInt16 i = 0; i < reader.getMethodCount(); ++i) { + o << "public static "; + printType(o, + options, manager, + codemaker::convertString(reader.getSuperTypeName(0)), false); + o << ' '; + if (reader.getMethodName(i).getLength() == 0) { + o << "create"; + } else { + o + << (codemaker::java::translateUnoToJavaIdentifier( + codemaker::convertString(reader.getMethodName(i)), + "method"). + getStr()); + } + o << '('; + printMethodParameters(o, options, manager, reader, i, false, true); + o << ')'; + printExceptionSpecification(o, options, manager, reader, i); + o << ";\n"; + } +} + +void generateDocumentation(std::ostream & o, + ProgramOptions const & options, TypeManager const & manager, + rtl::OString const & type); + +void printServiceMembers(std::ostream & o, + ProgramOptions const & options, TypeManager const & manager, + typereg::Reader const & reader, rtl::OString const & type) +{ + for (sal_uInt16 i = 0; i < reader.getReferenceCount(); ++i) { + rtl::OString referenceType( + codemaker::convertString( + reader.getReferenceTypeName(i)).replace('/', '.')); + + if ( reader.getReferenceSort(i) == RT_REF_SUPPORTS ) { + o << "\n// supported interface " << referenceType.getStr() << "\n"; + generateDocumentation(o, options, manager, referenceType); + } else if ( reader.getReferenceSort(i) == RT_REF_EXPORTS ) { + o << "\n// exported service " << referenceType.getStr() << "\n"; + generateDocumentation(o, options, manager, referenceType); + } + } + + o << "\n// properties of service \""<< type.getStr() << "\"\n"; + for (sal_uInt16 i = 0; i < reader.getFieldCount(); ++i) { + rtl::OString fieldName( + codemaker::convertString(reader.getFieldName(i))); + rtl::OString fieldType( + codemaker::convertString(reader.getFieldTypeName(i))); + + o << "// private "; + printType(o, options, manager, fieldType, false); + o << " " + << codemaker::java::translateUnoToJavaIdentifier( + fieldName, "property").getStr() + << ";\n"; + } +} + +void printMapsToJavaType(std::ostream & o, + ProgramOptions const & options, TypeManager const & manager, + codemaker::UnoType::Sort sort, RTTypeClass typeClass, + rtl::OString const & name, sal_Int32 rank, + std::vector< rtl::OString > const & arguments, const char * javaTypeSort) +{ + o << "maps to Java " << (options.java5 ? "1.5" : "1.4") << " "; + if (javaTypeSort != 0) { + o << javaTypeSort << ' '; + } + o << "type \""; + if (rank == 0 && name == "com/sun/star/uno/XInterface") { + o << "com.sun.star.uno.XInterface"; + } else { + printType(o, + options, manager, sort, typeClass, name, rank, arguments, false); + } + o << '"'; +} + +void generateDocumentation(std::ostream & o, + ProgramOptions const & options, TypeManager const & manager, + rtl::OString const & type) +{ + if (type.indexOf('/') >= 0) { + throw CannotDumpException("Illegal type name " + type); + } + rtl::OString binType(type.replace('.', '/')); + RTTypeClass typeClass; + rtl::OString name; + sal_Int32 rank; + std::vector< rtl::OString > arguments; + codemaker::UnoType::Sort sort = decomposeResolveAndCheck( + manager, binType, false, true, true, &typeClass, &name, &rank, + &arguments); + o << "\n// UNO"; + if (rank > 0) { + o << " sequence type"; + } else if (sort != codemaker::UnoType::SORT_COMPLEX) { + o << " simple type"; + } else { + typereg::Reader reader(manager.getTypeReader(name)); + if (!reader.isValid()) { + throw CannotDumpException("Bad type library entity " + name); + } + switch (typeClass) { + case RT_TYPE_INTERFACE: + o << " interface type"; + break; + + case RT_TYPE_MODULE: + o << "IDL module"; + break; + + case RT_TYPE_STRUCT: + if (reader.getReferenceCount() == 0) { + o << " simple struct type"; + } else if (arguments.empty()) { + o << " polymorphic struct type template"; + } else { + o << " instantiated polymorphic struct type"; + } + break; + + case RT_TYPE_ENUM: + o << " enum type"; + break; + + case RT_TYPE_EXCEPTION: + o << " exception type"; + break; + + case RT_TYPE_TYPEDEF: + o << "IDL typedef"; + break; + + case RT_TYPE_SERVICE: + if (reader.getSuperTypeCount() > 0) { + o << " single-inheritance--based service"; + } else { + o << "IDL accumulation-based service"; + } + break; + + case RT_TYPE_SINGLETON: + if ((manager.getTypeReader( + codemaker::convertString( + reader.getSuperTypeName(0))). + getTypeClass()) + == RT_TYPE_INTERFACE) + { + o << " inheritance-based singleton"; + } else { + o << "IDL service-based singleton"; + } + break; + + case RT_TYPE_CONSTANTS: + o << "IDL constant group"; + break; + + default: + OSL_ASSERT(false); + break; + } + } + o << " \"" << type.getStr() << "\" "; + sort = codemaker::decomposeAndResolve( + manager, binType, true, true, true, &typeClass, &name, &rank, + &arguments); + if (rank > 0) { + printMapsToJavaType(o, + options, manager, sort, typeClass, name, rank, arguments, "array"); + o << '\n'; + } else if (sort != codemaker::UnoType::SORT_COMPLEX) { + printMapsToJavaType(o, + options, manager, sort, typeClass, name, rank, arguments, 0); + o << '\n'; + } else { + typereg::Reader reader(manager.getTypeReader(name)); + if (!reader.isValid()) { + throw CannotDumpException("Bad type library entity " + name); + } + switch (typeClass) { + case RT_TYPE_INTERFACE: + printMapsToJavaType(o, + options, manager, sort, typeClass, name, rank, arguments, + "interface"); + if (name == "com/sun/star/uno/XInterface") { + o << '\n'; + } else { + o + << "; " << (options.all ? "all" : "direct") + << " methods:\n"; + codemaker::GeneratedTypeSet generated; + printMethods(o, options, manager, reader, generated, + "", "", false); + } + break; + + case RT_TYPE_MODULE: + printMapsToJavaType(o, + options, manager, sort, typeClass, name, rank, arguments, + "package"); + o << '\n'; + break; + + case RT_TYPE_STRUCT: + if (reader.getReferenceCount() == 0) { + printMapsToJavaType(o, + options, manager, sort, typeClass, name, rank, arguments, + "class"); + } else if (arguments.empty()) { + printMapsToJavaType(o, + options, manager, sort, typeClass, name, rank, arguments, + options.java5 ? "generic class" : "class"); + } else { + printMapsToJavaType(o, + options, manager, sort, typeClass, name, rank, arguments, + options.java5 ? "generic class instantiation" : "class"); + } + o << "; full constructor:\n"; + printConstructor(o, options, manager, reader, arguments); + break; + + case RT_TYPE_ENUM: + case RT_TYPE_CONSTANTS: + printMapsToJavaType(o, + options, manager, sort, typeClass, name, rank, arguments, + "class"); + o << '\n'; + break; + + case RT_TYPE_EXCEPTION: + printMapsToJavaType(o, + options, manager, sort, typeClass, name, rank, arguments, + "exception class"); + o << "; full constructor:\n"; + printConstructor(o, options, manager, reader, arguments); + break; + + case RT_TYPE_SERVICE: + if (reader.getSuperTypeCount() > 0) { + printMapsToJavaType(o, + options, manager, sort, typeClass, name, rank, arguments, + "class"); + o << "; construction methods:\n"; + printConstructionMethods(o, options, manager, reader); + + rtl::OString super( + codemaker::convertString( + reader.getSuperTypeName(0)).replace('/', '.')); + + generateDocumentation(o, options, manager, super); + } else { + o << ("does not map to Java\n" + "// the service members are generated instead\n"); + printServiceMembers(o, options, manager, reader, type); + } + break; + + case RT_TYPE_SINGLETON: + if (reader.getSuperTypeCount() > 0 && + ((manager.getTypeReader( + codemaker::convertString( + reader.getSuperTypeName(0))). + getTypeClass()) == RT_TYPE_INTERFACE) ) { + printMapsToJavaType(o, options, manager, sort, typeClass, + name, rank, arguments, "class"); + o << "; get method:\npublic static "; + printType(o, options, manager, + codemaker::convertString(reader.getSuperTypeName(0)), + false); + o + << " get(com.sun.star.uno.XComponentContext context);\n"; + } else { + o << "does not map to Java\n"; + } + break; + + default: + OSL_ASSERT(false); + break; + } + } +} + +} } + + |