LCOV - code coverage report
Current view: top level - libreoffice/unodevtools/source/skeletonmaker - javatypemaker.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 0 437 0.0 %
Date: 2012-12-27 Functions: 0 12 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include "codemaker/commonjava.hxx"
      21             : 
      22             : #include "skeletoncommon.hxx"
      23             : #include "skeletonjava.hxx"
      24             : 
      25             : using namespace ::rtl;
      26             : 
      27             : namespace skeletonmaker { namespace java {
      28             : 
      29             : void printType(std::ostream & o,
      30             :                ProgramOptions const & options, TypeManager const & manager,
      31             :                OString const & type, bool referenceType,
      32             :                bool defaultvalue);
      33             : 
      34           0 : void printType(std::ostream & o,
      35             :                ProgramOptions const & options, TypeManager const & manager,
      36             :                codemaker::UnoType::Sort sort, RTTypeClass typeClass,
      37             :                OString const & name, sal_Int32 rank,
      38             :                std::vector< OString > const & arguments, bool referenceType,
      39             :                bool defaultvalue)
      40             : {
      41           0 :     if ( defaultvalue && rank == 0 && sort <= codemaker::UnoType::SORT_CHAR ) {
      42           0 :         switch (sort)
      43             :         {
      44             :         case codemaker::UnoType::SORT_BOOLEAN:
      45           0 :             o << "false";
      46             :             return;
      47             :         case codemaker::UnoType::SORT_CHAR:
      48             :         case codemaker::UnoType::SORT_BYTE:
      49             :         case codemaker::UnoType::SORT_SHORT:
      50             :         case codemaker::UnoType::SORT_UNSIGNED_SHORT:
      51             :         case codemaker::UnoType::SORT_LONG:
      52             :         case codemaker::UnoType::SORT_UNSIGNED_LONG:
      53             :         case codemaker::UnoType::SORT_HYPER:
      54             :         case codemaker::UnoType::SORT_UNSIGNED_HYPER:
      55             :         case codemaker::UnoType::SORT_FLOAT:
      56             :         case codemaker::UnoType::SORT_DOUBLE:
      57           0 :             o << "0";
      58             :             return;
      59             :         case codemaker::UnoType::SORT_VOID:
      60             :         case codemaker::UnoType::SORT_STRING:
      61             :         case codemaker::UnoType::SORT_TYPE:
      62             :         case codemaker::UnoType::SORT_ANY:
      63             :         case codemaker::UnoType::SORT_COMPLEX:
      64           0 :             break;
      65             :         }
      66             :     }
      67             : 
      68           0 :     if ( defaultvalue ) {
      69           0 :         if ( sort == codemaker::UnoType::SORT_COMPLEX &&
      70             :             typeClass == RT_TYPE_INTERFACE ) {
      71           0 :             o << "null";
      72             :             return;
      73           0 :         } else if ( sort == codemaker::UnoType::SORT_ANY && rank==0 ) {
      74           0 :             o << "com.sun.star.uno.Any.VOID";
      75             :             return;
      76           0 :         } else if ( sort == codemaker::UnoType::SORT_TYPE && rank==0 ) {
      77           0 :             o << "com.sun.star.uno.Type.VOID";
      78             :             return;
      79             :         } else
      80           0 :             if ( typeClass != RT_TYPE_ENUM || rank > 0 )
      81           0 :                 o << "new ";
      82             :     }
      83             : 
      84             :     OString sType(codemaker::java::translateUnoToJavaType(
      85           0 :                       sort, typeClass, name, referenceType && rank==0).replace('/', '.'));
      86           0 :     if ( sType.indexOf("java.lang.") == 0 )
      87           0 :         sType = sType.copy(10);
      88           0 :     o << sType.getStr();
      89           0 :     if ( !arguments.empty() && options.java5 ) {
      90           0 :         o << '<';
      91           0 :         for ( std::vector< OString >::const_iterator i(arguments.begin());
      92           0 :               i != arguments.end(); ++i )
      93             :         {
      94           0 :             if ( i != arguments.begin() ) {
      95           0 :                 o << ", ";
      96             :             }
      97             : 
      98           0 :             printType(o, options, manager, *i, true, false);
      99             :         }
     100           0 :         o << '>';
     101             :     }
     102           0 :     for ( sal_Int32 i = 0; i < rank; ++i ) {
     103           0 :         if ( defaultvalue )
     104           0 :             o << "[0]";
     105             :         else
     106           0 :             o << "[]";
     107             :     }
     108             : 
     109           0 :     if ( defaultvalue && sort > codemaker::UnoType::SORT_CHAR && rank == 0 ) {
     110           0 :         if ( typeClass == RT_TYPE_ENUM )
     111           0 :             o << ".getDefault()";
     112             :         else
     113           0 :             o << "()";
     114           0 :     }
     115             : }
     116             : 
     117           0 : void printType(std::ostream & o,
     118             :     ProgramOptions const & options, TypeManager const & manager,
     119             :     OString const & type, bool referenceType, bool defaultvalue)
     120             : {
     121             :     RTTypeClass typeClass;
     122           0 :     OString name;
     123             :     sal_Int32 rank;
     124           0 :     std::vector< OString > arguments;
     125             :     codemaker::UnoType::Sort sort = codemaker::decomposeAndResolve(
     126           0 :         manager, type, true, true, true, &typeClass, &name, &rank, &arguments);
     127             :     printType(o,
     128             :         options, manager, sort, typeClass, name, rank, arguments,
     129           0 :         referenceType, defaultvalue);
     130           0 : }
     131             : 
     132           0 : bool printConstructorParameters(std::ostream & o,
     133             :     ProgramOptions const & options, TypeManager const & manager,
     134             :     typereg::Reader const & reader, typereg::Reader const & outerReader,
     135             :     std::vector< OString > const & arguments)
     136             : {
     137           0 :     bool previous = false;
     138           0 :     if ( reader.getSuperTypeCount() != 0 ) {
     139             :         OString super(
     140           0 :             codemaker::convertString(reader.getSuperTypeName(0)));
     141           0 :         typereg::Reader superReader(manager.getTypeReader(super));
     142           0 :         if ( !superReader.isValid() ) {
     143           0 :             throw CannotDumpException("Bad type library entity " + super);
     144             :         }
     145             :         previous = printConstructorParameters(o,
     146           0 :             options, manager, superReader, outerReader, arguments);
     147             :     }
     148           0 :     for ( sal_uInt16 i = 0; i < reader.getFieldCount(); ++i ) {
     149           0 :         if ( previous ) {
     150           0 :             o << ", ";
     151             :         }
     152           0 :         previous = true;
     153           0 :         if ( (reader.getFieldFlags(i) & RT_ACCESS_PARAMETERIZED_TYPE) == 0  ) {
     154             :             printType(o,
     155             :                 options, manager,
     156             :                 codemaker::convertString(reader.getFieldTypeName(i)),
     157           0 :                 false);
     158           0 :         } else if ( arguments.empty() ) {
     159           0 :             o << "java.lang.Object";
     160             :         } else {
     161           0 :             sal_uInt16 tparam = 0;
     162           0 :             while ( outerReader.getReferenceTypeName(tparam)
     163           0 :                     != reader.getFieldTypeName(i) )
     164             :             {
     165           0 :                 ++tparam;
     166             :                 OSL_ASSERT(tparam < outerReader.getReferenceCount());
     167             :             }
     168             :             // assume std::vector< OString >::size_type is at least as
     169             :             // large as sal_uInt16:
     170           0 :             printType(o, options, manager, arguments[tparam], true);
     171             :         }
     172             :         o
     173           0 :             << ' '
     174             :             << (codemaker::java::translateUnoToJavaIdentifier(
     175             :                     codemaker::convertString(reader.getFieldName(i)),
     176             :                     "param").
     177           0 :                 getStr());
     178             :     }
     179           0 :     return previous;
     180             : }
     181             : 
     182           0 : void printConstructor(std::ostream & o,
     183             :     ProgramOptions const & options, TypeManager const & manager,
     184             :     typereg::Reader const & reader,
     185             :     std::vector< OString > const & arguments)
     186             : {
     187           0 :     OString type(codemaker::convertString(reader.getTypeName()));
     188           0 :     o << "public " << type.copy(type.lastIndexOf('/') + 1) << '(';
     189           0 :     printConstructorParameters(o, options, manager, reader, reader, arguments);
     190           0 :     o << ");\n";
     191           0 : }
     192             : 
     193           0 : void printMethodParameters(std::ostream & o,
     194             :     ProgramOptions const & options, TypeManager const & manager,
     195             :     typereg::Reader const & reader, sal_uInt16 method, bool previous,
     196             :     bool withtype)
     197             : {
     198           0 :     for ( sal_uInt16 i = 0; i < reader.getMethodParameterCount(method); ++i ) {
     199           0 :         if ( previous  )
     200           0 :             o << ", ";
     201             :         else
     202           0 :             previous = true;
     203             : 
     204           0 :         if ( withtype ) {
     205             :             printType(o, options, manager,
     206             :                       codemaker::convertString(
     207             :                           reader.getMethodParameterTypeName(method, i)),
     208           0 :                       false);
     209           0 :             if ( reader.getMethodParameterFlags(method, i) == RT_PARAM_OUT
     210           0 :                  || reader.getMethodParameterFlags(method, i) == RT_PARAM_INOUT )
     211             :             {
     212           0 :                 o << "[]";
     213           0 :             } else if ( (reader.getMethodParameterFlags(method, i) & RT_PARAM_REST )
     214             :                        != 0)
     215             :             {
     216           0 :                 o << (options.java5 ? "..." : "[]");
     217             :             }
     218           0 :             o << ' ';
     219             :         }
     220             :         o << (codemaker::java::translateUnoToJavaIdentifier(
     221             :                   codemaker::convertString(
     222             :                       reader.getMethodParameterName(method, i)),
     223             :                   "param").
     224           0 :               getStr());
     225             :     }
     226           0 : }
     227             : 
     228           0 : void printExceptionSpecification(std::ostream & o,
     229             :     ProgramOptions const & options, TypeManager const & manager,
     230             :     typereg::Reader const & reader, sal_uInt16 method)
     231             : {
     232           0 :     if ( reader.getMethodExceptionCount(method) > 0 ) {
     233           0 :         o << " throws ";
     234           0 :         for ( sal_uInt16 i = 0; i < reader.getMethodExceptionCount(method); ++i )
     235             :         {
     236           0 :             if ( i != 0 ) {
     237           0 :                 o << ", ";
     238             :             }
     239             :             printType(o,
     240             :                 options, manager,
     241             :                 codemaker::convertString(
     242             :                     reader.getMethodExceptionTypeName(method, i)),
     243           0 :                 false);
     244             :         }
     245             :     }
     246           0 : }
     247             : 
     248             : 
     249           0 : void printSetPropertyMixinBody(std::ostream & o,
     250             :                                typereg::Reader const & reader,
     251             :                                sal_uInt16 field,
     252             :                                sal_uInt16 method,
     253             :                                OString const & indentation)
     254             : {
     255           0 :     RTFieldAccess propFlags = checkAdditionalPropertyFlags(reader, field, method);
     256           0 :     OString fieldname = codemaker::convertString(reader.getFieldName(field));
     257           0 :     bool bound = (reader.getFieldFlags(field) & RT_ACCESS_BOUND ? true : false);
     258             : 
     259           0 :     o << "\n" << indentation << "{\n";
     260             : 
     261           0 :     if ( bound ) {
     262           0 :         o << indentation << "    PropertySetMixin.BoundListeners l = "
     263           0 :             "new PropertySetMixin.BoundListeners();\n\n";
     264             :     }
     265             : 
     266           0 :     o << indentation << "    m_prophlp.prepareSet(\""
     267           0 :       << fieldname << "\", ";
     268           0 :     if ( propFlags & RT_ACCESS_CONSTRAINED ) {
     269           0 :         OString fieldtype = codemaker::convertString(reader.getFieldTypeName(field));
     270             : 
     271           0 :         sal_Int32 index = fieldtype.lastIndexOf('<');
     272           0 :         sal_Int32 nPos=0;
     273           0 :         bool single = true;
     274           0 :         bool optional = false;
     275           0 :         OStringBuffer buffer1(64);
     276           0 :         OStringBuffer buffer2(64);
     277           0 :         do
     278             :         {
     279           0 :             OString s(fieldtype.getToken(0, '<', nPos));
     280           0 :             OStringBuffer buffer(16);
     281           0 :             buffer.append("((");
     282           0 :             buffer.append(s.copy(s.lastIndexOf('/')+1));
     283           0 :             buffer.append(')');
     284           0 :             OString t = buffer.makeStringAndClear();
     285             : 
     286           0 :             if ( t.equals("((Optional)") ) {
     287           0 :                 optional=true;
     288           0 :                 if (single) {
     289           0 :                     single=false;
     290           0 :                     buffer1.append("the_value.IsPresent");
     291           0 :                     buffer2.append("the_value.Value");
     292             :                 } else {
     293           0 :                     buffer1.insert(0, t);
     294           0 :                     buffer1.append(").IsPresent");
     295           0 :                     buffer2.insert(0, t);
     296           0 :                     buffer2.append(").Value");
     297             :                 }
     298             :             } else {
     299           0 :                 if ( single ) {
     300           0 :                     single=false;
     301           0 :                     if ( !optional ) {
     302           0 :                         buffer1.append("the_value.Value");
     303             :                     }
     304           0 :                     buffer2.append("the_value.Value");
     305             :                 } else {
     306           0 :                     if ( !optional ) {
     307           0 :                         buffer1.insert(0, t);
     308           0 :                         buffer1.append(").Value");
     309             :                     }
     310           0 :                     buffer2.insert(0, t);
     311           0 :                     buffer2.append(").Value");
     312             :                 }
     313           0 :             }
     314             :         } while( nPos <= index );
     315             : 
     316           0 :         o << "Any.VOID,\n" << indentation << "        ";
     317           0 :         if ( optional )
     318           0 :             o << "(";
     319           0 :         o << buffer1.makeStringAndClear();
     320           0 :         if ( optional )
     321           0 :             o << ") ? " << buffer2.makeStringAndClear() << " : Any.VOID,\n"
     322           0 :               << indentation << "        ";
     323             :         else
     324           0 :             o << ", ";
     325             :     }
     326             : 
     327           0 :     if ( bound )
     328           0 :         o << "l";
     329             :     else
     330           0 :         o << "null";
     331           0 :     o << ");\n";
     332             : 
     333           0 :     o << indentation << "    synchronized (this) {\n"
     334           0 :       << indentation << "        m_" << fieldname
     335           0 :       << " = the_value;\n" << indentation << "    }\n";
     336             : 
     337           0 :     if ( bound ) {
     338           0 :         o << indentation << "    l.notifyListeners();\n";
     339             :     }
     340           0 :     o  << indentation << "}\n\n";
     341           0 : }
     342             : 
     343             : void generateXPropertySetBodies(std::ostream& o);
     344             : void generateXFastPropertySetBodies(std::ostream& o);
     345             : void generateXPropertyAccessBodies(std::ostream& o);
     346             : 
     347           0 : void printMethods(std::ostream & o,
     348             :     ProgramOptions const & options, TypeManager const & manager,
     349             :     typereg::Reader const & reader,
     350             :     codemaker::GeneratedTypeSet & generated,
     351             :     OString const & delegate, OString const & indentation,
     352             :     bool defaultvalue, bool usepropertymixin)
     353             : {
     354           0 :     OString type(codemaker::convertString(reader.getTypeName()));
     355           0 :     if ( generated.contains(type) || type == "com/sun/star/uno/XInterface" ||
     356             :          ( defaultvalue &&
     357           0 :            ( type.equals("com/sun/star/lang/XComponent") ||
     358           0 :              type.equals("com/sun/star/lang/XTypeProvider") ||
     359           0 :              type.equals("com/sun/star/uno/XWeak") ) ) ) {
     360             :         return;
     361             :     }
     362             : 
     363           0 :     if ( usepropertymixin ) {
     364           0 :         if ( type.equals("com/sun/star/beans/XPropertySet") ) {
     365           0 :             generated.add(type);
     366           0 :             generateXPropertySetBodies(o);
     367             :             return;
     368           0 :         } else if ( type.equals("com/sun/star/beans/XFastPropertySet") ) {
     369           0 :             generated.add(type);
     370           0 :             generateXFastPropertySetBodies(o);
     371             :             return;
     372           0 :         } else if ( type.equals("com/sun/star/beans/XPropertyAccess") ) {
     373           0 :             generated.add(type);
     374           0 :             generateXPropertyAccessBodies(o);
     375             :             return;
     376             :         }
     377             :     }
     378             : 
     379           0 :     static OString sd(RTL_CONSTASCII_STRINGPARAM("_"));
     380           0 :     bool body = !delegate.isEmpty();
     381           0 :     bool defaultbody = ((delegate.equals(sd)) ? true : false);
     382             : 
     383           0 :     generated.add(type);
     384           0 :     if ( options.all || defaultvalue ) {
     385           0 :         for (sal_uInt16 i = 0; i < reader.getSuperTypeCount(); ++i) {
     386             :             typereg::Reader super(
     387             :                 manager.getTypeReader(
     388             :                     codemaker::convertString(
     389           0 :                         reader.getSuperTypeName(i))));
     390           0 :             if ( !super.isValid() ) {
     391             :                 throw CannotDumpException(
     392             :                     "Bad type library entity "
     393             :                     + codemaker::convertString(
     394           0 :                         reader.getSuperTypeName(i)));
     395             :             }
     396             :             printMethods(o, options, manager, super, generated, delegate,
     397           0 :                          indentation, defaultvalue, usepropertymixin);
     398           0 :         }
     399           0 :         if ( reader.getFieldCount() > 0 || reader.getMethodCount() > 0 ) {
     400           0 :             o << indentation << "// ";
     401           0 :             printType(o, options, manager, type, false);
     402           0 :             o << ":\n";
     403             :         }
     404             :     }
     405           0 :     sal_uInt16 method = 0;
     406           0 :     for ( sal_uInt16 i = 0; i < reader.getFieldCount(); ++i ) {
     407             : //         OString fieldName(
     408             : //             codemaker::convertString(reader.getFieldName(i)).
     409             : //             replace('/', '.'));
     410             : //         OString fieldType(
     411             : //             codemaker::convertString(reader.getFieldTypeName(i)).
     412             : //             replace('/', '.'));
     413             : //         attributes.insert(StringPairHashMap::value_type(fieldName,
     414             : //                               std::pair<OString, sal_Int16>(
     415             : //                                   fieldType, reader.getFieldFlags(i))));
     416             : 
     417           0 :         o << indentation << "public ";
     418             :         printType(o,
     419             :             options, manager,
     420           0 :             codemaker::convertString(reader.getFieldTypeName(i)), false);
     421           0 :         o << " get"
     422           0 :           << codemaker::convertString(reader.getFieldName(i)).getStr()
     423           0 :           << "()";
     424             : 
     425           0 :         OUString mn = reader.getMethodName(method);
     426           0 :         OUString fn = reader.getFieldName(i);
     427             : 
     428           0 :         if ( method < reader.getMethodCount()
     429           0 :              && reader.getMethodFlags(method) == RT_MODE_ATTRIBUTE_GET
     430           0 :              && reader.getMethodName(method) == reader.getFieldName(i) )
     431             :         {
     432           0 :             printExceptionSpecification(o, options, manager, reader, method++);
     433             :         }
     434           0 :         if ( body ) {
     435           0 :             if ( defaultbody ) {
     436           0 :                 if ( usepropertymixin ) {
     437           0 :                     o << "\n" << indentation << "{\n" << indentation
     438           0 :                       << "    return m_"
     439           0 :                       << codemaker::convertString(reader.getFieldName(i)).getStr()
     440           0 :                       << ";\n" << indentation << "}\n\n";
     441             :                 } else {
     442           0 :                     o << "\n" << indentation << "{\n" << indentation
     443           0 :                       << "    return ";
     444             :                     printType(o,
     445             :                               options, manager,
     446             :                               codemaker::convertString(reader.getFieldTypeName(i)),
     447           0 :                               false, true);
     448           0 :                     o << ";\n" << indentation << "}\n\n";
     449             :                 }
     450             :             } else {
     451           0 :                 o << "\n" << indentation << "{\n" << indentation <<
     452           0 :                     "    return "
     453           0 :                   << delegate.getStr() << "get"
     454           0 :                   << codemaker::convertString(reader.getFieldName(i)).getStr()
     455           0 :                   << "();\n" << indentation << "}\n\n";
     456             :             }
     457             :         } else {
     458           0 :             o << ";\n";
     459             :         }
     460             : 
     461             :         // REMOVE next line
     462           0 :         OUString tmp = reader.getFieldName(i);
     463           0 :         bool setAttrMethod = false;
     464           0 :         if ( (reader.getFieldFlags(i) & RT_ACCESS_READONLY) == 0 ) {
     465           0 :             o << indentation << "public void set"
     466             :               << (codemaker::convertString(reader.getFieldName(i)).
     467           0 :                   getStr())
     468           0 :               << '(';
     469             :             printType(o,
     470             :                 options, manager,
     471             :                 codemaker::convertString(reader.getFieldTypeName(i)),
     472           0 :                 false);
     473           0 :             o << " the_value)";
     474           0 :             if ( method < reader.getMethodCount()
     475           0 :                  && reader.getMethodFlags(method) == RT_MODE_ATTRIBUTE_SET
     476           0 :                  && reader.getMethodName(method) == reader.getFieldName(i) )
     477             :             {
     478           0 :                 setAttrMethod=true;
     479           0 :                 printExceptionSpecification(o, options, manager, reader, method);
     480             :             }
     481           0 :             if ( body ) {
     482           0 :                 if ( defaultbody ) {
     483           0 :                     if ( usepropertymixin ) {
     484             :                         printSetPropertyMixinBody(o, reader, i, method,
     485           0 :                                                   indentation);
     486             :                     } else {
     487           0 :                         o << "\n" << indentation << "{\n\n" << indentation
     488           0 :                           << "}\n\n";
     489             :                     }
     490             :                 } else {
     491           0 :                     o << "\n" << indentation << "{\n" << indentation
     492           0 :                       << "    " << delegate.getStr() << "set"
     493           0 :                       << codemaker::convertString(reader.getFieldName(i)).getStr()
     494           0 :                       << "(the_value);\n" << indentation << "}\n\n";
     495             :                 }
     496             :             } else {
     497           0 :                 o << ";\n";
     498             :             }
     499           0 :             if (setAttrMethod) ++method;
     500             :         }
     501           0 :     }
     502           0 :     for ( ; method < reader.getMethodCount(); ++method ) {
     503           0 :         o << indentation << "public ";
     504             :         printType(o,
     505             :             options, manager,
     506             :             codemaker::convertString(
     507             :                 reader.getMethodReturnTypeName(method)),
     508           0 :             false);
     509             : 
     510           0 :         const OString methodName(codemaker::convertString(reader.getMethodName(method)));
     511             : 
     512           0 :         o << ' ' << methodName.getStr() << '(';
     513           0 :         printMethodParameters(o, options, manager, reader, method, false, true);
     514           0 :         o << ')';
     515           0 :         printExceptionSpecification(o, options, manager, reader, method);
     516           0 :         if ( body ) {
     517           0 :             static OUString s(RTL_CONSTASCII_USTRINGPARAM("void"));
     518           0 :             if ( defaultbody ) {
     519           0 :                 o << "\n" << indentation << "{\n";
     520           0 :                 if ( !reader.getMethodReturnTypeName(method).equals(s) ) {
     521           0 :                     o << indentation << "    // TODO: Exchange the default return "
     522           0 :                       << "implementation for \"" << methodName << "\" !!!\n";
     523           0 :                     o << indentation << "    // NOTE: "
     524             :                         "Default initialized polymorphic structs can cause problems"
     525           0 :                         "\n" << indentation << "    // because of missing default "
     526           0 :                         "initialization of primitive types of\n" << indentation
     527             :                       << "    // some C++ compilers or different Any initialization"
     528           0 :                         " in Java and C++\n" << indentation
     529           0 :                       << "    // polymorphic structs.\n" << indentation
     530           0 :                       << "    return ";
     531             :                     printType(o,
     532             :                         options, manager,
     533             :                         codemaker::convertString(
     534             :                             reader.getMethodReturnTypeName(method)),
     535           0 :                         false, true);
     536           0 :                     o << ";";
     537             :                 } else {
     538           0 :                     o << indentation << "    // TODO: Insert your implementation for \""
     539           0 :                       << methodName << "\" here.";
     540             :                 }
     541           0 :                 o << "\n" << indentation << "}\n\n";
     542             :             } else {
     543           0 :                 o << "\n" << indentation << "{\n" << indentation << "    ";
     544           0 :                 if ( !reader.getMethodReturnTypeName(method).equals(s) )
     545           0 :                     o << "return ";
     546           0 :                 o << delegate.getStr()
     547             :                   << (codemaker::convertString(
     548           0 :                           reader.getMethodName(method)).getStr())
     549           0 :                   << '(';
     550             :                 printMethodParameters(o, options, manager, reader, method,
     551           0 :                                          false, false);
     552           0 :                 o << ");\n" << indentation << "}\n\n";
     553             :             }
     554             :         } else {
     555           0 :             o << ";\n";
     556             :         }
     557           0 :     }
     558             : }
     559             : 
     560           0 : void printConstructionMethods(std::ostream & o,
     561             :     ProgramOptions const & options, TypeManager const & manager,
     562             :     typereg::Reader const & reader)
     563             : {
     564           0 :     for ( sal_uInt16 i = 0; i < reader.getMethodCount(); ++i ) {
     565           0 :         o << "public static ";
     566             :         printType(o,
     567             :             options, manager,
     568           0 :             codemaker::convertString(reader.getSuperTypeName(0)), false);
     569           0 :         o << ' ';
     570           0 :         if ( reader.getMethodName(i).isEmpty() ) {
     571           0 :             o << "create";
     572             :         } else {
     573             :             o << (codemaker::java::translateUnoToJavaIdentifier(
     574             :                       codemaker::convertString(reader.getMethodName(i)),
     575           0 :                       "method").getStr());
     576             :         }
     577           0 :         o << "(com.sun.star.uno.XComponentContext the_context";
     578           0 :         printMethodParameters(o, options, manager, reader, i, true, true);
     579           0 :         o << ')';
     580           0 :         printExceptionSpecification(o, options, manager, reader, i);
     581           0 :         o << ";\n";
     582             :     }
     583           0 : }
     584             : 
     585             : void generateDocumentation(std::ostream & o,
     586             :     ProgramOptions const & options, TypeManager const & manager,
     587             :     OString const & type);
     588             : 
     589           0 : void printServiceMembers(std::ostream & o,
     590             :     ProgramOptions const & options, TypeManager const & manager,
     591             :     typereg::Reader const & reader, OString const & type,
     592             :     OString const & delegate)
     593             : {
     594           0 :     for ( sal_uInt16 i = 0; i < reader.getReferenceCount(); ++i ) {
     595             :         OString referenceType(
     596             :             codemaker::convertString(
     597           0 :                 reader.getReferenceTypeName(i)).replace('/', '.'));
     598             : 
     599           0 :         if ( reader.getReferenceSort(i) == RT_REF_SUPPORTS ) {
     600           0 :             o << "\n// supported interface " << referenceType.getStr() << "\n";
     601           0 :             generateDocumentation(o, options, manager, referenceType, delegate);
     602           0 :         } else if ( reader.getReferenceSort(i) == RT_REF_EXPORTS ) {
     603           0 :             o << "\n// exported service " << referenceType.getStr() << "\n";
     604           0 :             generateDocumentation(o, options, manager, referenceType, delegate);
     605             :         }
     606           0 :     }
     607             : 
     608           0 :     o << "\n// properties of service \""<< type.getStr() << "\"\n";
     609           0 :     for ( sal_uInt16 i = 0; i < reader.getFieldCount(); ++i ) {
     610             :         OString fieldName(
     611           0 :             codemaker::convertString(reader.getFieldName(i)));
     612             :         OString fieldType(
     613           0 :             codemaker::convertString(reader.getFieldTypeName(i)));
     614             : 
     615           0 :         o << "// private ";
     616           0 :         printType(o, options, manager, fieldType, false);
     617           0 :         o << " "
     618             :           << codemaker::java::translateUnoToJavaIdentifier(
     619           0 :               fieldName, "property").getStr()
     620           0 :           << ";\n";
     621           0 :     }
     622           0 : }
     623             : 
     624           0 : void printMapsToJavaType(std::ostream & o,
     625             :     ProgramOptions const & options, TypeManager const & manager,
     626             :     codemaker::UnoType::Sort sort, RTTypeClass typeClass,
     627             :     OString const & name, sal_Int32 rank,
     628             :     std::vector< OString > const & arguments, const char * javaTypeSort)
     629             : {
     630           0 :     o << "maps to Java " << (options.java5 ? "1.5" : "1.4") << " ";
     631           0 :     if ( javaTypeSort != 0 ) {
     632           0 :         o << javaTypeSort << ' ';
     633             :     }
     634           0 :     o << "type \"";
     635           0 :     if ( rank == 0 && name == "com/sun/star/uno/XInterface" ) {
     636           0 :         o << "com.sun.star.uno.XInterface";
     637             :     } else {
     638             :         printType(o,
     639           0 :             options, manager, sort, typeClass, name, rank, arguments, false);
     640             :     }
     641           0 :     o << '"';
     642           0 : }
     643             : 
     644           0 : void generateDocumentation(std::ostream & o,
     645             :     ProgramOptions const & options, TypeManager const & manager,
     646             :     OString const & type, OString const & delegate)
     647             : {
     648           0 :     if ( type.indexOf('/') >= 0 ) {
     649           0 :         throw CannotDumpException("Illegal type name " + type);
     650             :     }
     651           0 :     OString binType(type.replace('.', '/'));
     652             :     RTTypeClass typeClass;
     653           0 :     OString name;
     654             :     sal_Int32 rank;
     655           0 :     std::vector< OString > arguments;
     656             :     codemaker::UnoType::Sort sort = decomposeResolveAndCheck(
     657             :         manager, binType, false, true, true, &typeClass, &name, &rank,
     658           0 :         &arguments);
     659             : 
     660           0 :     bool comment=true;
     661           0 :     if ( !delegate.isEmpty() ) {
     662           0 :         if ( typeClass != RT_TYPE_INTERFACE && typeClass != RT_TYPE_SERVICE )
     663           0 :             return;
     664             : 
     665           0 :         comment=false;
     666             :     }
     667             : 
     668           0 :     if ( comment ) {
     669           0 :         o << "\n// UNO";
     670           0 :         if ( rank > 0 ) {
     671           0 :             o << " sequence type";
     672           0 :         } else if ( sort != codemaker::UnoType::SORT_COMPLEX ) {
     673           0 :             o << " simple type";
     674             :         } else {
     675           0 :             typereg::Reader reader(manager.getTypeReader(name));
     676           0 :             if ( !reader.isValid() ) {
     677           0 :                 throw CannotDumpException("Bad type library entity " + name);
     678             :             }
     679           0 :             switch ( typeClass ) {
     680             :             case RT_TYPE_INTERFACE:
     681           0 :                 o << " interface type";
     682           0 :                 break;
     683             : 
     684             :             case RT_TYPE_MODULE:
     685           0 :                 o << "IDL module";
     686           0 :                 break;
     687             : 
     688             :             case RT_TYPE_STRUCT:
     689           0 :                 if ( reader.getReferenceCount() == 0 ) {
     690           0 :                     o << " simple struct type";
     691           0 :                 } else if ( arguments.empty() ) {
     692           0 :                     o << " polymorphic struct type template";
     693             :                 } else {
     694           0 :                     o << " instantiated polymorphic struct type";
     695             :                 }
     696           0 :                 break;
     697             : 
     698             :             case RT_TYPE_ENUM:
     699           0 :                 o << " enum type";
     700           0 :                 break;
     701             : 
     702             :             case RT_TYPE_EXCEPTION:
     703           0 :                 o << " exception type";
     704           0 :                 break;
     705             : 
     706             :             case RT_TYPE_TYPEDEF:
     707           0 :                 o << "IDL typedef";
     708           0 :                 break;
     709             : 
     710             :             case RT_TYPE_SERVICE:
     711           0 :                 if ( reader.getSuperTypeCount() > 0 ) {
     712           0 :                     o << " single-inheritance--based service";
     713             :                 } else {
     714           0 :                     o << "IDL accumulation-based service";
     715             :                 }
     716           0 :                 break;
     717             : 
     718             :             case RT_TYPE_SINGLETON:
     719           0 :                 if ( (manager.getTypeReader(
     720             :                           codemaker::convertString(
     721           0 :                               reader.getSuperTypeName(0))).getTypeClass())
     722             :                      == RT_TYPE_INTERFACE )
     723             :                 {
     724           0 :                     o << " inheritance-based singleton";
     725             :                 } else {
     726           0 :                     o << "IDL service-based singleton";
     727             :                 }
     728           0 :                 break;
     729             : 
     730             :             case RT_TYPE_CONSTANTS:
     731           0 :                 o << "IDL constant group";
     732           0 :                 break;
     733             : 
     734             :             default:
     735             :                 OSL_ASSERT(false);
     736           0 :                 break;
     737           0 :             }
     738             :         }
     739           0 :         o << " \"" << type.getStr() << "\" ";
     740             :     }
     741             :     sort = codemaker::decomposeAndResolve(
     742             :         manager, binType, true, true, true, &typeClass, &name, &rank,
     743           0 :         &arguments);
     744           0 :     if ( rank > 0 ) {
     745             :         printMapsToJavaType(o,
     746           0 :             options, manager, sort, typeClass, name, rank, arguments, "array");
     747           0 :         o << '\n';
     748           0 :     } else if ( sort != codemaker::UnoType::SORT_COMPLEX ) {
     749             :         printMapsToJavaType(o,
     750           0 :             options, manager, sort, typeClass, name, rank, arguments, 0);
     751           0 :         o << '\n';
     752             :     } else {
     753           0 :         typereg::Reader reader(manager.getTypeReader(name));
     754           0 :         if ( !reader.isValid() ) {
     755           0 :             throw CannotDumpException("Bad type library entity " + name);
     756             :         }
     757           0 :         switch ( typeClass ) {
     758             :         case RT_TYPE_INTERFACE:
     759             :             printMapsToJavaType(o,
     760             :                 options, manager, sort, typeClass, name, rank, arguments,
     761           0 :                 "interface");
     762           0 :             if ( name == "com/sun/star/uno/XInterface" ) {
     763           0 :                 o << '\n';
     764             :             } else {
     765             :                 o
     766           0 :                     << "; " << (options.all ? "all" : "direct")
     767           0 :                     << " methods:\n";
     768           0 :                 codemaker::GeneratedTypeSet generated;
     769             :                 printMethods(o, options, manager, reader, generated,
     770           0 :                              delegate, "");
     771             :             }
     772           0 :             break;
     773             : 
     774             :         case RT_TYPE_MODULE:
     775             :             printMapsToJavaType(o,
     776             :                 options, manager, sort, typeClass, name, rank, arguments,
     777           0 :                 "package");
     778           0 :             o << '\n';
     779           0 :             break;
     780             : 
     781             :         case RT_TYPE_STRUCT:
     782           0 :             if ( reader.getReferenceCount() == 0 ) {
     783             :                 printMapsToJavaType(o,
     784             :                     options, manager, sort, typeClass, name, rank, arguments,
     785           0 :                     "class");
     786           0 :             } else if ( arguments.empty() ) {
     787             :                 printMapsToJavaType(o,
     788             :                     options, manager, sort, typeClass, name, rank, arguments,
     789           0 :                     options.java5 ? "generic class" : "class");
     790             :             } else {
     791             :                 printMapsToJavaType(o,
     792             :                     options, manager, sort, typeClass, name, rank, arguments,
     793           0 :                     options.java5 ? "generic class instantiation" : "class");
     794             :             }
     795           0 :             o << "; full constructor:\n";
     796           0 :             printConstructor(o, options, manager, reader, arguments);
     797           0 :             break;
     798             : 
     799             :         case RT_TYPE_ENUM:
     800             :         case RT_TYPE_CONSTANTS:
     801             :             printMapsToJavaType(o,
     802             :                 options, manager, sort, typeClass, name, rank, arguments,
     803           0 :                 "class");
     804           0 :             o << '\n';
     805           0 :             break;
     806             : 
     807             :         case RT_TYPE_EXCEPTION:
     808             :             printMapsToJavaType(o,
     809             :                 options, manager, sort, typeClass, name, rank, arguments,
     810           0 :                 "exception class");
     811           0 :             o << "; full constructor:\n";
     812           0 :             printConstructor(o, options, manager, reader, arguments);
     813           0 :             break;
     814             : 
     815             :         case RT_TYPE_SERVICE:
     816           0 :             if ( reader.getSuperTypeCount() > 0 ) {
     817             :                 printMapsToJavaType(o,
     818             :                     options, manager, sort, typeClass, name, rank, arguments,
     819           0 :                     "class");
     820           0 :                 o << "; construction methods:\n";
     821           0 :                 printConstructionMethods(o, options, manager, reader);
     822             : 
     823             :                 OString super(
     824             :                     codemaker::convertString(
     825           0 :                         reader.getSuperTypeName(0)).replace('/', '.'));
     826             : 
     827           0 :                 generateDocumentation(o, options, manager, super, delegate);
     828             :             } else {
     829             :                 o << ("does not map to Java\n"
     830           0 :                       "// the service members are generated instead\n");
     831           0 :                 printServiceMembers(o, options, manager, reader, type, delegate);
     832             :             }
     833           0 :             break;
     834             : 
     835             :         case RT_TYPE_SINGLETON:
     836           0 :             if ( reader.getSuperTypeCount() > 0 &&
     837             :                  ((manager.getTypeReader(
     838             :                        codemaker::convertString(
     839           0 :                            reader.getSuperTypeName(0))).getTypeClass())
     840             :                   == RT_TYPE_INTERFACE) ) {
     841             :                 printMapsToJavaType(o, options, manager, sort, typeClass,
     842           0 :                                     name, rank, arguments, "class");
     843           0 :                 o << "; get method:\npublic static ";
     844             :                 printType(o, options, manager,
     845             :                           codemaker::convertString(reader.getSuperTypeName(0)),
     846           0 :                           false);
     847             :                 o
     848           0 :                     << " get(com.sun.star.uno.XComponentContext context);\n";
     849             :             } else {
     850           0 :                 o << "does not map to Java\n";
     851             :             }
     852           0 :             break;
     853             : 
     854             :         default:
     855             :             OSL_ASSERT(false);
     856           0 :             break;
     857           0 :         }
     858           0 :     }
     859             : }
     860             : 
     861             : } }
     862             : 
     863             : 
     864             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10