unodevtools/source/skeletonmaker/skeletoncommon.cxx

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