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