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 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_idl.hxx" 26 27 #include <ctype.h> 28 #include <stdio.h> 29 30 #include <attrib.hxx> 31 #include <module.hxx> 32 #include <globals.hxx> 33 #include <database.hxx> 34 #include <tools/fsys.hxx> 35 #include <tools/debug.hxx> 36 37 /****************** SvMetaModule ******************************************/ 38 SV_IMPL_META_FACTORY1( SvMetaModule, SvMetaExtern ); 39 40 /************************************************************************* 41 |* 42 |* SvMetaModule::SvMetaModule() 43 |* 44 |* Beschreibung 45 |* Ersterstellung MM 12.12.94 46 |* Letzte Aenderung MM 12.12.94 47 |* 48 *************************************************************************/ 49 SvMetaModule::SvMetaModule() 50 #ifdef IDL_COMPILER 51 : bImported( sal_False ) 52 , bIsModified( sal_False ) 53 #endif 54 { 55 } 56 57 #ifdef IDL_COMPILER 58 SvMetaModule::SvMetaModule( const String & rIdlFileName, sal_Bool bImp ) 59 : aIdlFileName( rIdlFileName ) 60 , bImported( bImp ), bIsModified( sal_False ) 61 { 62 } 63 #endif 64 65 /************************************************************************* 66 |* 67 |* SvMetaModule::Load() 68 |* 69 |* Beschreibung 70 |* Ersterstellung MM 12.12.94 71 |* Letzte Aenderung MM 12.12.94 72 |* 73 *************************************************************************/ 74 #define MODULE_VER 0x0001 75 void SvMetaModule::Load( SvPersistStream & rStm ) 76 { 77 bImported = sal_True; // immer importiert 78 SvMetaExtern::Load( rStm ); 79 80 sal_uInt16 nVer; 81 82 rStm >> nVer; // Version 83 DBG_ASSERT( (nVer & ~IDL_WRITE_MASK) == MODULE_VER, "false version" ); 84 85 rStm >> aClassList; 86 rStm >> aTypeList; 87 rStm >> aAttrList; 88 // Browser 89 rStm.ReadByteString( aIdlFileName ); 90 rStm.ReadByteString( aHelpFileName ); 91 rStm.ReadByteString( aSlotIdFile ); 92 rStm.ReadByteString( aModulePrefix ); 93 94 // Compiler Daten lesen 95 sal_uInt16 nCmpLen; 96 rStm >> nCmpLen; 97 #ifdef IDL_COMPILER 98 DBG_ASSERT( (nVer & IDL_WRITE_MASK) == IDL_WRITE_COMPILER, 99 "no idl compiler format" ); 100 rStm >> aBeginName; 101 rStm >> aEndName; 102 rStm >> aNextName; 103 #else 104 rStm->SeekRel( nCmpLen ); 105 #endif 106 } 107 108 /************************************************************************* 109 |* 110 |* SvMetaModule::Save() 111 |* 112 |* Beschreibung 113 |* Ersterstellung MM 12.12.94 114 |* Letzte Aenderung MM 12.12.94 115 |* 116 *************************************************************************/ 117 void SvMetaModule::Save( SvPersistStream & rStm ) 118 { 119 SvMetaExtern::Save( rStm ); 120 121 rStm << (sal_uInt16)(MODULE_VER | IDL_WRITE_COMPILER); // Version 122 123 rStm << aClassList; 124 rStm << aTypeList; 125 rStm << aAttrList; 126 // Browser 127 rStm.WriteByteString( aIdlFileName ); 128 rStm.WriteByteString( aHelpFileName ); 129 rStm.WriteByteString( aSlotIdFile ); 130 rStm.WriteByteString( aModulePrefix ); 131 132 // Compiler Daten schreiben 133 sal_uInt16 nCmpLen = 0; 134 sal_uLong nLenPos = rStm.Tell(); 135 rStm << nCmpLen; 136 #ifdef IDL_COMPILER 137 rStm << aBeginName; 138 rStm << aEndName; 139 rStm << aNextName; 140 // Laenge der Compiler Daten schreiben 141 sal_uLong nPos = rStm.Tell(); 142 rStm.Seek( nLenPos ); 143 rStm << (sal_uInt16)( nPos - nLenPos - sizeof( sal_uInt16 ) ); 144 rStm.Seek( nPos ); 145 #endif 146 } 147 148 /************************************************************************* 149 |* 150 |* SvMetaModule::SetName() 151 |* 152 |* Beschreibung 153 |* Ersterstellung MM 12.12.94 154 |* Letzte Aenderung MM 12.12.94 155 |* 156 *************************************************************************/ 157 sal_Bool SvMetaModule::SetName( const ByteString & rName, SvIdlDataBase * pBase ) 158 { 159 if( pBase ) 160 { 161 if( pBase->GetModule( rName ) ) 162 return sal_False; 163 } 164 return SvMetaExtern::SetName( rName ); 165 } 166 167 #ifdef IDL_COMPILER 168 /************************************************************************* 169 |* SvMetaModule::GetNextName() 170 |* 171 |* Beschreibung 172 *************************************************************************/ 173 sal_Bool SvMetaModule::FillNextName( SvGlobalName * pName ) 174 { 175 *pName = aNextName; 176 177 if( aNextName < aEndName ) 178 { 179 ++aNextName; 180 bIsModified = sal_True; 181 return sal_True; 182 } 183 return sal_False; 184 } 185 186 /************************************************************************* 187 |* SvMetaModule::ReadSvIdl() 188 |* 189 |* Beschreibung 190 *************************************************************************/ 191 void SvMetaModule::ReadAttributesSvIdl( SvIdlDataBase & rBase, 192 SvTokenStream & rInStm ) 193 { 194 SvMetaExtern::ReadAttributesSvIdl( rBase, rInStm ); 195 196 aHelpFileName.ReadSvIdl( SvHash_HelpFile(), rInStm ); 197 if( aSlotIdFile.ReadSvIdl( SvHash_SlotIdFile(), rInStm ) ) 198 { 199 sal_uInt32 nTokPos = rInStm.Tell(); 200 if( !rBase.ReadIdFile( String::CreateFromAscii( aSlotIdFile.GetBuffer() ) ) ) 201 { 202 ByteString aStr = "cannot read file: "; 203 aStr += aSlotIdFile; 204 rBase.SetError( aStr, rInStm.GetToken() ); 205 rBase.WriteError( rInStm ); 206 207 rInStm.Seek( nTokPos ); 208 } 209 } 210 aTypeLibFile.ReadSvIdl( SvHash_TypeLibFile(), rInStm ); 211 aModulePrefix.ReadSvIdl( SvHash_ModulePrefix(), rInStm ); 212 } 213 214 /************************************************************************* 215 |* SvMetaModule::WriteAttributesSvIdl() 216 |* 217 |* Beschreibung 218 *************************************************************************/ 219 void SvMetaModule::WriteAttributesSvIdl( SvIdlDataBase & rBase, 220 SvStream & rOutStm, 221 sal_uInt16 nTab ) 222 { 223 SvMetaExtern::WriteAttributesSvIdl( rBase, rOutStm, nTab ); 224 if( aTypeLibFile.Len() || aSlotIdFile.Len() || aTypeLibFile.Len() ) 225 { 226 if( aHelpFileName.Len() ) 227 { 228 WriteTab( rOutStm, nTab ); 229 aHelpFileName.WriteSvIdl( SvHash_HelpFile(), rOutStm, nTab +1 ); 230 rOutStm << ';' << endl; 231 } 232 if( aSlotIdFile.Len() ) 233 { 234 WriteTab( rOutStm, nTab ); 235 aSlotIdFile.WriteSvIdl( SvHash_SlotIdFile(), rOutStm, nTab +1 ); 236 rOutStm << ';' << endl; 237 } 238 if( aTypeLibFile.Len() ) 239 { 240 WriteTab( rOutStm, nTab ); 241 aTypeLibFile.WriteSvIdl( SvHash_TypeLibFile(), rOutStm, nTab +1 ); 242 rOutStm << ';' << endl; 243 } 244 } 245 } 246 247 /************************************************************************* 248 |* SvMetaModule::ReadContextSvIdl() 249 |* 250 |* Beschreibung 251 *************************************************************************/ 252 void SvMetaModule::ReadContextSvIdl( SvIdlDataBase & rBase, 253 SvTokenStream & rInStm ) 254 { 255 sal_uInt32 nTokPos = rInStm.Tell(); 256 if( rInStm.GetToken()->Is( SvHash_interface() ) 257 || rInStm.GetToken()->Is( SvHash_shell() ) ) 258 { 259 SvMetaClassRef aClass = new SvMetaClass(); 260 if( aClass->ReadSvIdl( rBase, rInStm ) ) 261 { 262 aClassList.Append( aClass ); 263 // Global bekanntgeben 264 rBase.GetClassList().Append( aClass ); 265 } 266 } 267 else if( rInStm.GetToken()->Is( SvHash_enum() ) ) 268 { 269 SvMetaTypeEnumRef aEnum = new SvMetaTypeEnum(); 270 271 if( aEnum->ReadSvIdl( rBase, rInStm ) ) 272 { 273 // Im Modul deklariert 274 aTypeList.Append( aEnum ); 275 // Global bekanntgeben 276 rBase.GetTypeList().Append( aEnum ); 277 } 278 } 279 else if( rInStm.GetToken()->Is( SvHash_item() ) 280 || rInStm.GetToken()->Is( SvHash_struct() ) 281 || rInStm.GetToken()->Is( SvHash_typedef() ) ) 282 { 283 SvMetaTypeRef xItem = new SvMetaType(); 284 285 if( xItem->ReadSvIdl( rBase, rInStm ) ) 286 { 287 // Im Modul deklariert 288 aTypeList.Append( xItem ); 289 // Global bekanntgeben 290 rBase.GetTypeList().Append( xItem ); 291 } 292 } 293 else if( rInStm.GetToken()->Is( SvHash_include() ) ) 294 { 295 sal_Bool bOk = sal_False; 296 rInStm.GetToken_Next(); 297 SvToken * pTok = rInStm.GetToken_Next(); 298 if( pTok->IsString() ) 299 { 300 DirEntry aFullName( String::CreateFromAscii( pTok->GetString().GetBuffer() ) ); 301 rBase.StartNewFile( aFullName.GetFull() ); 302 if( aFullName.Find( rBase.GetPath() ) ) 303 { 304 SvTokenStream aTokStm( aFullName.GetFull() ); 305 if( SVSTREAM_OK == aTokStm.GetStream().GetError() ) 306 { 307 // Fehler aus alter Datei retten 308 SvIdlError aOldErr = rBase.GetError(); 309 // Fehler zuruecksetzen 310 rBase.SetError( SvIdlError() ); 311 312 sal_uInt32 nBeginPos = 0xFFFFFFFF; // kann mit Tell nicht vorkommen 313 while( nBeginPos != aTokStm.Tell() ) 314 { 315 nBeginPos = aTokStm.Tell(); 316 ReadContextSvIdl( rBase, aTokStm ); 317 aTokStm.ReadDelemiter(); 318 } 319 bOk = aTokStm.GetToken()->IsEof(); 320 if( !bOk ) 321 { 322 rBase.WriteError( aTokStm ); 323 } 324 // Fehler aus alter Datei wieder herstellen 325 rBase.SetError( aOldErr ); 326 } 327 else 328 { 329 ByteString aStr = "cannot open file: "; 330 aStr += ByteString( aFullName.GetFull(), RTL_TEXTENCODING_UTF8 ); 331 rBase.SetError( aStr, pTok ); 332 } 333 } 334 else 335 { 336 ByteString aStr = "cannot find file: "; 337 aStr += ByteString( aFullName.GetFull(), RTL_TEXTENCODING_UTF8 ); 338 rBase.SetError( aStr, pTok ); 339 } 340 } 341 if( !bOk ) 342 rInStm.Seek( nTokPos ); 343 } 344 else 345 { 346 SvMetaSlotRef xSlot = new SvMetaSlot(); 347 348 if( xSlot->ReadSvIdl( rBase, rInStm ) ) 349 { 350 if( xSlot->Test( rBase, rInStm ) ) 351 { 352 // Im Modul deklariert 353 aAttrList.Append( xSlot ); 354 // Global bekanntgeben 355 rBase.AppendAttr( xSlot ); 356 } 357 } 358 } 359 } 360 361 /************************************************************************* 362 |* SvMetaModule::WriteContextSvIdl() 363 |* 364 |* Beschreibung 365 *************************************************************************/ 366 void SvMetaModule::WriteContextSvIdl( SvIdlDataBase & rBase, 367 SvStream & rOutStm, 368 sal_uInt16 nTab ) 369 { 370 SvMetaExtern::WriteContextSvIdl( rBase, rOutStm, nTab ); 371 sal_uLong n; 372 for( n = 0; n < aTypeList.Count(); n++ ) 373 { 374 WriteTab( rOutStm, nTab ); 375 aTypeList.GetObject( n )->WriteSvIdl( rBase, rOutStm, nTab ); 376 } 377 rOutStm << endl; 378 for( n = 0; n < aAttrList.Count(); n++ ) 379 { 380 WriteTab( rOutStm, nTab ); 381 aAttrList.GetObject( n )->WriteSvIdl( rBase, rOutStm, nTab ); 382 } 383 rOutStm << endl; 384 for( n = 0; n < aClassList.Count(); n++ ) 385 { 386 WriteTab( rOutStm, nTab ); 387 aClassList.GetObject( n )->WriteSvIdl( rBase, rOutStm, nTab ); 388 } 389 } 390 391 /************************************************************************* 392 |* 393 |* SvMetaModule::ReadSvIdl() 394 |* 395 |* Beschreibung 396 |* 397 *************************************************************************/ 398 sal_Bool SvMetaModule::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm ) 399 { 400 bIsModified = sal_True; // bisher immer wenn Compiler laueft 401 402 sal_uInt32 nTokPos = rInStm.Tell(); 403 SvToken * pTok = rInStm.GetToken_Next(); 404 sal_Bool bOk = sal_False; 405 bOk = pTok->Is( SvHash_module() ); 406 if( bOk ) 407 { 408 pTok = rInStm.GetToken_Next(); 409 if( pTok->IsString() ) 410 bOk = aBeginName.MakeId( String::CreateFromAscii( pTok->GetString().GetBuffer() ) ); 411 } 412 rInStm.ReadDelemiter(); 413 if( bOk ) 414 { 415 pTok = rInStm.GetToken_Next(); 416 if( pTok->IsString() ) 417 bOk = aEndName.MakeId( String::CreateFromAscii( pTok->GetString().GetBuffer() ) ); 418 } 419 rInStm.ReadDelemiter(); 420 if( bOk ) 421 { 422 aNextName = aBeginName; 423 424 rBase.Push( this ); // auf den Context Stack 425 426 if( ReadNameSvIdl( rBase, rInStm ) ) 427 { 428 // Zeiger auf sich selbst setzen 429 SetModule( rBase ); 430 bOk = SvMetaName::ReadSvIdl( rBase, rInStm ); 431 } 432 rBase.GetStack().Pop(); // und runter 433 } 434 if( !bOk ) 435 rInStm.Seek( nTokPos ); 436 return bOk; 437 } 438 439 /************************************************************************* 440 |* 441 |* SvMetaModule::WriteSvIdl() 442 |* 443 |* Beschreibung 444 |* 445 *************************************************************************/ 446 void SvMetaModule::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm, 447 sal_uInt16 nTab ) 448 { 449 rOutStm << SvHash_module()->GetName().GetBuffer() << endl 450 << '\"'; 451 rOutStm.WriteByteString( aBeginName.GetHexName() ); 452 rOutStm << '\"' << endl << '\"'; 453 rOutStm.WriteByteString( aEndName.GetHexName() ); 454 rOutStm << '\"' << endl; 455 SvMetaExtern::WriteSvIdl( rBase, rOutStm, nTab ); 456 } 457 458 /************************************************************************* 459 |* SvMetaModule::WriteSfx() 460 *************************************************************************/ 461 void SvMetaModule::WriteSfx( SvIdlDataBase & rBase, SvStream & rOutStm ) 462 { 463 for( sal_uLong n = 0; n < aClassList.Count(); n++ ) 464 { 465 SvMetaClass * pClass = aClassList.GetObject( n ); 466 pClass->WriteSfx( rBase, rOutStm ); 467 } 468 } 469 470 void SvMetaModule::WriteHelpIds( SvIdlDataBase & rBase, SvStream & rOutStm, 471 Table* pTable ) 472 { 473 for( sal_uLong n = 0; n < aClassList.Count(); n++ ) 474 { 475 SvMetaClass * pClass = aClassList.GetObject( n ); 476 pClass->WriteHelpIds( rBase, rOutStm, pTable ); 477 } 478 } 479 480 /************************************************************************* 481 |* SvMetaModule::WriteAttributes() 482 *************************************************************************/ 483 void SvMetaModule::WriteAttributes( SvIdlDataBase & rBase, 484 SvStream & rOutStm, 485 sal_uInt16 nTab, 486 WriteType nT, WriteAttribute nA ) 487 { 488 SvMetaExtern::WriteAttributes( rBase, rOutStm, nTab, nT, nA ); 489 if( aHelpFileName.Len() ) 490 { 491 WriteTab( rOutStm, nTab ); 492 rOutStm << "// class SvMetaModule" << endl; 493 WriteTab( rOutStm, nTab ); 494 rOutStm << "helpfile(\"" << aHelpFileName.GetBuffer() << "\");" << endl; 495 } 496 } 497 498 /************************************************************************* 499 |* SvMetaModule::WriteSbx() 500 *************************************************************************/ 501 /* 502 void SvMetaModule::WriteSbx( SvIdlDataBase & rBase, SvStream & rOutStm, 503 SvNamePosList & rList ) 504 { 505 for( sal_uLong n = 0; n < aClassList.Count(); n++ ) 506 { 507 SvMetaClass * pClass = aClassList.GetObject( n ); 508 if( !pClass->IsShell() && pClass->GetAutomation() ) 509 { 510 rList.Insert( new SvNamePos( pClass->GetUUId(), rOutStm.Tell() ), 511 LIST_APPEND ); 512 SbxObjectRef xSbxObj = new SbxObject( pClass->GetName() ); 513 pClass->FillSbxObject( rBase, xSbxObj ); 514 xSbxObj->Store( rOutStm ); 515 } 516 } 517 } 518 */ 519 520 /************************************************************************* 521 |* SvMetaModule::Write() 522 *************************************************************************/ 523 void SvMetaModule::Write( SvIdlDataBase & rBase, SvStream & rOutStm, 524 sal_uInt16 nTab, 525 WriteType nT, WriteAttribute nA ) 526 { 527 switch ( nT ) 528 { 529 case WRITE_ODL: 530 { 531 if( aSlotIdFile.Len() ) 532 { 533 WriteTab( rOutStm, nTab ); 534 rOutStm << "#include \"" << aSlotIdFile.GetBuffer() << '"' << endl << endl; 535 } 536 SvMetaExtern::Write( rBase, rOutStm, nTab, nT, nA ); 537 rOutStm << endl; 538 WriteTab( rOutStm, nTab ); 539 rOutStm << "library " << GetName().GetBuffer() << endl; 540 WriteTab( rOutStm, nTab ); 541 rOutStm << '{' << endl; 542 WriteTab( rOutStm, nTab ); 543 rOutStm << "importlib(\"STDOLE.TLB\");" << endl; 544 545 /* 546 for( sal_uLong n = 0; n < aTypeList.Count(); n++ ) 547 { 548 SvMetaType * pType = aTypeList.GetObject( n ); 549 if( !pType ->Write( rBase, rOutStm, nTab +1, nT, nA ) ) 550 return sal_False; 551 } 552 */ 553 /* 554 for( sal_uLong n = 0; n < rBase.GetModuleList().Count(); n++ ) 555 { 556 SvMetaModule * pModule = rBase.GetModuleList().GetObject( n ); 557 const SvMetaTypeMemberList &rTypeList = pModule->GetTypeList(); 558 for( sal_uLong n = 0; n < rTypeList.Count(); n++ ) 559 { 560 SvMetaType * pType = rTypeList.GetObject( n ); 561 pType->Write( rBase, rOutStm, nTab +1, nT, nA ); 562 } 563 } 564 */ 565 566 for( sal_uLong n = 0; n < aClassList.Count(); n++ ) 567 { 568 SvMetaClass * pClass = aClassList.GetObject( n ); 569 if( !pClass->IsShell() && pClass->GetAutomation() ) 570 { 571 WriteTab( rOutStm, nTab ); 572 WriteStars( rOutStm ); 573 pClass->Write( rBase, rOutStm, nTab +1, nT, nA ); 574 if( n +1 < aClassList.Count() ) 575 rOutStm << endl; 576 } 577 } 578 579 rOutStm << '}' << endl; 580 } 581 break; 582 case WRITE_DOCU: 583 { 584 rOutStm << "SvIDL interface documentation" << endl << endl; 585 rOutStm << "<MODULE>" << endl << GetName().GetBuffer() << endl; 586 WriteDescription( rOutStm ); 587 rOutStm << "</MODULE>" << endl << endl; 588 589 rOutStm << "<CLASSES>" << endl; 590 for( sal_uLong n = 0; n < aClassList.Count(); n++ ) 591 { 592 SvMetaClass * pClass = aClassList.GetObject( n ); 593 if( !pClass->IsShell() ) 594 { 595 rOutStm << pClass->GetName().GetBuffer(); 596 SvMetaClass* pSC = pClass->GetSuperClass(); 597 if( pSC ) 598 rOutStm << " : " << pSC->GetName().GetBuffer(); 599 600 // Importierte Klassen 601 const SvClassElementMemberList& rClassList = pClass->GetClassList(); 602 if ( rClassList.Count() ) 603 { 604 rOutStm << " ( "; 605 606 for( sal_uLong m=0; m<rClassList.Count(); m++ ) 607 { 608 SvClassElement *pEle = rClassList.GetObject(m); 609 SvMetaClass *pCl = pEle->GetClass(); 610 rOutStm << pCl->GetName().GetBuffer(); 611 if ( m+1 == rClassList.Count() ) 612 rOutStm << " )"; 613 else 614 rOutStm << " , "; 615 } 616 } 617 618 rOutStm << endl; 619 } 620 } 621 rOutStm << "</CLASSES>" << endl << endl; 622 // kein Break! 623 } 624 625 case WRITE_C_SOURCE: 626 case WRITE_C_HEADER: 627 { 628 for( sal_uLong n = 0; n < aClassList.Count(); n++ ) 629 { 630 SvMetaClass * pClass = aClassList.GetObject( n ); 631 if( !pClass->IsShell() /* && pClass->GetAutomation() */ ) 632 pClass->Write( rBase, rOutStm, nTab, nT, nA ); 633 } 634 } 635 break; 636 637 default: 638 break; 639 } 640 } 641 642 /************************************************************************* 643 |* SvMetaModule::WriteSrc() 644 *************************************************************************/ 645 void SvMetaModule::WriteSrc( SvIdlDataBase & rBase, SvStream & rOutStm, 646 Table * pTable ) 647 { 648 // rOutStm << "#pragma CHARSET IBMPC" << endl; 649 if( aSlotIdFile.Len() ) 650 rOutStm << "//#include <" << aSlotIdFile.GetBuffer() << '>' << endl; 651 for( sal_uLong n = 0; n < aClassList.Count(); n++ ) 652 { 653 aClassList.GetObject( n )->WriteSrc( rBase, rOutStm, pTable ); 654 } 655 } 656 657 /************************************************************************* 658 |* SvMetaModule::WriteHxx() 659 *************************************************************************/ 660 void SvMetaModule::WriteHxx( SvIdlDataBase & rBase, SvStream & rOutStm, 661 sal_uInt16 nTab ) 662 { 663 for( sal_uLong n = 0; n < aClassList.Count(); n++ ) 664 { 665 SvMetaClass * pClass = aClassList.GetObject( n ); 666 pClass->WriteHxx( rBase, rOutStm, nTab ); 667 } 668 } 669 670 /************************************************************************* 671 |* SvMetaModule::WriteCxx() 672 *************************************************************************/ 673 void SvMetaModule::WriteCxx( SvIdlDataBase & rBase, SvStream & rOutStm, 674 sal_uInt16 nTab ) 675 { 676 for( sal_uLong n = 0; n < aClassList.Count(); n++ ) 677 { 678 SvMetaClass * pClass = aClassList.GetObject( n ); 679 pClass->WriteCxx( rBase, rOutStm, nTab ); 680 } 681 } 682 683 #endif // IDL_COMPILER 684 685