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