unodevtools/source/skeletonmaker/skeletoncommon.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29 #include "osl/thread.hxx"
  30
  31 #include "codemaker/commonjava.hxx"
  32 #include "codemaker/commoncpp.hxx"
  33 #include "codemaker/generatedtypeset.hxx"
  34
  35 #include "ostringostreaminserter.hxx"
  36 #include "skeletoncommon.hxx"
  37
  38 #include <iostream>
  39
  40 using namespace ::rtl;
  41 using namespace ::codemaker::cpp;
  42
  43 namespace skeletonmaker {
  44
  45 void printLicenseHeader(std::ostream& o, rtl::OString const & filename)
  46 {
  47     sal_Int32 index = -1;
  48 #ifdef SAL_UNX
  49     index = filename.lastIndexOf('/');
  50 #else
  51     index = filename.lastIndexOf('\\');
  52 #endif
  53     OString shortfilename(filename);
  54     if ( index != -1 )
  55         shortfilename = filename.copy(index+1);
  56
  57     o << "/*************************************************************************\n"
  58         " *\n"
  59         " * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.\n"
  60         " * \n"
  61         " * Copyright 2000, 2010 Oracle and/or its affiliates.\n"
  62         " *\n"
  63         " * OpenOffice.org - a multi-platform office productivity suite\n"
  64         " *\n"
  65         " * This file is part of OpenOffice.org.\n"
  66         " *\n"
  67         " * OpenOffice.org is free software: you can redistribute it and/or modify\n"
  68         " * it under the terms of the GNU Lesser General Public License version 3\n"
  69         " * only, as published by the Free Software Foundation.\n"
  70         " *\n"
  71         " * OpenOffice.org is distributed in the hope that it will be useful,\n"
  72         " * but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
  73         " * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
  74         " * GNU Lesser General Public License version 3 for more details\n"
  75         " * (a copy is included in the LICENSE file that accompanied this code).\n"
  76         " *\n"
  77         " * You should have received a copy of the GNU Lesser General Public License\n"
  78         " * version 3 along with OpenOffice.org.  If not, see\n"
  79         " * <http://www.openoffice.org/license.html>\n"
  80         " * for a copy of the LGPLv3 License.\n"
  81         " *\n"
  82         " ************************************************************************/\n\n";
  83 }
  84
  85 bool getOutputStream(ProgramOptions const & options,
  86                      OString const & extension,
  87                      std::ostream** ppOutputStream,
  88                      OString & targetSourceFileName,
  89                      OString & tmpSourceFileName)
  90 {
  91     bool bStandardout = false;
  92     if ( options.outputpath.equals("stdout") )
  93     {
  94         bStandardout = true;
  95         *ppOutputStream = &std::cout;
  96         return bStandardout;
  97     }
  98
  99     targetSourceFileName = createFileNameFromType(
 100         options.outputpath, options.implname.replace('.','/'), extension);
 101
 102     OString tmpDir = getTempDir(targetSourceFileName);
 103     FileStream file;
 104     file.createTempFile(tmpDir);
 105
 106     if( !file.isValid() )
 107     {
 108         OString message("cannot open ");
 109         message += targetSourceFileName + " for writing";
 110         throw CannotDumpException(message);
 111     } else {
 112         tmpSourceFileName = file.getName();
 113     }
 114     file.close();
 115     *ppOutputStream = new std::ofstream(tmpSourceFileName.getStr(),
 116                                         std::ios_base::binary);
 117
 118     return bStandardout;
 119 }
 120
 121 codemaker::UnoType::Sort decomposeResolveAndCheck(
 122     TypeManager const & manager, OString const & type,
 123     bool resolveTypedefs, bool allowVoid, bool allowExtraEntities,
 124     RTTypeClass * typeClass, OString * name, sal_Int32 * rank,
 125     std::vector< OString > * arguments)
 126 {
 127     codemaker::UnoType::Sort sort = codemaker::decomposeAndResolve(
 128         manager, type, resolveTypedefs, allowVoid, allowExtraEntities,
 129         typeClass, name, rank, arguments);
 130     for ( std::vector< OString >::iterator i(arguments->begin());
 131           i != arguments->end(); ++i )
 132     {
 133         RTTypeClass typeClass2;
 134         OString name2;
 135         sal_Int32 rank2;
 136         std::vector< OString > arguments2;
 137         decomposeResolveAndCheck(
 138             manager, *i, true, false, false, &typeClass2, &name2, &rank2,
 139             &arguments2);
 140     }
 141     return sort;
 142 }
 143
 144 bool containsAttribute(AttributeInfo& attributes, OString const & attrname)
 145 {
 146     for ( AttributeInfo::const_iterator i(attributes.begin());
 147           i != attributes.end(); ++i ) {
 148         if ( (*i).first == attrname ) {
 149             return true;
 150         }
 151     }
 152     return false;
 153 }
 154
 155 // collect attributes including inherited attributes
 156 void checkAttributes(TypeManager const & manager,
 157                      const typereg::Reader& reader,
 158                      AttributeInfo& attributes,
 159                      boost::unordered_set< OString, OStringHash >& propinterfaces)
 160 {
 161     OString typeName = codemaker::convertString(reader.getTypeName());
 162     if ( typeName.equals("com/sun/star/beans/XPropertySet") ||
 163          typeName.equals("com/sun/star/beans/XFastPropertySet") ||
 164 //        typeName.equals("com/sun/star/beans/XMultiPropertySet") ||
 165          typeName.equals("com/sun/star/beans/XPropertyAccess") )
 166     {
 167         propinterfaces.insert(typeName);
 168     }
 169
 170     for ( sal_uInt16 i = 0; i < reader.getSuperTypeCount(); ++i ) {
 171         typereg::Reader supertype(manager.getTypeReader(
 172                                   codemaker::convertString(
 173                                       reader.getSuperTypeName(i))));
 174         if ( !supertype.isValid() ) {
 175             throw CannotDumpException(
 176                 "Bad type library entity "
 177                 + codemaker::convertString(reader.getSuperTypeName(i)));
 178         }
 179         checkAttributes(manager, supertype, attributes, propinterfaces);
 180     }
 181
 182     for ( sal_uInt16 i = 0; i < reader.getFieldCount(); ++i ) {
 183         OString fieldName(
 184             codemaker::convertString(reader.getFieldName(i)).
 185             replace('/', '.'));
 186
 187         if ( !containsAttribute(attributes, fieldName) ) {
 188             OString fieldType(
 189                 codemaker::convertString(reader.getFieldTypeName(i)).
 190                 replace('/', '.'));
 191             attributes.push_back(AttributeInfo::value_type(
 192                                      fieldName, std::pair<OString, sal_Int16>(
 193                                          fieldType, reader.getFieldFlags(i))));
 194         }
 195     }
 196 }
 197
 198 void checkType(TypeManager const & manager,
 199                OString const & type,
 200                boost::unordered_set< OString, OStringHash >& interfaceTypes,
 201                boost::unordered_set< OString, OStringHash >& serviceTypes,
 202                AttributeInfo& properties)
 203 {
 204
 205     OString binType(type.replace('.', '/'));
 206     typereg::Reader reader(manager.getTypeReader(binType));
 207     if ( !reader.isValid() ) {
 208         throw CannotDumpException("Bad type library entity " + binType);
 209     }
 210
 211     switch ( reader.getTypeClass() )
 212     {
 213     case RT_TYPE_INTERFACE:
 214     {
 215         // com/sun/star/lang/XComponent should be also not in the list
 216         // but it will be used for checking the impl helper and will be
 217         // removed later if necessary.
 218         if ( binType.equals("com/sun/star/lang/XTypeProvider") ||
 219              binType.equals("com/sun/star/uno/XWeak") )
 220             return;
 221         if (interfaceTypes.find(type) == interfaceTypes.end()) {
 222             interfaceTypes.insert(type);
 223         }
 224     }
 225         break;
 226     case RT_TYPE_SERVICE:
 227         if ( serviceTypes.find(binType) == serviceTypes.end() ) {
 228             serviceTypes.insert(binType);
 229
 230             if ( reader.getSuperTypeCount() > 0 ) {
 231                 OString supername(codemaker::convertString(
 232                     reader.getSuperTypeName(0).replace('/', '.')));
 233                 if ( interfaceTypes.find(supername) == interfaceTypes.end() ) {
 234                     interfaceTypes.insert(supername);
 235
 236                     typereg::Reader supertype(manager.getTypeReader(
 237                                   codemaker::convertString(
 238                                       reader.getSuperTypeName(0))));
 239                     if ( !supertype.isValid() ) {
 240                         throw CannotDumpException(
 241                             "Bad type library entity "
 242                             + codemaker::convertString(reader.getSuperTypeName(0)));
 243                     }
 244                 }
 245
 246                 // check if constructors are specified, if yes automatically
 247                 // support of XInitialization. We will take care of the default
 248                 // constructor because in this case XInitialization is not called.
 249                 if ( reader.getMethodCount() > 1 ||
 250                      ( reader.getMethodCount() == 1 &&
 251                        !reader.getMethodName(0).isEmpty() ) )
 252                 {
 253                     OString s("com.sun.star.lang.XInitialization");
 254                     if ( interfaceTypes.find(s) == interfaceTypes.end() )
 255                         interfaceTypes.insert(s);
 256                 }
 257             } else {
 258                 for ( sal_uInt16 i = 0; i < reader.getReferenceCount(); ++i ) {
 259                     OString referenceType(
 260                         codemaker::convertString(
 261                             reader.getReferenceTypeName(i)).replace('/', '.'));
 262
 263                     if ( reader.getReferenceSort(i) == RT_REF_SUPPORTS ) {
 264                         checkType(manager, referenceType, interfaceTypes,
 265                                   serviceTypes, properties);
 266                     } else if ( reader.getReferenceSort(i) == RT_REF_EXPORTS ) {
 267                         checkType(manager, referenceType, interfaceTypes,
 268                                   serviceTypes, properties);
 269                     }
 270                 }
 271
 272                 for ( sal_uInt16 i = 0; i < reader.getFieldCount(); ++i ) {
 273                     OString fieldName(
 274                         codemaker::convertString(reader.getFieldName(i)).
 275                         replace('/', '.'));
 276                     OString fieldType(
 277                         codemaker::convertString(reader.getFieldTypeName(i)).
 278                         replace('/', '.'));
 279
 280                     properties.push_back(AttributeInfo::value_type(
 281                         fieldName, std::pair<OString, sal_Int16>(
 282                             fieldType, reader.getFieldFlags(i))));
 283                 }
 284             }
 285         }
 286         break;
 287     default:
 288         OSL_ASSERT(false);
 289         break;
 290     }
 291 }
 292
 293 void checkDefaultInterfaces(
 294          boost::unordered_set< OString, OStringHash >& interfaces,
 295          const boost::unordered_set< OString, OStringHash >& services,
 296        const OString & propertyhelper)
 297 {
 298     if ( services.empty() ) {
 299         if (interfaces.find("com.sun.star.lang.XServiceInfo") != interfaces.end())
 300             interfaces.erase("com.sun.star.lang.XServiceInfo");
 301     } else {
 302         if (interfaces.find("com.sun.star.lang.XServiceInfo") == interfaces.end())
 303             interfaces.insert("com.sun.star.lang.XServiceInfo");
 304     }
 305
 306     if ( propertyhelper.equals("_") ) {
 307         if (interfaces.find("com.sun.star.beans.XPropertySet")
 308             != interfaces.end())
 309             interfaces.erase("com.sun.star.beans.XPropertySet");
 310         if (interfaces.find("com.sun.star.beans.XFastPropertySet")
 311             != interfaces.end())
 312             interfaces.erase("com.sun.star.beans.XFastPropertySet");
 313         if (interfaces.find("com.sun.star.beans.XPropertyAccess")
 314             != interfaces.end())
 315             interfaces.erase("com.sun.star.beans.XPropertyAccess");
 316     }
 317 }
 318
 319 bool checkServiceProperties(TypeManager const & manager,
 320                             const typereg::Reader & reader)
 321 {
 322     if ( reader.getFieldCount() > 0 )
 323         return true;
 324
 325     if ( reader.getReferenceCount() > 0 ) {
 326         for ( sal_uInt16 i = 0; i < reader.getReferenceCount(); ++i ) {
 327             if ( reader.getReferenceSort(i) == RT_REF_EXPORTS ) {
 328                 typereg::Reader refreader(
 329                     manager.getTypeReader(
 330                         codemaker::convertString(reader.getReferenceTypeName(i))));
 331
 332                 if ( checkServiceProperties(manager, refreader) )
 333                     return true;
 334             }
 335         }
 336     }
 337     return false;
 338 }
 339
 340
 341 OString checkPropertyHelper(
 342     ProgramOptions const & options,
 343     TypeManager const & manager,
 344     const boost::unordered_set< OString, OStringHash >& services,
 345     const boost::unordered_set< OString, OStringHash >& interfaces,
 346     AttributeInfo& attributes,
 347     boost::unordered_set< OString, OStringHash >& propinterfaces)
 348 {
 349     boost::unordered_set< OString, OStringHash >::const_iterator iter;
 350     boost::unordered_set< OString, OStringHash >::const_iterator end;
 351
 352     if ( !services.empty() ) {
 353         iter = services.begin();
 354         end = services.end();
 355     } else {
 356         iter = interfaces.begin();
 357         end = interfaces.end();
 358     }
 359
 360     bool oldStyleWithProperties = false;
 361     while ( iter != end ) {
 362         typereg::Reader reader(manager.getTypeReader((*iter).replace('.', '/')));
 363
 364         if ( !services.empty() ) {
 365             if ( options.supportpropertysetmixin && reader.getSuperTypeCount() > 0 )
 366             {
 367                 typereg::Reader supertype(
 368                     manager.getTypeReader(
 369                         codemaker::convertString(
 370                             reader.getSuperTypeName(0))));
 371                 if ( !supertype.isValid() ) {
 372                     throw CannotDumpException(
 373                         "Bad type library entity "
 374                         + codemaker::convertString(
 375                             reader.getSuperTypeName(0)));
 376                 }
 377
 378                 checkAttributes(manager, supertype, attributes, propinterfaces);
 379
 380                 if ( !(attributes.empty() || propinterfaces.empty()) ) {
 381                     return OUStringToOString(
 382                         supertype.getTypeName().replace('/', '.'),
 383                         osl_getThreadTextEncoding());
 384                 }
 385             } else {
 386                 oldStyleWithProperties = checkServiceProperties(manager, reader);
 387             }
 388         } else {
 389             checkAttributes(manager, reader, attributes, propinterfaces);
 390             if ( !(attributes.empty() || propinterfaces.empty()) ) {
 391                 return OUStringToOString(
 392                     reader.getTypeName().replace('/', '.'),
 393                     osl_getThreadTextEncoding());
 394             }
 395         }
 396         ++iter;
 397     }
 398
 399     return (oldStyleWithProperties ? "_" : "");
 400 }
 401
 402 bool checkXComponentSupport(TypeManager const & manager,
 403                             typereg::Reader const & reader)
 404 {
 405     static OUString s( "com/sun/star/lang/XComponent");
 406     if ( reader.getTypeName().equals(s) )
 407         return true;
 408
 409     for ( sal_uInt16 i = 0; i < reader.getSuperTypeCount(); ++i ) {
 410         typereg::Reader super(
 411             manager.getTypeReader(
 412                 codemaker::convertString(
 413                     reader.getSuperTypeName(i))));
 414         if ( !super.isValid() ) {
 415             throw CannotDumpException(
 416                 "Bad type library entity "
 417                 + codemaker::convertString(
 418                     reader.getSuperTypeName(i)));
 419         }
 420         if ( checkXComponentSupport(manager, super) )
 421             return true;
 422     }
 423
 424     return false;
 425 }
 426
 427
 428 // if XComponent is directly specified, return true and remove it from the
 429 // supported interfaces list
 430 bool checkXComponentSupport(TypeManager const & manager,
 431          boost::unordered_set< OString, OStringHash >& interfaces)
 432 {
 433     if ( interfaces.empty() )
 434         return false;
 435
 436     boost::unordered_set< OString, OStringHash >::const_iterator iter =
 437         interfaces.begin();
 438     while ( iter != interfaces.end() ) {
 439         if ( (*iter).equals("com.sun.star.lang.XComponent") ) {
 440             interfaces.erase("com.sun.star.lang.XComponent");
 441             return true;
 442         }
 443         typereg::Reader reader(manager.getTypeReader((*iter).replace('.', '/')));
 444         if ( checkXComponentSupport(manager, reader) )
 445             return true;
 446         ++iter;
 447     }
 448
 449     return false;
 450 }
 451
 452 sal_uInt16 checkAdditionalPropertyFlags(typereg::Reader const & reader,
 453                                         sal_uInt16 field, sal_uInt16 method)
 454 {
 455     sal_uInt16 flags = 0;
 456     bool getterSupportsUnknown = false;
 457
 458     OUString su( "com/sun/star/beans/UnknownPropertyException");
 459     if ( method < reader.getMethodCount()
 460          && reader.getMethodFlags(method) == RT_MODE_ATTRIBUTE_GET
 461          && reader.getMethodName(method) == reader.getFieldName(field) )
 462     {
 463         if ( reader.getMethodExceptionCount(method) > 0 ) {
 464             for ( sal_uInt16 i = 0; i < reader.getMethodExceptionCount(method);
 465                   ++i )
 466             {
 467                 if (su.equals(reader.getMethodExceptionTypeName(method, i)))
 468                     getterSupportsUnknown = true;
 469             }
 470         }
 471         method++;
 472     }
 473     if ( method < reader.getMethodCount()
 474          && reader.getMethodFlags(method) == RT_MODE_ATTRIBUTE_SET
 475          && reader.getMethodName(method) == reader.getFieldName(field) )
 476     {
 477         if ( reader.getMethodExceptionCount(method) > 0 ) {
 478             OUString s( "com/sun/star/beans/PropertyVetoException");
 479             for ( sal_uInt16 i = 0; i < reader.getMethodExceptionCount(method);
 480                   ++i )
 481             {
 482                 if ( s.equals(reader.getMethodExceptionTypeName(method, i)) )
 483                     flags |= RT_ACCESS_CONSTRAINED;
 484                 if ( getterSupportsUnknown &&
 485                      su.equals(reader.getMethodExceptionTypeName(method, i)) )
 486                     flags |= RT_ACCESS_OPTIONAL;
 487             }
 488         }
 489     }
 490     return flags;
 491 }
 492
 493 // This function checks if the specified types for parameters and return
 494 // types are allowed add-in types, for more info see the com.sun.star.sheet.AddIn
 495 // service description
 496 bool checkAddinType(TypeManager const & manager,
 497                     OString const & type, bool & bLastAny,
 498                     bool & bHasXPropertySet, bool bIsReturn)
 499 {
 500     RTTypeClass typeClass;
 501     OString name;
 502     sal_Int32 rank;
 503     std::vector< OString > arguments;
 504     codemaker::UnoType::Sort sort = codemaker::decomposeAndResolve(
 505         manager, type, true, true, true, &typeClass, &name, &rank, &arguments);
 506
 507     if ( sort == codemaker::UnoType::SORT_LONG ||
 508          sort == codemaker::UnoType::SORT_DOUBLE ||
 509          sort == codemaker::UnoType::SORT_STRING )
 510     {
 511         if ( rank == 0 || rank ==2 )
 512             return true;
 513     }
 514     if ( sort == codemaker::UnoType::SORT_ANY )
 515     {
 516         if ( rank <= 2 ) {
 517             if ( rank ==1 ) {
 518                 if ( bIsReturn )
 519                     return false;
 520                 bLastAny = true;
 521             }
 522
 523             return true;
 524         }
 525     }
 526     if ( sort == codemaker::UnoType::SORT_COMPLEX &&
 527          typeClass == RT_TYPE_INTERFACE )
 528     {
 529         if ( bIsReturn && type.equals("com/sun/star/sheet/XVolatileResult") )
 530             return true;
 531         if ( !bIsReturn && type.equals("com/sun/star/table/XCellRange") )
 532             return true;
 533         if ( !bIsReturn && type.equals("com/sun/star/beans/XPropertySet") )
 534         {
 535             if ( bHasXPropertySet ) {
 536                 return false;
 537             } else {
 538                 bHasXPropertySet = true;
 539                 return true;
 540             }
 541         }
 542     }
 543     return false;
 544 }
 545
 546 void checkAddInTypes(TypeManager const & manager,
 547                      typereg::Reader const & reader)
 548 {
 549     OString sType(codemaker::convertString(reader.getTypeName()).replace('/', '.'));
 550     bool bLastAny = false;
 551     bool bHasXPropertySet = false;
 552     for ( sal_uInt16 m = 0; m < reader.getMethodCount(); ++m ) {
 553         OString sMethod(codemaker::convertString(reader.getMethodName(m)));
 554
 555         OString sReturnType(codemaker::convertString(
 556                                 reader.getMethodReturnTypeName(m)));
 557         if ( !checkAddinType(
 558                  manager, sReturnType, bLastAny, bHasXPropertySet, true) )
 559         {
 560             OStringBuffer msg("the return type of the calc add-in function '");
 561             msg.append(sType);
 562             msg.append(":");
 563             msg.append(sMethod);
 564             msg.append("' is invalid. Please check your IDL defintion.");
 565             throw CannotDumpException(msg.makeStringAndClear());
 566         }
 567
 568         bHasXPropertySet = false;
 569         for ( sal_uInt16 p = 0; p < reader.getMethodParameterCount(m); ++p ) {
 570             bLastAny = false;
 571             OString sParamType(codemaker::convertString(
 572                                    reader.getMethodParameterTypeName(m, p)));
 573             if ( !checkAddinType(manager, sParamType,
 574                                 bLastAny, bHasXPropertySet, false) ||
 575                  bLastAny )
 576             {
 577                 OStringBuffer msg("the type of the ");
 578                 msg.append((sal_Int32)p+1);
 579                 msg.append(". parameter of the calc add-in function '");
 580                 msg.append(sType);
 581                 msg.append(":");
 582                 msg.append(sMethod);
 583                 msg.append("' is invalid.");
 584                 if ( bLastAny )
 585                     msg.append(" The type 'sequence<any>' is allowed as last "
 586                                "parameter only.");
 587                 if ( bHasXPropertySet )
 588                     msg.append(" The type 'XPropertySet' is allowed only once.");
 589
 590                 msg.append(" Please check your IDL definition.");
 591                 throw CannotDumpException(msg.makeStringAndClear());
 592             }
 593         }
 594     }
 595 }
 596
 597 void generateFunctionParamterMap(std::ostream& o,
 598                                  ProgramOptions const & options,
 599                                  TypeManager const & manager,
 600                                  typereg::Reader const & reader,
 601                                  ::codemaker::GeneratedTypeSet & generated,
 602                                  bool bFirst)
 603 {
 604     OString sType(codemaker::convertString(reader.getTypeName()));
 605     if ( sType.equals("com/sun/star/uno/XInterface") ||
 606          sType.equals("com/sun/star/lang/XLocalizable") ||
 607          sType.equals("com/sun/star/lang/XServiceInfo") ||
 608          // the next three checks becomes obsolete when configuration is used
 609          sType.equals("com/sun/star/sheet/XAddIn") ||
 610          sType.equals("com/sun/star/sheet/XCompatibilityNames") ||
 611          sType.equals("com/sun/star/lang/XServiceName") )
 612     {
 613         return;
 614     }
 615
 616     // check if the specified add-in functions supports valid types
 617     checkAddInTypes(manager, reader);
 618
 619     for ( sal_uInt16 i = 0; i < reader.getSuperTypeCount(); ++i ) {
 620         typereg::Reader super(
 621             manager.getTypeReader(
 622                 codemaker::convertString(
 623                     reader.getSuperTypeName(i))));
 624         if ( !super.isValid() ) {
 625             throw CannotDumpException(
 626                 "Bad type library entity "
 627                 + codemaker::convertString(
 628                     reader.getSuperTypeName(i)));
 629         }
 630         generateFunctionParamterMap(o, options, manager, super, generated, bFirst);
 631     }
 632
 633     OString type(codemaker::convertString(reader.getTypeName()));
 634     if ( generated.contains(type) )
 635         return;
 636     else
 637         generated.add(type);
 638
 639     for ( sal_uInt16 m = 0; m < reader.getMethodCount(); ++m ) {
 640         OString sMethod(codemaker::convertString(reader.getMethodName(m)));
 641
 642         if ( bFirst ) {
 643             if (options.language == 2) {
 644                 o << "        ParamMap fpm;\n";
 645             }
 646             else {
 647                 if ( options.java5 )
 648                     o << "        java.util.Hashtable< Integer, String > fpm = "
 649                         "new java.util.Hashtable< Integer, String >();\n";
 650                 else
 651                     o << "        java.util.Hashtable fpm = "
 652                         "new java.util.Hashtable();\n";
 653             }
 654             bFirst = false;
 655         } else
 656             if ( options.language == 2 ) {
 657                 o << "        fpm = ParamMap();\n";
 658             }
 659             else {
 660                 if ( options.java5 )
 661                     o << "        fpm = new java.util.Hashtable< "
 662                         "Integer, String >();\n";
 663                 else
 664                     o << "        fpm = new java.util.Hashtable();\n";
 665             }
 666
 667         for ( sal_uInt16 p = 0; p < reader.getMethodParameterCount(m); ++p ) {
 668             if ( options.language == 2 ) {
 669                 o << "        fpm[" << p
 670                   << "] = ::rtl::OUString(\""
 671                   << codemaker::convertString(reader.getMethodParameterName(m, p))
 672                   << "\");\n";
 673             }
 674             else {
 675                 if ( options.java5 )
 676                     o << "        fpm.put(" << p << ", \""
 677                       << codemaker::convertString(
 678                           reader.getMethodParameterName(m, p))
 679                       << "\");\n";
 680                 else
 681                     o << "       fpm.put(new Integer(" << p << "), \""
 682                       << codemaker::convertString(
 683                           reader.getMethodParameterName(m, p))
 684                       << "\");\n";
 685             }
 686         }
 687
 688         if ( options.language == 2 ) {
 689             o << "        m_functionMap[::rtl::OUString(\""
 690               << sMethod << "\")] = fpm;\n\n";
 691         }
 692         else {
 693             o << "        m_functionMap.put(\"" << sMethod << "\", fpm);\n\n";
 694         }
 695     }
 696 }
 697
 698 void generateFunctionParameterMap(std::ostream& o,
 699          ProgramOptions const & options,
 700          TypeManager const & manager,
 701          const boost::unordered_set< OString, OStringHash >& interfaces)
 702 {
 703     ::codemaker::GeneratedTypeSet generated;
 704     bool bFirst = true;
 705     boost::unordered_set< OString, OStringHash >::const_iterator iter = interfaces.begin();
 706     while ( iter != interfaces.end() ) {
 707         typereg::Reader reader(manager.getTypeReader((*iter).replace('.','/')));
 708         if (!reader.isValid()) {
 709             throw CannotDumpException(
 710                 "Bad type library entity "
 711                 + codemaker::convertString(
 712                     reader.getTypeName()));
 713         }
 714
 715         generateFunctionParamterMap(o, options, manager, reader, generated, bFirst);
 716         ++iter;
 717     }
 718 }
 719
 720 }
 721
 722 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */