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