1*b1cdbd2cSJim Jagielski /**************************************************************
2*b1cdbd2cSJim Jagielski *
3*b1cdbd2cSJim Jagielski * Licensed to the Apache Software Foundation (ASF) under one
4*b1cdbd2cSJim Jagielski * or more contributor license agreements. See the NOTICE file
5*b1cdbd2cSJim Jagielski * distributed with this work for additional information
6*b1cdbd2cSJim Jagielski * regarding copyright ownership. The ASF licenses this file
7*b1cdbd2cSJim Jagielski * to you under the Apache License, Version 2.0 (the
8*b1cdbd2cSJim Jagielski * "License"); you may not use this file except in compliance
9*b1cdbd2cSJim Jagielski * with the License. You may obtain a copy of the License at
10*b1cdbd2cSJim Jagielski *
11*b1cdbd2cSJim Jagielski * http://www.apache.org/licenses/LICENSE-2.0
12*b1cdbd2cSJim Jagielski *
13*b1cdbd2cSJim Jagielski * Unless required by applicable law or agreed to in writing,
14*b1cdbd2cSJim Jagielski * software distributed under the License is distributed on an
15*b1cdbd2cSJim Jagielski * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*b1cdbd2cSJim Jagielski * KIND, either express or implied. See the License for the
17*b1cdbd2cSJim Jagielski * specific language governing permissions and limitations
18*b1cdbd2cSJim Jagielski * under the License.
19*b1cdbd2cSJim Jagielski *
20*b1cdbd2cSJim Jagielski *************************************************************/
21*b1cdbd2cSJim Jagielski
22*b1cdbd2cSJim Jagielski
23*b1cdbd2cSJim Jagielski
24*b1cdbd2cSJim Jagielski // MARKER(update_precomp.py): autogen include statement, do not remove
25*b1cdbd2cSJim Jagielski #include "precompiled_idl.hxx"
26*b1cdbd2cSJim Jagielski
27*b1cdbd2cSJim Jagielski #include <ctype.h>
28*b1cdbd2cSJim Jagielski #include <stdio.h>
29*b1cdbd2cSJim Jagielski #include <stdlib.h>
30*b1cdbd2cSJim Jagielski #include <tools/fsys.hxx>
31*b1cdbd2cSJim Jagielski #include <tools/debug.hxx>
32*b1cdbd2cSJim Jagielski #include <database.hxx>
33*b1cdbd2cSJim Jagielski #include <globals.hxx>
34*b1cdbd2cSJim Jagielski
35*b1cdbd2cSJim Jagielski /****************** SvIdlDataBase ****************************************/
36*b1cdbd2cSJim Jagielski /*************************************************************************
37*b1cdbd2cSJim Jagielski |* SvIdlDataBase::SvIdlDataBase()
38*b1cdbd2cSJim Jagielski |*
39*b1cdbd2cSJim Jagielski |* Beschreibung
40*b1cdbd2cSJim Jagielski *************************************************************************/
41*b1cdbd2cSJim Jagielski /*
42*b1cdbd2cSJim Jagielski void PrimeNumber(){
43*b1cdbd2cSJim Jagielski sal_uInt16 i, n;
44*b1cdbd2cSJim Jagielski for( i = 5001; i < 5500; i += 2 ){
45*b1cdbd2cSJim Jagielski for( n = 2; n < i && ((i % n) != 0); n++ );
46*b1cdbd2cSJim Jagielski if( n == i ){
47*b1cdbd2cSJim Jagielski printf( "\nPrimzahl: %d\n", i );
48*b1cdbd2cSJim Jagielski return;
49*b1cdbd2cSJim Jagielski }
50*b1cdbd2cSJim Jagielski }
51*b1cdbd2cSJim Jagielski }
52*b1cdbd2cSJim Jagielski */
53*b1cdbd2cSJim Jagielski
SvIdlDataBase(const SvCommand & rCmd)54*b1cdbd2cSJim Jagielski SvIdlDataBase::SvIdlDataBase( const SvCommand& rCmd )
55*b1cdbd2cSJim Jagielski : bExport( sal_False )
56*b1cdbd2cSJim Jagielski , nUniqueId( 0 )
57*b1cdbd2cSJim Jagielski , nVerbosity( rCmd.nVerbosity )
58*b1cdbd2cSJim Jagielski , bIsModified( sal_False )
59*b1cdbd2cSJim Jagielski , aPersStream( *IDLAPP->pClassMgr, NULL )
60*b1cdbd2cSJim Jagielski , pIdTable( NULL )
61*b1cdbd2cSJim Jagielski {
62*b1cdbd2cSJim Jagielski //PrimeNumber();
63*b1cdbd2cSJim Jagielski }
64*b1cdbd2cSJim Jagielski
65*b1cdbd2cSJim Jagielski /*************************************************************************
66*b1cdbd2cSJim Jagielski |* SvIdlDataBase::~SvIdlDataBase()
67*b1cdbd2cSJim Jagielski |*
68*b1cdbd2cSJim Jagielski |* Beschreibung
69*b1cdbd2cSJim Jagielski *************************************************************************/
~SvIdlDataBase()70*b1cdbd2cSJim Jagielski SvIdlDataBase::~SvIdlDataBase()
71*b1cdbd2cSJim Jagielski {
72*b1cdbd2cSJim Jagielski String * pStr = aIdFileList.First();
73*b1cdbd2cSJim Jagielski while( pStr )
74*b1cdbd2cSJim Jagielski {
75*b1cdbd2cSJim Jagielski delete pStr;
76*b1cdbd2cSJim Jagielski pStr = aIdFileList.Next();
77*b1cdbd2cSJim Jagielski }
78*b1cdbd2cSJim Jagielski delete pIdTable;
79*b1cdbd2cSJim Jagielski }
80*b1cdbd2cSJim Jagielski
81*b1cdbd2cSJim Jagielski /*************************************************************************
82*b1cdbd2cSJim Jagielski |* SvIdlDataBase::GetTypeList()
83*b1cdbd2cSJim Jagielski |*
84*b1cdbd2cSJim Jagielski |* Beschreibung
85*b1cdbd2cSJim Jagielski *************************************************************************/
86*b1cdbd2cSJim Jagielski #define ADD_TYPE( Name, OdlName, ParserChar, CName, BasName, BasPost ) \
87*b1cdbd2cSJim Jagielski aTypeList.Append( new SvMetaType( SvHash_##Name()->GetName(), \
88*b1cdbd2cSJim Jagielski BasName, OdlName, ParserChar, CName, BasName, BasPost ) );
89*b1cdbd2cSJim Jagielski
GetTypeList()90*b1cdbd2cSJim Jagielski SvMetaTypeMemberList & SvIdlDataBase::GetTypeList()
91*b1cdbd2cSJim Jagielski {
92*b1cdbd2cSJim Jagielski if( aTypeList.Count() == 0 )
93*b1cdbd2cSJim Jagielski { // Initial fuellen
94*b1cdbd2cSJim Jagielski aTypeList.Append( new SvMetaTypeString() );
95*b1cdbd2cSJim Jagielski aTypeList.Append( new SvMetaTypevoid() );
96*b1cdbd2cSJim Jagielski
97*b1cdbd2cSJim Jagielski // MI: IDispatch::Invoke kann keine unsigned
98*b1cdbd2cSJim Jagielski ADD_TYPE( UINT16, "long", 'h', "unsigned short", "Long", "&" );
99*b1cdbd2cSJim Jagielski ADD_TYPE( INT16, "short", 'h', "short", "Integer", "%" );
100*b1cdbd2cSJim Jagielski ADD_TYPE( UINT32, "long", 'l', "unsigned long", "Long", "&" );
101*b1cdbd2cSJim Jagielski ADD_TYPE( INT32, "long", 'l', "long", "Long", "&" );
102*b1cdbd2cSJim Jagielski ADD_TYPE( int, "int", 'i', "int", "Integer", "%" );
103*b1cdbd2cSJim Jagielski ADD_TYPE( BOOL, "boolean", 'b', "unsigned char", "Boolean", "" );
104*b1cdbd2cSJim Jagielski ADD_TYPE( char, "char", 'c', "char", "Integer", "%" );
105*b1cdbd2cSJim Jagielski ADD_TYPE( BYTE, "char", 'c', "unsigned char", "Integer", "%" );
106*b1cdbd2cSJim Jagielski ADD_TYPE( float, "float", 'f', "float", "Single", "!" );
107*b1cdbd2cSJim Jagielski ADD_TYPE( double, "double", 'F', "double", "Double", "#" );
108*b1cdbd2cSJim Jagielski ADD_TYPE( SbxObject, "VARIANT", 'o', "C_Object", "Object", "" );
109*b1cdbd2cSJim Jagielski
110*b1cdbd2cSJim Jagielski
111*b1cdbd2cSJim Jagielski // A c h t u n g !!!, bei hinzufuegen von Typen werden alle
112*b1cdbd2cSJim Jagielski // bin�ren Datenbasen inkompatibel
113*b1cdbd2cSJim Jagielski
114*b1cdbd2cSJim Jagielski /*
115*b1cdbd2cSJim Jagielski // So tun als ob die Init-Daten auf einem Stream gelesen wurden
116*b1cdbd2cSJim Jagielski SvMemoryStream aStm;
117*b1cdbd2cSJim Jagielski aPersStream.SetStream( &aStm );
118*b1cdbd2cSJim Jagielski // Alle Init-Daten Streamen
119*b1cdbd2cSJim Jagielski aPersStream << aTypeList;
120*b1cdbd2cSJim Jagielski // Nur die Id-Zuordnung merken
121*b1cdbd2cSJim Jagielski aPersStream.SetStream( NULL );
122*b1cdbd2cSJim Jagielski */
123*b1cdbd2cSJim Jagielski }
124*b1cdbd2cSJim Jagielski return aTypeList;
125*b1cdbd2cSJim Jagielski }
126*b1cdbd2cSJim Jagielski
127*b1cdbd2cSJim Jagielski /*************************************************************************
128*b1cdbd2cSJim Jagielski |*
129*b1cdbd2cSJim Jagielski |* SvIdlDataBase::GetModuleInfo()
130*b1cdbd2cSJim Jagielski |*
131*b1cdbd2cSJim Jagielski |* Beschreibung
132*b1cdbd2cSJim Jagielski |* Ersterstellung MM 13.12.94
133*b1cdbd2cSJim Jagielski |* Letzte Aenderung MM 13.12.94
134*b1cdbd2cSJim Jagielski |*
135*b1cdbd2cSJim Jagielski *************************************************************************/
GetModule(const ByteString & rName)136*b1cdbd2cSJim Jagielski SvMetaModule * SvIdlDataBase::GetModule( const ByteString & rName )
137*b1cdbd2cSJim Jagielski {
138*b1cdbd2cSJim Jagielski for( sal_uLong n = 0; n < aModuleList.Count(); n++ )
139*b1cdbd2cSJim Jagielski if( aModuleList.GetObject( n )->GetName() == rName )
140*b1cdbd2cSJim Jagielski return aModuleList.GetObject( n );
141*b1cdbd2cSJim Jagielski return NULL;
142*b1cdbd2cSJim Jagielski }
143*b1cdbd2cSJim Jagielski
144*b1cdbd2cSJim Jagielski /*************************************************************************
145*b1cdbd2cSJim Jagielski |*
146*b1cdbd2cSJim Jagielski |* SvIdlDataBase::IsBinaryFormat()
147*b1cdbd2cSJim Jagielski |*
148*b1cdbd2cSJim Jagielski |* Beschreibung
149*b1cdbd2cSJim Jagielski |*
150*b1cdbd2cSJim Jagielski *************************************************************************/
151*b1cdbd2cSJim Jagielski #define DATABASE_SIGNATURE (sal_uInt32)0x13B799F2
152*b1cdbd2cSJim Jagielski #define DATABASE_VER 0x0006
IsBinaryFormat(SvStream & rStm)153*b1cdbd2cSJim Jagielski sal_Bool SvIdlDataBase::IsBinaryFormat( SvStream & rStm )
154*b1cdbd2cSJim Jagielski {
155*b1cdbd2cSJim Jagielski sal_uInt32 nSig = 0;
156*b1cdbd2cSJim Jagielski sal_uLong nPos = rStm.Tell();
157*b1cdbd2cSJim Jagielski rStm >> nSig;
158*b1cdbd2cSJim Jagielski rStm.Seek( nPos );
159*b1cdbd2cSJim Jagielski
160*b1cdbd2cSJim Jagielski return nSig == DATABASE_SIGNATURE;
161*b1cdbd2cSJim Jagielski }
162*b1cdbd2cSJim Jagielski
163*b1cdbd2cSJim Jagielski /*************************************************************************
164*b1cdbd2cSJim Jagielski |*
165*b1cdbd2cSJim Jagielski |* SvIdlDataBase::Load()
166*b1cdbd2cSJim Jagielski |*
167*b1cdbd2cSJim Jagielski |* Beschreibung
168*b1cdbd2cSJim Jagielski |*
169*b1cdbd2cSJim Jagielski *************************************************************************/
Load(SvStream & rStm)170*b1cdbd2cSJim Jagielski void SvIdlDataBase::Load( SvStream & rStm )
171*b1cdbd2cSJim Jagielski {
172*b1cdbd2cSJim Jagielski DBG_ASSERT( aTypeList.Count() == 0, "type list already initialized" );
173*b1cdbd2cSJim Jagielski SvPersistStream aPStm( *IDLAPP->pClassMgr, &rStm );
174*b1cdbd2cSJim Jagielski
175*b1cdbd2cSJim Jagielski sal_uInt16 nVersion = 0;
176*b1cdbd2cSJim Jagielski sal_uInt32 nSig = 0;
177*b1cdbd2cSJim Jagielski
178*b1cdbd2cSJim Jagielski aPStm >> nSig;
179*b1cdbd2cSJim Jagielski aPStm >> nVersion;
180*b1cdbd2cSJim Jagielski if( nSig != DATABASE_SIGNATURE )
181*b1cdbd2cSJim Jagielski {
182*b1cdbd2cSJim Jagielski aPStm.SetError( SVSTREAM_FILEFORMAT_ERROR );
183*b1cdbd2cSJim Jagielski return;
184*b1cdbd2cSJim Jagielski }
185*b1cdbd2cSJim Jagielski if( nVersion != DATABASE_VER )
186*b1cdbd2cSJim Jagielski {
187*b1cdbd2cSJim Jagielski aPStm.SetError( SVSTREAM_WRONGVERSION );
188*b1cdbd2cSJim Jagielski return;
189*b1cdbd2cSJim Jagielski }
190*b1cdbd2cSJim Jagielski aPStm >> aClassList;
191*b1cdbd2cSJim Jagielski aPStm >> aTypeList;
192*b1cdbd2cSJim Jagielski aPStm >> aAttrList;
193*b1cdbd2cSJim Jagielski aPStm >> aModuleList;
194*b1cdbd2cSJim Jagielski aPStm >> nUniqueId;
195*b1cdbd2cSJim Jagielski
196*b1cdbd2cSJim Jagielski if( aPStm.IsEof() )
197*b1cdbd2cSJim Jagielski aPStm.SetError( SVSTREAM_GENERALERROR );
198*b1cdbd2cSJim Jagielski }
199*b1cdbd2cSJim Jagielski
200*b1cdbd2cSJim Jagielski /*************************************************************************
201*b1cdbd2cSJim Jagielski |* SvIdlDataBase::Save()
202*b1cdbd2cSJim Jagielski |*
203*b1cdbd2cSJim Jagielski |* Beschreibung
204*b1cdbd2cSJim Jagielski *************************************************************************/
Save(SvStream & rStm,sal_uInt32 nFlags)205*b1cdbd2cSJim Jagielski void SvIdlDataBase::Save( SvStream & rStm, sal_uInt32 nFlags )
206*b1cdbd2cSJim Jagielski {
207*b1cdbd2cSJim Jagielski SvPersistStream aPStm( *IDLAPP->pClassMgr, &rStm );
208*b1cdbd2cSJim Jagielski aPStm.SetContextFlags( nFlags );
209*b1cdbd2cSJim Jagielski
210*b1cdbd2cSJim Jagielski aPStm << (sal_uInt32)DATABASE_SIGNATURE;
211*b1cdbd2cSJim Jagielski aPStm << (sal_uInt16)DATABASE_VER;
212*b1cdbd2cSJim Jagielski
213*b1cdbd2cSJim Jagielski sal_Bool bOnlyStreamedObjs = sal_False;
214*b1cdbd2cSJim Jagielski if( nFlags & IDL_WRITE_CALLING )
215*b1cdbd2cSJim Jagielski bOnlyStreamedObjs = sal_True;
216*b1cdbd2cSJim Jagielski
217*b1cdbd2cSJim Jagielski if( bOnlyStreamedObjs )
218*b1cdbd2cSJim Jagielski {
219*b1cdbd2cSJim Jagielski SvMetaClassMemberList aList;
220*b1cdbd2cSJim Jagielski for( sal_uLong n = 0; n < GetModuleList().Count(); n++ )
221*b1cdbd2cSJim Jagielski {
222*b1cdbd2cSJim Jagielski SvMetaModule * pModule = GetModuleList().GetObject( n );
223*b1cdbd2cSJim Jagielski if( !pModule->IsImported() )
224*b1cdbd2cSJim Jagielski aList.Append( pModule->GetClassList() );
225*b1cdbd2cSJim Jagielski }
226*b1cdbd2cSJim Jagielski aPStm << aList;
227*b1cdbd2cSJim Jagielski }
228*b1cdbd2cSJim Jagielski else
229*b1cdbd2cSJim Jagielski aPStm << aClassList;
230*b1cdbd2cSJim Jagielski
231*b1cdbd2cSJim Jagielski //aClassList.WriteObjects( aPStm, bOnlyStreamedObjs );
232*b1cdbd2cSJim Jagielski aTypeList.WriteObjects( aPStm, bOnlyStreamedObjs );
233*b1cdbd2cSJim Jagielski aAttrList.WriteObjects( aPStm, bOnlyStreamedObjs );
234*b1cdbd2cSJim Jagielski aModuleList.WriteObjects( aPStm, bOnlyStreamedObjs );
235*b1cdbd2cSJim Jagielski aPStm << nUniqueId;
236*b1cdbd2cSJim Jagielski }
237*b1cdbd2cSJim Jagielski
238*b1cdbd2cSJim Jagielski /*************************************************************************
239*b1cdbd2cSJim Jagielski |* SvIdlDataBase::SetError()
240*b1cdbd2cSJim Jagielski |*
241*b1cdbd2cSJim Jagielski |* Beschreibung
242*b1cdbd2cSJim Jagielski *************************************************************************/
SetError(const ByteString & rError,SvToken * pTok)243*b1cdbd2cSJim Jagielski void SvIdlDataBase::SetError( const ByteString & rError, SvToken * pTok )
244*b1cdbd2cSJim Jagielski {
245*b1cdbd2cSJim Jagielski if( pTok->GetLine() > 10000 )
246*b1cdbd2cSJim Jagielski aError.SetText( "hgchcg" );
247*b1cdbd2cSJim Jagielski
248*b1cdbd2cSJim Jagielski if( aError.nLine < pTok->GetLine()
249*b1cdbd2cSJim Jagielski || (aError.nLine == pTok->GetLine() && aError.nColumn < pTok->GetColumn()) )
250*b1cdbd2cSJim Jagielski {
251*b1cdbd2cSJim Jagielski aError = SvIdlError( pTok->GetLine(), pTok->GetColumn() );
252*b1cdbd2cSJim Jagielski aError.SetText( rError );
253*b1cdbd2cSJim Jagielski }
254*b1cdbd2cSJim Jagielski }
255*b1cdbd2cSJim Jagielski
256*b1cdbd2cSJim Jagielski /*************************************************************************
257*b1cdbd2cSJim Jagielski |* SvIdlDataBase::Push()
258*b1cdbd2cSJim Jagielski |*
259*b1cdbd2cSJim Jagielski |* Beschreibung
260*b1cdbd2cSJim Jagielski *************************************************************************/
Push(SvMetaObject * pObj)261*b1cdbd2cSJim Jagielski void SvIdlDataBase::Push( SvMetaObject * pObj )
262*b1cdbd2cSJim Jagielski {
263*b1cdbd2cSJim Jagielski GetStack().Push( pObj );
264*b1cdbd2cSJim Jagielski }
265*b1cdbd2cSJim Jagielski
266*b1cdbd2cSJim Jagielski #ifdef IDL_COMPILER
267*b1cdbd2cSJim Jagielski /*************************************************************************
268*b1cdbd2cSJim Jagielski |*
269*b1cdbd2cSJim Jagielski |* SvIdlDataBase::FindId()
270*b1cdbd2cSJim Jagielski |*
271*b1cdbd2cSJim Jagielski |* Beschreibung
272*b1cdbd2cSJim Jagielski |*
273*b1cdbd2cSJim Jagielski *************************************************************************/
FindId(const ByteString & rIdName,sal_uLong * pVal)274*b1cdbd2cSJim Jagielski sal_Bool SvIdlDataBase::FindId( const ByteString & rIdName, sal_uLong * pVal )
275*b1cdbd2cSJim Jagielski {
276*b1cdbd2cSJim Jagielski if( pIdTable )
277*b1cdbd2cSJim Jagielski {
278*b1cdbd2cSJim Jagielski sal_uInt32 nHash;
279*b1cdbd2cSJim Jagielski if( pIdTable->Test( rIdName, &nHash ) )
280*b1cdbd2cSJim Jagielski {
281*b1cdbd2cSJim Jagielski *pVal = pIdTable->Get( nHash )->GetValue();
282*b1cdbd2cSJim Jagielski return sal_True;
283*b1cdbd2cSJim Jagielski }
284*b1cdbd2cSJim Jagielski }
285*b1cdbd2cSJim Jagielski return sal_False;
286*b1cdbd2cSJim Jagielski }
287*b1cdbd2cSJim Jagielski
288*b1cdbd2cSJim Jagielski /*************************************************************************
289*b1cdbd2cSJim Jagielski |*
290*b1cdbd2cSJim Jagielski |* SvIdlDataBase::InsertId()
291*b1cdbd2cSJim Jagielski |*
292*b1cdbd2cSJim Jagielski |* Beschreibung
293*b1cdbd2cSJim Jagielski |*
294*b1cdbd2cSJim Jagielski *************************************************************************/
InsertId(const ByteString & rIdName,sal_uLong nVal)295*b1cdbd2cSJim Jagielski sal_Bool SvIdlDataBase::InsertId( const ByteString & rIdName, sal_uLong nVal )
296*b1cdbd2cSJim Jagielski {
297*b1cdbd2cSJim Jagielski if( !pIdTable )
298*b1cdbd2cSJim Jagielski pIdTable = new SvStringHashTable( 20003 );
299*b1cdbd2cSJim Jagielski
300*b1cdbd2cSJim Jagielski sal_uInt32 nHash;
301*b1cdbd2cSJim Jagielski if( pIdTable->Insert( rIdName, &nHash ) )
302*b1cdbd2cSJim Jagielski {
303*b1cdbd2cSJim Jagielski pIdTable->Get( nHash )->SetValue( nVal );
304*b1cdbd2cSJim Jagielski return sal_True;
305*b1cdbd2cSJim Jagielski }
306*b1cdbd2cSJim Jagielski return sal_False;
307*b1cdbd2cSJim Jagielski }
308*b1cdbd2cSJim Jagielski
309*b1cdbd2cSJim Jagielski /*************************************************************************
310*b1cdbd2cSJim Jagielski |* SvIdlDataBase::ReadIdFile()
311*b1cdbd2cSJim Jagielski |*
312*b1cdbd2cSJim Jagielski |* Beschreibung
313*b1cdbd2cSJim Jagielski *************************************************************************/
ReadIdFile(const String & rFileName)314*b1cdbd2cSJim Jagielski sal_Bool SvIdlDataBase::ReadIdFile( const String & rFileName )
315*b1cdbd2cSJim Jagielski {
316*b1cdbd2cSJim Jagielski DirEntry aFullName( rFileName );
317*b1cdbd2cSJim Jagielski aFullName.Find( GetPath() );
318*b1cdbd2cSJim Jagielski
319*b1cdbd2cSJim Jagielski String * pIdFile = aIdFileList.First();
320*b1cdbd2cSJim Jagielski while( pIdFile )
321*b1cdbd2cSJim Jagielski {
322*b1cdbd2cSJim Jagielski if( *pIdFile == rFileName )
323*b1cdbd2cSJim Jagielski return sal_True; // schon eingelesen
324*b1cdbd2cSJim Jagielski pIdFile = aIdFileList.Next();
325*b1cdbd2cSJim Jagielski }
326*b1cdbd2cSJim Jagielski
327*b1cdbd2cSJim Jagielski aIdFileList.Insert( new String( rFileName ), LIST_APPEND );
328*b1cdbd2cSJim Jagielski
329*b1cdbd2cSJim Jagielski SvTokenStream aTokStm( aFullName.GetFull() );
330*b1cdbd2cSJim Jagielski if( aTokStm.GetStream().GetError() == SVSTREAM_OK )
331*b1cdbd2cSJim Jagielski {
332*b1cdbd2cSJim Jagielski SvToken * pTok = aTokStm.GetToken_Next();
333*b1cdbd2cSJim Jagielski
334*b1cdbd2cSJim Jagielski while( !pTok->IsEof() )
335*b1cdbd2cSJim Jagielski {
336*b1cdbd2cSJim Jagielski if( pTok->IsChar() && pTok->GetChar() == '#' )
337*b1cdbd2cSJim Jagielski {
338*b1cdbd2cSJim Jagielski pTok = aTokStm.GetToken_Next();
339*b1cdbd2cSJim Jagielski if( pTok->Is( SvHash_define() ) )
340*b1cdbd2cSJim Jagielski {
341*b1cdbd2cSJim Jagielski pTok = aTokStm.GetToken_Next();
342*b1cdbd2cSJim Jagielski ByteString aDefName;
343*b1cdbd2cSJim Jagielski if( pTok->IsIdentifier() )
344*b1cdbd2cSJim Jagielski aDefName = pTok->GetString();
345*b1cdbd2cSJim Jagielski else
346*b1cdbd2cSJim Jagielski {
347*b1cdbd2cSJim Jagielski ByteString aStr( "unexpected token after define" );
348*b1cdbd2cSJim Jagielski // Fehler setzen
349*b1cdbd2cSJim Jagielski SetError( aStr, pTok );
350*b1cdbd2cSJim Jagielski WriteError( aTokStm );
351*b1cdbd2cSJim Jagielski return sal_False;
352*b1cdbd2cSJim Jagielski }
353*b1cdbd2cSJim Jagielski
354*b1cdbd2cSJim Jagielski sal_uLong nVal = 0;
355*b1cdbd2cSJim Jagielski sal_Bool bOk = sal_True;
356*b1cdbd2cSJim Jagielski while( bOk )
357*b1cdbd2cSJim Jagielski {
358*b1cdbd2cSJim Jagielski pTok = aTokStm.GetToken_Next();
359*b1cdbd2cSJim Jagielski if( pTok->IsIdentifier() )
360*b1cdbd2cSJim Jagielski {
361*b1cdbd2cSJim Jagielski sal_uLong n;
362*b1cdbd2cSJim Jagielski if( FindId( pTok->GetString(), &n ) )
363*b1cdbd2cSJim Jagielski nVal += n;
364*b1cdbd2cSJim Jagielski else
365*b1cdbd2cSJim Jagielski bOk = sal_False;
366*b1cdbd2cSJim Jagielski }
367*b1cdbd2cSJim Jagielski else if( pTok->IsChar() )
368*b1cdbd2cSJim Jagielski {
369*b1cdbd2cSJim Jagielski if( pTok->GetChar() == '-'
370*b1cdbd2cSJim Jagielski || pTok->GetChar() == '/'
371*b1cdbd2cSJim Jagielski || pTok->GetChar() == '*'
372*b1cdbd2cSJim Jagielski || pTok->GetChar() == '&'
373*b1cdbd2cSJim Jagielski || pTok->GetChar() == '|'
374*b1cdbd2cSJim Jagielski || pTok->GetChar() == '^'
375*b1cdbd2cSJim Jagielski || pTok->GetChar() == '~' )
376*b1cdbd2cSJim Jagielski {
377*b1cdbd2cSJim Jagielski ByteString aStr( "unknown operator '" );
378*b1cdbd2cSJim Jagielski aStr += pTok->GetChar();
379*b1cdbd2cSJim Jagielski aStr += "'in define";
380*b1cdbd2cSJim Jagielski // Fehler setzen
381*b1cdbd2cSJim Jagielski SetError( aStr, pTok );
382*b1cdbd2cSJim Jagielski WriteError( aTokStm );
383*b1cdbd2cSJim Jagielski return sal_False;
384*b1cdbd2cSJim Jagielski }
385*b1cdbd2cSJim Jagielski if( pTok->GetChar() != '+'
386*b1cdbd2cSJim Jagielski && pTok->GetChar() != '('
387*b1cdbd2cSJim Jagielski && pTok->GetChar() != ')' )
388*b1cdbd2cSJim Jagielski // nur + erlaubt, Klammern spielen kein Rolle,
389*b1cdbd2cSJim Jagielski // da + komutativ ist
390*b1cdbd2cSJim Jagielski break;
391*b1cdbd2cSJim Jagielski }
392*b1cdbd2cSJim Jagielski else if( pTok->IsInteger() )
393*b1cdbd2cSJim Jagielski {
394*b1cdbd2cSJim Jagielski nVal += pTok->GetNumber();
395*b1cdbd2cSJim Jagielski }
396*b1cdbd2cSJim Jagielski else
397*b1cdbd2cSJim Jagielski break;
398*b1cdbd2cSJim Jagielski }
399*b1cdbd2cSJim Jagielski if( bOk )
400*b1cdbd2cSJim Jagielski {
401*b1cdbd2cSJim Jagielski if( !InsertId( aDefName, nVal ) )
402*b1cdbd2cSJim Jagielski {
403*b1cdbd2cSJim Jagielski ByteString aStr = "hash table overflow: ";
404*b1cdbd2cSJim Jagielski SetError( aStr, pTok );
405*b1cdbd2cSJim Jagielski WriteError( aTokStm );
406*b1cdbd2cSJim Jagielski return sal_False;
407*b1cdbd2cSJim Jagielski }
408*b1cdbd2cSJim Jagielski }
409*b1cdbd2cSJim Jagielski }
410*b1cdbd2cSJim Jagielski else if( pTok->Is( SvHash_include() ) )
411*b1cdbd2cSJim Jagielski {
412*b1cdbd2cSJim Jagielski pTok = aTokStm.GetToken_Next();
413*b1cdbd2cSJim Jagielski ByteString aName;
414*b1cdbd2cSJim Jagielski if( pTok->IsString() )
415*b1cdbd2cSJim Jagielski aName = pTok->GetString();
416*b1cdbd2cSJim Jagielski else if( pTok->IsChar() && pTok->GetChar() == '<' )
417*b1cdbd2cSJim Jagielski {
418*b1cdbd2cSJim Jagielski pTok = aTokStm.GetToken_Next();
419*b1cdbd2cSJim Jagielski while( !pTok->IsEof()
420*b1cdbd2cSJim Jagielski && !(pTok->IsChar() && pTok->GetChar() == '>') )
421*b1cdbd2cSJim Jagielski {
422*b1cdbd2cSJim Jagielski aName += pTok->GetTokenAsString();
423*b1cdbd2cSJim Jagielski pTok = aTokStm.GetToken_Next();
424*b1cdbd2cSJim Jagielski }
425*b1cdbd2cSJim Jagielski if( pTok->IsEof() )
426*b1cdbd2cSJim Jagielski {
427*b1cdbd2cSJim Jagielski ByteString aStr( "unexpected eof in #include" );
428*b1cdbd2cSJim Jagielski // Fehler setzen
429*b1cdbd2cSJim Jagielski SetError( aStr, pTok );
430*b1cdbd2cSJim Jagielski WriteError( aTokStm );
431*b1cdbd2cSJim Jagielski return sal_False;
432*b1cdbd2cSJim Jagielski }
433*b1cdbd2cSJim Jagielski }
434*b1cdbd2cSJim Jagielski if( !ReadIdFile( String::CreateFromAscii(aName.GetBuffer()) ) )
435*b1cdbd2cSJim Jagielski {
436*b1cdbd2cSJim Jagielski ByteString aStr = "cannot read file: ";
437*b1cdbd2cSJim Jagielski aStr += aName;
438*b1cdbd2cSJim Jagielski SetError( aStr, pTok );
439*b1cdbd2cSJim Jagielski WriteError( aTokStm );
440*b1cdbd2cSJim Jagielski return sal_False;
441*b1cdbd2cSJim Jagielski }
442*b1cdbd2cSJim Jagielski }
443*b1cdbd2cSJim Jagielski }
444*b1cdbd2cSJim Jagielski else
445*b1cdbd2cSJim Jagielski pTok = aTokStm.GetToken_Next();
446*b1cdbd2cSJim Jagielski }
447*b1cdbd2cSJim Jagielski }
448*b1cdbd2cSJim Jagielski else
449*b1cdbd2cSJim Jagielski return sal_False;
450*b1cdbd2cSJim Jagielski return sal_True;
451*b1cdbd2cSJim Jagielski }
452*b1cdbd2cSJim Jagielski
453*b1cdbd2cSJim Jagielski /*************************************************************************
454*b1cdbd2cSJim Jagielski |* SvIdlDataBase::FindType()
455*b1cdbd2cSJim Jagielski |*
456*b1cdbd2cSJim Jagielski |* Beschreibung
457*b1cdbd2cSJim Jagielski *************************************************************************/
FindType(const SvMetaType * pPType,SvMetaTypeMemberList & rList)458*b1cdbd2cSJim Jagielski SvMetaType * SvIdlDataBase::FindType( const SvMetaType * pPType,
459*b1cdbd2cSJim Jagielski SvMetaTypeMemberList & rList )
460*b1cdbd2cSJim Jagielski {
461*b1cdbd2cSJim Jagielski SvMetaType * pType = rList.First();
462*b1cdbd2cSJim Jagielski while( pType && pPType != pType )
463*b1cdbd2cSJim Jagielski pType = rList.Next();
464*b1cdbd2cSJim Jagielski return pType;
465*b1cdbd2cSJim Jagielski }
466*b1cdbd2cSJim Jagielski
FindType(const ByteString & rName)467*b1cdbd2cSJim Jagielski SvMetaType * SvIdlDataBase::FindType( const ByteString & rName )
468*b1cdbd2cSJim Jagielski {
469*b1cdbd2cSJim Jagielski SvMetaType * pType = aTypeList.First();
470*b1cdbd2cSJim Jagielski while( pType && rName != pType->GetName() )
471*b1cdbd2cSJim Jagielski pType = aTypeList.Next();
472*b1cdbd2cSJim Jagielski return pType;
473*b1cdbd2cSJim Jagielski }
474*b1cdbd2cSJim Jagielski
475*b1cdbd2cSJim Jagielski /*************************************************************************
476*b1cdbd2cSJim Jagielski |* SvIdlDataBase::ReadKnownType()
477*b1cdbd2cSJim Jagielski |*
478*b1cdbd2cSJim Jagielski |* Beschreibung
479*b1cdbd2cSJim Jagielski *************************************************************************/
ReadKnownType(SvTokenStream & rInStm)480*b1cdbd2cSJim Jagielski SvMetaType * SvIdlDataBase::ReadKnownType( SvTokenStream & rInStm )
481*b1cdbd2cSJim Jagielski {
482*b1cdbd2cSJim Jagielski sal_Bool bIn = sal_False;
483*b1cdbd2cSJim Jagielski sal_Bool bOut = sal_False;
484*b1cdbd2cSJim Jagielski int nCall0 = CALL_VALUE;
485*b1cdbd2cSJim Jagielski int nCall1 = CALL_VALUE;
486*b1cdbd2cSJim Jagielski sal_Bool bSet = sal_False; //irgent ein Attribut gesetzt
487*b1cdbd2cSJim Jagielski
488*b1cdbd2cSJim Jagielski sal_uInt32 nTokPos = rInStm.Tell();
489*b1cdbd2cSJim Jagielski SvToken * pTok = rInStm.GetToken_Next();
490*b1cdbd2cSJim Jagielski
491*b1cdbd2cSJim Jagielski if( pTok->HasHash() )
492*b1cdbd2cSJim Jagielski {
493*b1cdbd2cSJim Jagielski sal_uInt32 nBeginPos = 0; // kann mit Tell nicht vorkommen
494*b1cdbd2cSJim Jagielski while( nBeginPos != rInStm.Tell() )
495*b1cdbd2cSJim Jagielski {
496*b1cdbd2cSJim Jagielski nBeginPos = rInStm.Tell();
497*b1cdbd2cSJim Jagielski if( pTok->Is( SvHash_in() ) )
498*b1cdbd2cSJim Jagielski {
499*b1cdbd2cSJim Jagielski bIn = sal_True;
500*b1cdbd2cSJim Jagielski pTok = rInStm.GetToken_Next();
501*b1cdbd2cSJim Jagielski bSet = sal_True;
502*b1cdbd2cSJim Jagielski }
503*b1cdbd2cSJim Jagielski if( pTok->Is( SvHash_out() ) )
504*b1cdbd2cSJim Jagielski {
505*b1cdbd2cSJim Jagielski bOut = sal_True;
506*b1cdbd2cSJim Jagielski pTok = rInStm.GetToken_Next();
507*b1cdbd2cSJim Jagielski bSet = sal_True;
508*b1cdbd2cSJim Jagielski }
509*b1cdbd2cSJim Jagielski if( pTok->Is( SvHash_inout() ) )
510*b1cdbd2cSJim Jagielski {
511*b1cdbd2cSJim Jagielski bIn = sal_True;
512*b1cdbd2cSJim Jagielski bOut = sal_True;
513*b1cdbd2cSJim Jagielski pTok = rInStm.GetToken_Next();
514*b1cdbd2cSJim Jagielski bSet = sal_True;
515*b1cdbd2cSJim Jagielski }
516*b1cdbd2cSJim Jagielski }
517*b1cdbd2cSJim Jagielski }
518*b1cdbd2cSJim Jagielski /*
519*b1cdbd2cSJim Jagielski SvMetaTypeList aTmpTypeList;
520*b1cdbd2cSJim Jagielski if( FillTypeList( aTmpTypeList, pTok ) )
521*b1cdbd2cSJim Jagielski */
522*b1cdbd2cSJim Jagielski if( pTok->IsIdentifier() )
523*b1cdbd2cSJim Jagielski {
524*b1cdbd2cSJim Jagielski ByteString aName = pTok->GetString();
525*b1cdbd2cSJim Jagielski SvMetaTypeMemberList & rList = GetTypeList();
526*b1cdbd2cSJim Jagielski SvMetaType * pType = rList.First();
527*b1cdbd2cSJim Jagielski while( pType )
528*b1cdbd2cSJim Jagielski {
529*b1cdbd2cSJim Jagielski if( pType->GetName() == aName )
530*b1cdbd2cSJim Jagielski break;
531*b1cdbd2cSJim Jagielski pType = rList.Next();
532*b1cdbd2cSJim Jagielski }
533*b1cdbd2cSJim Jagielski if( pType )
534*b1cdbd2cSJim Jagielski {
535*b1cdbd2cSJim Jagielski pTok = rInStm.GetToken();
536*b1cdbd2cSJim Jagielski if( pTok->IsChar() )
537*b1cdbd2cSJim Jagielski {
538*b1cdbd2cSJim Jagielski if( pTok->GetChar() == '&' || pTok->GetChar() == '*' )
539*b1cdbd2cSJim Jagielski {
540*b1cdbd2cSJim Jagielski nCall0 = (pTok->GetChar() == '&') ? CALL_REFERENCE :
541*b1cdbd2cSJim Jagielski CALL_POINTER;
542*b1cdbd2cSJim Jagielski rInStm.GetToken_Next();
543*b1cdbd2cSJim Jagielski pTok = rInStm.GetToken();
544*b1cdbd2cSJim Jagielski if( pTok->GetChar() == '&' || pTok->GetChar() == '*' )
545*b1cdbd2cSJim Jagielski {
546*b1cdbd2cSJim Jagielski nCall1 = (pTok->GetChar() == '&') ? CALL_REFERENCE :
547*b1cdbd2cSJim Jagielski CALL_POINTER;
548*b1cdbd2cSJim Jagielski rInStm.GetToken_Next();
549*b1cdbd2cSJim Jagielski }
550*b1cdbd2cSJim Jagielski bSet = sal_True;
551*b1cdbd2cSJim Jagielski }
552*b1cdbd2cSJim Jagielski }
553*b1cdbd2cSJim Jagielski /*
554*b1cdbd2cSJim Jagielski SvMetaType * pMetaType = aTmpTypeList.First();
555*b1cdbd2cSJim Jagielski while( pMetaType )
556*b1cdbd2cSJim Jagielski {
557*b1cdbd2cSJim Jagielski if( pMetaType->GetIn() == bIn
558*b1cdbd2cSJim Jagielski && pMetaType->GetOut() == bOut
559*b1cdbd2cSJim Jagielski && pMetaType->GetCall0() == nCall0
560*b1cdbd2cSJim Jagielski && pMetaType->GetCall1() == nCall1 )
561*b1cdbd2cSJim Jagielski {
562*b1cdbd2cSJim Jagielski return pMetaType;
563*b1cdbd2cSJim Jagielski }
564*b1cdbd2cSJim Jagielski pMetaType = aTmpTypeList.Next();
565*b1cdbd2cSJim Jagielski }
566*b1cdbd2cSJim Jagielski */
567*b1cdbd2cSJim Jagielski //SvMetaType * pType = aTmpTypeList.First();
568*b1cdbd2cSJim Jagielski if( !bSet )
569*b1cdbd2cSJim Jagielski // Ist genau dieser Typ
570*b1cdbd2cSJim Jagielski return pType;
571*b1cdbd2cSJim Jagielski
572*b1cdbd2cSJim Jagielski DBG_ASSERT( aTmpTypeList.First(), "mindestens ein Element" );
573*b1cdbd2cSJim Jagielski SvMetaTypeRef xType = new SvMetaType( pType->GetName(), 'h', "dummy" );
574*b1cdbd2cSJim Jagielski xType->SetRef( pType );
575*b1cdbd2cSJim Jagielski xType->SetIn( bIn );
576*b1cdbd2cSJim Jagielski xType->SetOut( bOut );
577*b1cdbd2cSJim Jagielski xType->SetCall0( nCall0 );
578*b1cdbd2cSJim Jagielski xType->SetCall1( nCall1 );
579*b1cdbd2cSJim Jagielski
580*b1cdbd2cSJim Jagielski aTmpTypeList.Append( xType );
581*b1cdbd2cSJim Jagielski return xType;
582*b1cdbd2cSJim Jagielski }
583*b1cdbd2cSJim Jagielski }
584*b1cdbd2cSJim Jagielski rInStm.Seek( nTokPos );
585*b1cdbd2cSJim Jagielski return NULL;
586*b1cdbd2cSJim Jagielski }
587*b1cdbd2cSJim Jagielski
588*b1cdbd2cSJim Jagielski /*************************************************************************
589*b1cdbd2cSJim Jagielski |*
590*b1cdbd2cSJim Jagielski |* SvIdlDataBase::ReadKnownAttr()
591*b1cdbd2cSJim Jagielski |*
592*b1cdbd2cSJim Jagielski |* Beschreibung
593*b1cdbd2cSJim Jagielski |*
594*b1cdbd2cSJim Jagielski *************************************************************************/
ReadKnownAttr(SvTokenStream & rInStm,SvMetaType * pType)595*b1cdbd2cSJim Jagielski SvMetaAttribute * SvIdlDataBase::ReadKnownAttr
596*b1cdbd2cSJim Jagielski (
597*b1cdbd2cSJim Jagielski SvTokenStream & rInStm,
598*b1cdbd2cSJim Jagielski SvMetaType * pType /* Wenn der pType == NULL, dann muss der Typ
599*b1cdbd2cSJim Jagielski noch gelesen werden. */
600*b1cdbd2cSJim Jagielski )
601*b1cdbd2cSJim Jagielski {
602*b1cdbd2cSJim Jagielski sal_uInt32 nTokPos = rInStm.Tell();
603*b1cdbd2cSJim Jagielski
604*b1cdbd2cSJim Jagielski if( !pType )
605*b1cdbd2cSJim Jagielski pType = ReadKnownType( rInStm );
606*b1cdbd2cSJim Jagielski
607*b1cdbd2cSJim Jagielski if( pType )
608*b1cdbd2cSJim Jagielski {
609*b1cdbd2cSJim Jagielski // Wenn wir Slots auf die Wiese stellen, d"urfen wir nicht voraussetzen,
610*b1cdbd2cSJim Jagielski // da\s jeder Slot einen anderen Namen hat!
611*b1cdbd2cSJim Jagielski /*
612*b1cdbd2cSJim Jagielski SvToken * pTok = rInStm.GetToken_Next();
613*b1cdbd2cSJim Jagielski if( pTok->IsIdentifier() )
614*b1cdbd2cSJim Jagielski for( sal_uLong n = 0; n < aAttrList.Count(); n++ )
615*b1cdbd2cSJim Jagielski {
616*b1cdbd2cSJim Jagielski SvMetaAttribute * pAttr = aAttrList.GetObject( n );
617*b1cdbd2cSJim Jagielski if( pAttr->GetName() == pTok->GetString() )
618*b1cdbd2cSJim Jagielski return pAttr;
619*b1cdbd2cSJim Jagielski }
620*b1cdbd2cSJim Jagielski */
621*b1cdbd2cSJim Jagielski }
622*b1cdbd2cSJim Jagielski else
623*b1cdbd2cSJim Jagielski {
624*b1cdbd2cSJim Jagielski // sonst SlotId?
625*b1cdbd2cSJim Jagielski SvToken * pTok = rInStm.GetToken_Next();
626*b1cdbd2cSJim Jagielski if( pTok->IsIdentifier() )
627*b1cdbd2cSJim Jagielski {
628*b1cdbd2cSJim Jagielski sal_uLong n;
629*b1cdbd2cSJim Jagielski if( FindId( pTok->GetString(), &n ) )
630*b1cdbd2cSJim Jagielski {
631*b1cdbd2cSJim Jagielski for( sal_uLong i = 0; i < aAttrList.Count(); i++ )
632*b1cdbd2cSJim Jagielski {
633*b1cdbd2cSJim Jagielski SvMetaAttribute * pAttr = aAttrList.GetObject( i );
634*b1cdbd2cSJim Jagielski if( pAttr->GetSlotId() == pTok->GetString() )
635*b1cdbd2cSJim Jagielski return pAttr;
636*b1cdbd2cSJim Jagielski }
637*b1cdbd2cSJim Jagielski }
638*b1cdbd2cSJim Jagielski
639*b1cdbd2cSJim Jagielski ByteString aStr( "Nicht gefunden : " );
640*b1cdbd2cSJim Jagielski aStr += pTok->GetString();
641*b1cdbd2cSJim Jagielski DBG_ERROR( aStr.GetBuffer() );
642*b1cdbd2cSJim Jagielski }
643*b1cdbd2cSJim Jagielski }
644*b1cdbd2cSJim Jagielski
645*b1cdbd2cSJim Jagielski rInStm.Seek( nTokPos );
646*b1cdbd2cSJim Jagielski return NULL;
647*b1cdbd2cSJim Jagielski }
648*b1cdbd2cSJim Jagielski
SearchKnownAttr(const SvNumberIdentifier & rId)649*b1cdbd2cSJim Jagielski SvMetaAttribute* SvIdlDataBase::SearchKnownAttr
650*b1cdbd2cSJim Jagielski (
651*b1cdbd2cSJim Jagielski const SvNumberIdentifier& rId
652*b1cdbd2cSJim Jagielski )
653*b1cdbd2cSJim Jagielski {
654*b1cdbd2cSJim Jagielski sal_uLong n;
655*b1cdbd2cSJim Jagielski if( FindId( rId, &n ) )
656*b1cdbd2cSJim Jagielski {
657*b1cdbd2cSJim Jagielski for( sal_uLong i = 0; i < aAttrList.Count(); i++ )
658*b1cdbd2cSJim Jagielski {
659*b1cdbd2cSJim Jagielski SvMetaAttribute * pAttr = aAttrList.GetObject( i );
660*b1cdbd2cSJim Jagielski if( pAttr->GetSlotId() == rId )
661*b1cdbd2cSJim Jagielski return pAttr;
662*b1cdbd2cSJim Jagielski }
663*b1cdbd2cSJim Jagielski }
664*b1cdbd2cSJim Jagielski
665*b1cdbd2cSJim Jagielski return NULL;
666*b1cdbd2cSJim Jagielski }
667*b1cdbd2cSJim Jagielski
668*b1cdbd2cSJim Jagielski /*************************************************************************
669*b1cdbd2cSJim Jagielski |* SvIdlDataBase::ReadKnownClass()
670*b1cdbd2cSJim Jagielski |*
671*b1cdbd2cSJim Jagielski |* Beschreibung
672*b1cdbd2cSJim Jagielski *************************************************************************/
ReadKnownClass(SvTokenStream & rInStm)673*b1cdbd2cSJim Jagielski SvMetaClass * SvIdlDataBase::ReadKnownClass( SvTokenStream & rInStm )
674*b1cdbd2cSJim Jagielski {
675*b1cdbd2cSJim Jagielski sal_uInt32 nTokPos = rInStm.Tell();
676*b1cdbd2cSJim Jagielski SvToken * pTok = rInStm.GetToken_Next();
677*b1cdbd2cSJim Jagielski
678*b1cdbd2cSJim Jagielski if( pTok->IsIdentifier() )
679*b1cdbd2cSJim Jagielski for( sal_uLong n = 0; n < aClassList.Count(); n++ )
680*b1cdbd2cSJim Jagielski {
681*b1cdbd2cSJim Jagielski SvMetaClass * pClass = aClassList.GetObject( n );
682*b1cdbd2cSJim Jagielski if( pClass->GetName() == pTok->GetString() )
683*b1cdbd2cSJim Jagielski return pClass;
684*b1cdbd2cSJim Jagielski }
685*b1cdbd2cSJim Jagielski
686*b1cdbd2cSJim Jagielski rInStm.Seek( nTokPos );
687*b1cdbd2cSJim Jagielski return NULL;
688*b1cdbd2cSJim Jagielski }
689*b1cdbd2cSJim Jagielski
690*b1cdbd2cSJim Jagielski /*************************************************************************
691*b1cdbd2cSJim Jagielski |* SvIdlDataBase::Write()
692*b1cdbd2cSJim Jagielski |*
693*b1cdbd2cSJim Jagielski |* Beschreibung
694*b1cdbd2cSJim Jagielski *************************************************************************/
Write(const ByteString & rText)695*b1cdbd2cSJim Jagielski void SvIdlDataBase::Write( const ByteString & rText )
696*b1cdbd2cSJim Jagielski {
697*b1cdbd2cSJim Jagielski if( nVerbosity != 0 )
698*b1cdbd2cSJim Jagielski fprintf( stdout, "%s", rText.GetBuffer() );
699*b1cdbd2cSJim Jagielski }
700*b1cdbd2cSJim Jagielski
701*b1cdbd2cSJim Jagielski /*************************************************************************
702*b1cdbd2cSJim Jagielski |* SvIdlDataBase::WriteError()
703*b1cdbd2cSJim Jagielski |*
704*b1cdbd2cSJim Jagielski |* Beschreibung
705*b1cdbd2cSJim Jagielski *************************************************************************/
WriteError(const ByteString & rErrWrn,const ByteString & rFileName,const ByteString & rErrorText,sal_uLong nRow,sal_uLong nColumn) const706*b1cdbd2cSJim Jagielski void SvIdlDataBase::WriteError( const ByteString & rErrWrn,
707*b1cdbd2cSJim Jagielski const ByteString & rFileName,
708*b1cdbd2cSJim Jagielski const ByteString & rErrorText,
709*b1cdbd2cSJim Jagielski sal_uLong nRow, sal_uLong nColumn ) const
710*b1cdbd2cSJim Jagielski {
711*b1cdbd2cSJim Jagielski //Fehlerbehandlung
712*b1cdbd2cSJim Jagielski fprintf( stderr, "\n%s --- %s: ( %ld, %ld )\n",
713*b1cdbd2cSJim Jagielski rFileName.GetBuffer(), rErrWrn.GetBuffer(), nRow, nColumn );
714*b1cdbd2cSJim Jagielski
715*b1cdbd2cSJim Jagielski if( rErrorText.Len() )
716*b1cdbd2cSJim Jagielski { // Fehler gesetzt
717*b1cdbd2cSJim Jagielski fprintf( stderr, "\t%s\n", rErrorText.GetBuffer() );
718*b1cdbd2cSJim Jagielski }
719*b1cdbd2cSJim Jagielski }
720*b1cdbd2cSJim Jagielski
721*b1cdbd2cSJim Jagielski /*************************************************************************
722*b1cdbd2cSJim Jagielski |* SvIdlDataBase::WriteError()
723*b1cdbd2cSJim Jagielski |*
724*b1cdbd2cSJim Jagielski |* Beschreibung
725*b1cdbd2cSJim Jagielski *************************************************************************/
WriteError(SvTokenStream & rInStm)726*b1cdbd2cSJim Jagielski void SvIdlDataBase::WriteError( SvTokenStream & rInStm )
727*b1cdbd2cSJim Jagielski {
728*b1cdbd2cSJim Jagielski //Fehlerbehandlung
729*b1cdbd2cSJim Jagielski String aFileName( rInStm.GetFileName() );
730*b1cdbd2cSJim Jagielski ByteString aErrorText;
731*b1cdbd2cSJim Jagielski sal_uLong nRow = 0, nColumn = 0;
732*b1cdbd2cSJim Jagielski
733*b1cdbd2cSJim Jagielski rInStm.SeekEnd();
734*b1cdbd2cSJim Jagielski SvToken *pTok = rInStm.GetToken();
735*b1cdbd2cSJim Jagielski
736*b1cdbd2cSJim Jagielski // Fehlerposition
737*b1cdbd2cSJim Jagielski nRow = pTok->GetLine();
738*b1cdbd2cSJim Jagielski nColumn = pTok->GetColumn();
739*b1cdbd2cSJim Jagielski
740*b1cdbd2cSJim Jagielski if( aError.IsError() )
741*b1cdbd2cSJim Jagielski { // Fehler gesetzt
742*b1cdbd2cSJim Jagielski // Fehler Token suchen
743*b1cdbd2cSJim Jagielski // Fehlertext
744*b1cdbd2cSJim Jagielski if( aError.GetText().Len() )
745*b1cdbd2cSJim Jagielski {
746*b1cdbd2cSJim Jagielski aErrorText = "may be <";
747*b1cdbd2cSJim Jagielski aErrorText += aError.GetText();
748*b1cdbd2cSJim Jagielski }
749*b1cdbd2cSJim Jagielski SvToken * pPrevTok = NULL;
750*b1cdbd2cSJim Jagielski while( pTok != pPrevTok )
751*b1cdbd2cSJim Jagielski {
752*b1cdbd2cSJim Jagielski pPrevTok = pTok;
753*b1cdbd2cSJim Jagielski if( pTok->GetLine() == aError.nLine
754*b1cdbd2cSJim Jagielski && pTok->GetColumn() == aError.nColumn )
755*b1cdbd2cSJim Jagielski break;
756*b1cdbd2cSJim Jagielski pTok = rInStm.GetToken_PrevAll();
757*b1cdbd2cSJim Jagielski }
758*b1cdbd2cSJim Jagielski
759*b1cdbd2cSJim Jagielski // Fehlerposition
760*b1cdbd2cSJim Jagielski aErrorText += "> at ( ";
761*b1cdbd2cSJim Jagielski aErrorText += ByteString::CreateFromInt64(aError.nLine);
762*b1cdbd2cSJim Jagielski aErrorText += ", ";
763*b1cdbd2cSJim Jagielski aErrorText += ByteString::CreateFromInt64(aError.nColumn);
764*b1cdbd2cSJim Jagielski aErrorText += " )";
765*b1cdbd2cSJim Jagielski
766*b1cdbd2cSJim Jagielski // Fehler zuruecksetzen
767*b1cdbd2cSJim Jagielski aError = SvIdlError();
768*b1cdbd2cSJim Jagielski }
769*b1cdbd2cSJim Jagielski
770*b1cdbd2cSJim Jagielski WriteError( "error", ByteString( aFileName, RTL_TEXTENCODING_UTF8 ), aErrorText, nRow, nColumn );
771*b1cdbd2cSJim Jagielski
772*b1cdbd2cSJim Jagielski DBG_ASSERT( pTok, "token must be found" );
773*b1cdbd2cSJim Jagielski if( !pTok )
774*b1cdbd2cSJim Jagielski return;
775*b1cdbd2cSJim Jagielski
776*b1cdbd2cSJim Jagielski // Identifier in der Naehe suchen
777*b1cdbd2cSJim Jagielski if( !pTok->IsIdentifier() )
778*b1cdbd2cSJim Jagielski {
779*b1cdbd2cSJim Jagielski rInStm.GetToken_PrevAll();
780*b1cdbd2cSJim Jagielski pTok = rInStm.GetToken();
781*b1cdbd2cSJim Jagielski }
782*b1cdbd2cSJim Jagielski if( pTok && pTok->IsIdentifier() )
783*b1cdbd2cSJim Jagielski {
784*b1cdbd2cSJim Jagielski ByteString aN = IDLAPP->pHashTable->GetNearString( pTok->GetString() );
785*b1cdbd2cSJim Jagielski if( aN.Len() )
786*b1cdbd2cSJim Jagielski fprintf( stderr, "%s versus %s\n", pTok->GetString().GetBuffer(), aN.GetBuffer() );
787*b1cdbd2cSJim Jagielski }
788*b1cdbd2cSJim Jagielski }
789*b1cdbd2cSJim Jagielski
790*b1cdbd2cSJim Jagielski /****************** SvIdlWorkingBase ****************************************/
791*b1cdbd2cSJim Jagielski /*************************************************************************
792*b1cdbd2cSJim Jagielski |* SvIdlWorkingBase::SvIdlWorkingBase()
793*b1cdbd2cSJim Jagielski |*
794*b1cdbd2cSJim Jagielski |* Beschreibung
795*b1cdbd2cSJim Jagielski *************************************************************************/
SvIdlWorkingBase(const SvCommand & rCmd)796*b1cdbd2cSJim Jagielski SvIdlWorkingBase::SvIdlWorkingBase(const SvCommand& rCmd) : SvIdlDataBase(rCmd)
797*b1cdbd2cSJim Jagielski {
798*b1cdbd2cSJim Jagielski }
799*b1cdbd2cSJim Jagielski
800*b1cdbd2cSJim Jagielski /*************************************************************************
801*b1cdbd2cSJim Jagielski |* SvIdlWorkingBase::ReadSvIdl()
802*b1cdbd2cSJim Jagielski |*
803*b1cdbd2cSJim Jagielski |* Beschreibung
804*b1cdbd2cSJim Jagielski *************************************************************************/
ReadSvIdl(SvTokenStream & rInStm,sal_Bool bImported,const String & rPath)805*b1cdbd2cSJim Jagielski sal_Bool SvIdlWorkingBase::ReadSvIdl( SvTokenStream & rInStm, sal_Bool bImported, const String & rPath )
806*b1cdbd2cSJim Jagielski {
807*b1cdbd2cSJim Jagielski aPath = rPath; // nur fuer den durchlauf gueltig
808*b1cdbd2cSJim Jagielski SvToken * pTok;
809*b1cdbd2cSJim Jagielski sal_Bool bOk = sal_True;
810*b1cdbd2cSJim Jagielski pTok = rInStm.GetToken();
811*b1cdbd2cSJim Jagielski // nur ein import ganz am Anfang
812*b1cdbd2cSJim Jagielski if( pTok->Is( SvHash_import() ) )
813*b1cdbd2cSJim Jagielski {
814*b1cdbd2cSJim Jagielski rInStm.GetToken_Next();
815*b1cdbd2cSJim Jagielski rInStm.Read( '(' ); // optional
816*b1cdbd2cSJim Jagielski pTok = rInStm.GetToken_Next();
817*b1cdbd2cSJim Jagielski if( pTok->IsString() )
818*b1cdbd2cSJim Jagielski {
819*b1cdbd2cSJim Jagielski DirEntry aFullName( String::CreateFromAscii( pTok->GetString().GetBuffer() ) );
820*b1cdbd2cSJim Jagielski if( aFullName.Find( rPath ) )
821*b1cdbd2cSJim Jagielski {
822*b1cdbd2cSJim Jagielski SvFileStream aStm( aFullName.GetFull(),
823*b1cdbd2cSJim Jagielski STREAM_STD_READ | STREAM_NOCREATE );
824*b1cdbd2cSJim Jagielski Load( aStm );
825*b1cdbd2cSJim Jagielski if( aStm.GetError() != SVSTREAM_OK )
826*b1cdbd2cSJim Jagielski {
827*b1cdbd2cSJim Jagielski if( aStm.GetError() == SVSTREAM_WRONGVERSION )
828*b1cdbd2cSJim Jagielski {
829*b1cdbd2cSJim Jagielski ByteString aStr( "wrong version, file " );
830*b1cdbd2cSJim Jagielski aStr += ByteString( aFullName.GetFull(), RTL_TEXTENCODING_UTF8 );
831*b1cdbd2cSJim Jagielski SetError( aStr, pTok );
832*b1cdbd2cSJim Jagielski WriteError( rInStm );
833*b1cdbd2cSJim Jagielski bOk = sal_False;
834*b1cdbd2cSJim Jagielski }
835*b1cdbd2cSJim Jagielski else
836*b1cdbd2cSJim Jagielski {
837*b1cdbd2cSJim Jagielski aStm.Seek( 0 );
838*b1cdbd2cSJim Jagielski aStm.ResetError();
839*b1cdbd2cSJim Jagielski SvTokenStream aTokStm( aStm, aFullName.GetFull() );
840*b1cdbd2cSJim Jagielski bOk = ReadSvIdl( aTokStm, sal_True, rPath );
841*b1cdbd2cSJim Jagielski }
842*b1cdbd2cSJim Jagielski }
843*b1cdbd2cSJim Jagielski }
844*b1cdbd2cSJim Jagielski else
845*b1cdbd2cSJim Jagielski bOk = sal_False;
846*b1cdbd2cSJim Jagielski }
847*b1cdbd2cSJim Jagielski else
848*b1cdbd2cSJim Jagielski bOk = sal_False;
849*b1cdbd2cSJim Jagielski }
850*b1cdbd2cSJim Jagielski
851*b1cdbd2cSJim Jagielski sal_uInt32 nBeginPos = 0xFFFFFFFF; // kann mit Tell nicht vorkommen
852*b1cdbd2cSJim Jagielski
853*b1cdbd2cSJim Jagielski while( bOk && nBeginPos != rInStm.Tell() )
854*b1cdbd2cSJim Jagielski {
855*b1cdbd2cSJim Jagielski nBeginPos = rInStm.Tell();
856*b1cdbd2cSJim Jagielski pTok = rInStm.GetToken();
857*b1cdbd2cSJim Jagielski if( pTok->IsEof() )
858*b1cdbd2cSJim Jagielski return sal_True;
859*b1cdbd2cSJim Jagielski if( pTok->IsEmpty() )
860*b1cdbd2cSJim Jagielski bOk = sal_False;
861*b1cdbd2cSJim Jagielski
862*b1cdbd2cSJim Jagielski // nur ein import ganz am Anfang
863*b1cdbd2cSJim Jagielski /*else */if( pTok->Is( SvHash_module() ) )
864*b1cdbd2cSJim Jagielski {
865*b1cdbd2cSJim Jagielski SvMetaModuleRef aModule = new SvMetaModule( rInStm.GetFileName(), bImported );
866*b1cdbd2cSJim Jagielski if( aModule->ReadSvIdl( *this, rInStm ) )
867*b1cdbd2cSJim Jagielski GetModuleList().Append( aModule );
868*b1cdbd2cSJim Jagielski else
869*b1cdbd2cSJim Jagielski bOk = sal_False;
870*b1cdbd2cSJim Jagielski }
871*b1cdbd2cSJim Jagielski else
872*b1cdbd2cSJim Jagielski bOk = sal_False;
873*b1cdbd2cSJim Jagielski }
874*b1cdbd2cSJim Jagielski if( !bOk || !pTok->IsEof() )
875*b1cdbd2cSJim Jagielski {
876*b1cdbd2cSJim Jagielski //Fehlerbehandlung
877*b1cdbd2cSJim Jagielski WriteError( rInStm );
878*b1cdbd2cSJim Jagielski return sal_False;
879*b1cdbd2cSJim Jagielski }
880*b1cdbd2cSJim Jagielski return sal_True;
881*b1cdbd2cSJim Jagielski }
882*b1cdbd2cSJim Jagielski
883*b1cdbd2cSJim Jagielski /*************************************************************************
884*b1cdbd2cSJim Jagielski |* SvIdlWorkingBase::WriteSvIdl()
885*b1cdbd2cSJim Jagielski |*
886*b1cdbd2cSJim Jagielski |* Beschreibung
887*b1cdbd2cSJim Jagielski *************************************************************************/
WriteSvIdl(SvStream & rOutStm)888*b1cdbd2cSJim Jagielski sal_Bool SvIdlWorkingBase::WriteSvIdl( SvStream & rOutStm )
889*b1cdbd2cSJim Jagielski {
890*b1cdbd2cSJim Jagielski if( rOutStm.GetError() != SVSTREAM_OK )
891*b1cdbd2cSJim Jagielski return sal_False;
892*b1cdbd2cSJim Jagielski
893*b1cdbd2cSJim Jagielski SvStringHashList aList;
894*b1cdbd2cSJim Jagielski if( GetIdTable() )
895*b1cdbd2cSJim Jagielski {
896*b1cdbd2cSJim Jagielski GetIdTable()->FillHashList( &aList );
897*b1cdbd2cSJim Jagielski SvStringHashEntry * pEntry = aList.First();
898*b1cdbd2cSJim Jagielski while( pEntry )
899*b1cdbd2cSJim Jagielski {
900*b1cdbd2cSJim Jagielski rOutStm << "#define " << pEntry->GetName().GetBuffer()
901*b1cdbd2cSJim Jagielski << '\t'
902*b1cdbd2cSJim Jagielski << ByteString::CreateFromInt64(
903*b1cdbd2cSJim Jagielski pEntry->GetValue() ).GetBuffer()
904*b1cdbd2cSJim Jagielski << endl;
905*b1cdbd2cSJim Jagielski pEntry = aList.Next();
906*b1cdbd2cSJim Jagielski }
907*b1cdbd2cSJim Jagielski }
908*b1cdbd2cSJim Jagielski
909*b1cdbd2cSJim Jagielski for( sal_uLong n = 0; n < GetModuleList().Count(); n++ )
910*b1cdbd2cSJim Jagielski {
911*b1cdbd2cSJim Jagielski SvMetaModule * pModule = GetModuleList().GetObject( n );
912*b1cdbd2cSJim Jagielski //if( !pModule->IsImported() )
913*b1cdbd2cSJim Jagielski pModule->WriteSvIdl( *this, rOutStm, 0 );
914*b1cdbd2cSJim Jagielski }
915*b1cdbd2cSJim Jagielski return sal_True;
916*b1cdbd2cSJim Jagielski }
917*b1cdbd2cSJim Jagielski
918*b1cdbd2cSJim Jagielski /*************************************************************************
919*b1cdbd2cSJim Jagielski |* SvIdlWorkingBase::WriteSfx()
920*b1cdbd2cSJim Jagielski |*
921*b1cdbd2cSJim Jagielski |* Beschreibung
922*b1cdbd2cSJim Jagielski *************************************************************************/
WriteSfx(SvStream & rOutStm)923*b1cdbd2cSJim Jagielski sal_Bool SvIdlWorkingBase::WriteSfx( SvStream & rOutStm )
924*b1cdbd2cSJim Jagielski {
925*b1cdbd2cSJim Jagielski if( rOutStm.GetError() != SVSTREAM_OK )
926*b1cdbd2cSJim Jagielski return sal_False;
927*b1cdbd2cSJim Jagielski
928*b1cdbd2cSJim Jagielski // alle Tmp-Variablen fuer das Schreiben zuruecksetzen
929*b1cdbd2cSJim Jagielski WriteReset();
930*b1cdbd2cSJim Jagielski SvMemoryStream aTmpStm( 256000, 256000 );
931*b1cdbd2cSJim Jagielski sal_uLong n;
932*b1cdbd2cSJim Jagielski for( n = 0; n < GetModuleList().Count(); n++ )
933*b1cdbd2cSJim Jagielski {
934*b1cdbd2cSJim Jagielski SvMetaModule * pModule = GetModuleList().GetObject( n );
935*b1cdbd2cSJim Jagielski if( !pModule->IsImported() )
936*b1cdbd2cSJim Jagielski pModule->WriteSfx( *this, aTmpStm );
937*b1cdbd2cSJim Jagielski aTmpStm.Seek( 0 );
938*b1cdbd2cSJim Jagielski }
939*b1cdbd2cSJim Jagielski for( n = 0; n < aUsedTypes.Count(); n++ )
940*b1cdbd2cSJim Jagielski {
941*b1cdbd2cSJim Jagielski SvMetaType * pType = aUsedTypes.GetObject( n );
942*b1cdbd2cSJim Jagielski pType->WriteSfx( *this, rOutStm );
943*b1cdbd2cSJim Jagielski }
944*b1cdbd2cSJim Jagielski aUsedTypes.Clear();
945*b1cdbd2cSJim Jagielski rOutStm << aTmpStm;
946*b1cdbd2cSJim Jagielski return sal_True;
947*b1cdbd2cSJim Jagielski }
948*b1cdbd2cSJim Jagielski
WriteHelpIds(SvStream & rOutStm)949*b1cdbd2cSJim Jagielski sal_Bool SvIdlWorkingBase::WriteHelpIds( SvStream& rOutStm )
950*b1cdbd2cSJim Jagielski {
951*b1cdbd2cSJim Jagielski if( rOutStm.GetError() != SVSTREAM_OK )
952*b1cdbd2cSJim Jagielski return sal_False;
953*b1cdbd2cSJim Jagielski
954*b1cdbd2cSJim Jagielski Table aIdTable;
955*b1cdbd2cSJim Jagielski sal_uLong n;
956*b1cdbd2cSJim Jagielski for( n = 0; n < GetModuleList().Count(); n++ )
957*b1cdbd2cSJim Jagielski {
958*b1cdbd2cSJim Jagielski SvMetaModule * pModule = GetModuleList().GetObject( n );
959*b1cdbd2cSJim Jagielski //if( !pModule->IsImported() )
960*b1cdbd2cSJim Jagielski pModule->WriteHelpIds( *this, rOutStm, &aIdTable );
961*b1cdbd2cSJim Jagielski }
962*b1cdbd2cSJim Jagielski
963*b1cdbd2cSJim Jagielski const SvMetaAttributeMemberList & rAttrList = GetAttrList();
964*b1cdbd2cSJim Jagielski for( n = 0; n < rAttrList.Count(); n++ )
965*b1cdbd2cSJim Jagielski {
966*b1cdbd2cSJim Jagielski SvMetaAttribute * pAttr = rAttrList.GetObject( n );
967*b1cdbd2cSJim Jagielski pAttr->WriteHelpId( *this, rOutStm, &aIdTable );
968*b1cdbd2cSJim Jagielski }
969*b1cdbd2cSJim Jagielski
970*b1cdbd2cSJim Jagielski return sal_True;
971*b1cdbd2cSJim Jagielski }
972*b1cdbd2cSJim Jagielski
973*b1cdbd2cSJim Jagielski /*************************************************************************
974*b1cdbd2cSJim Jagielski |* SvIdlWorkingBase::WriteSfxItem()
975*b1cdbd2cSJim Jagielski |*
976*b1cdbd2cSJim Jagielski |* Beschreibung
977*b1cdbd2cSJim Jagielski *************************************************************************/
WriteSfxItem(SvStream &)978*b1cdbd2cSJim Jagielski sal_Bool SvIdlWorkingBase::WriteSfxItem( SvStream & )
979*b1cdbd2cSJim Jagielski {
980*b1cdbd2cSJim Jagielski return sal_False;
981*b1cdbd2cSJim Jagielski }
982*b1cdbd2cSJim Jagielski
StartNewFile(const String & rName)983*b1cdbd2cSJim Jagielski void SvIdlDataBase::StartNewFile( const String& rName )
984*b1cdbd2cSJim Jagielski {
985*b1cdbd2cSJim Jagielski bExport = ( aExportFile.EqualsIgnoreCaseAscii( rName ) );
986*b1cdbd2cSJim Jagielski }
987*b1cdbd2cSJim Jagielski
AppendAttr(SvMetaAttribute * pAttr)988*b1cdbd2cSJim Jagielski void SvIdlDataBase::AppendAttr( SvMetaAttribute *pAttr )
989*b1cdbd2cSJim Jagielski {
990*b1cdbd2cSJim Jagielski aAttrList.Append( pAttr );
991*b1cdbd2cSJim Jagielski if ( bExport )
992*b1cdbd2cSJim Jagielski pAttr->SetNewAttribute( sal_True );
993*b1cdbd2cSJim Jagielski }
994*b1cdbd2cSJim Jagielski
WriteCSV(SvStream & rStrm)995*b1cdbd2cSJim Jagielski sal_Bool SvIdlWorkingBase::WriteCSV( SvStream& rStrm )
996*b1cdbd2cSJim Jagielski {
997*b1cdbd2cSJim Jagielski SvMetaAttributeMemberList &rList = GetAttrList();
998*b1cdbd2cSJim Jagielski sal_uLong nCount = rList.Count();
999*b1cdbd2cSJim Jagielski for ( sal_uLong n=0; n<nCount; n++ )
1000*b1cdbd2cSJim Jagielski {
1001*b1cdbd2cSJim Jagielski if ( rList.GetObject(n)->IsNewAttribute() )
1002*b1cdbd2cSJim Jagielski {
1003*b1cdbd2cSJim Jagielski rList.GetObject(n)->WriteCSV( *this, rStrm );
1004*b1cdbd2cSJim Jagielski }
1005*b1cdbd2cSJim Jagielski }
1006*b1cdbd2cSJim Jagielski
1007*b1cdbd2cSJim Jagielski if ( rStrm.GetError() != SVSTREAM_OK )
1008*b1cdbd2cSJim Jagielski return sal_False;
1009*b1cdbd2cSJim Jagielski else
1010*b1cdbd2cSJim Jagielski return sal_True;
1011*b1cdbd2cSJim Jagielski }
1012*b1cdbd2cSJim Jagielski
1013*b1cdbd2cSJim Jagielski /*************************************************************************
1014*b1cdbd2cSJim Jagielski |* SvIdlWorkingBase::WriteDocumentation()
1015*b1cdbd2cSJim Jagielski |*
1016*b1cdbd2cSJim Jagielski |* Beschreibung
1017*b1cdbd2cSJim Jagielski *************************************************************************/
WriteDocumentation(SvStream & rOutStm)1018*b1cdbd2cSJim Jagielski sal_Bool SvIdlWorkingBase::WriteDocumentation( SvStream & rOutStm )
1019*b1cdbd2cSJim Jagielski {
1020*b1cdbd2cSJim Jagielski if( rOutStm.GetError() != SVSTREAM_OK )
1021*b1cdbd2cSJim Jagielski return sal_False;
1022*b1cdbd2cSJim Jagielski
1023*b1cdbd2cSJim Jagielski for( sal_uLong n = 0; n < GetModuleList().Count(); n++ )
1024*b1cdbd2cSJim Jagielski {
1025*b1cdbd2cSJim Jagielski SvMetaModule * pModule = GetModuleList().GetObject( n );
1026*b1cdbd2cSJim Jagielski if( !pModule->IsImported() )
1027*b1cdbd2cSJim Jagielski pModule->Write( *this, rOutStm, 0, WRITE_DOCU );
1028*b1cdbd2cSJim Jagielski }
1029*b1cdbd2cSJim Jagielski return sal_True;
1030*b1cdbd2cSJim Jagielski }
1031*b1cdbd2cSJim Jagielski
1032*b1cdbd2cSJim Jagielski
1033*b1cdbd2cSJim Jagielski
1034*b1cdbd2cSJim Jagielski #endif // IDL_COMPILER
1035*b1cdbd2cSJim Jagielski
1036