Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 :
21 : #include <ctype.h>
22 : #include <stdio.h>
23 : #include <stdlib.h>
24 : #include <tools/debug.hxx>
25 : #include <database.hxx>
26 : #include <globals.hxx>
27 : #include <rtl/strbuf.hxx>
28 : #include <osl/file.hxx>
29 :
30 8 : SvIdlDataBase::SvIdlDataBase( const SvCommand& rCmd )
31 : : bExport( false )
32 : , nUniqueId( 0 )
33 : , nVerbosity( rCmd.nVerbosity )
34 8 : , pIdTable( NULL )
35 : {
36 8 : sSlotMapFile = rCmd.aSlotMapFile;
37 8 : }
38 :
39 16 : SvIdlDataBase::~SvIdlDataBase()
40 : {
41 8 : aIdFileList.clear();
42 :
43 8 : delete pIdTable;
44 8 : }
45 :
46 : #define ADD_TYPE( Name, OdlName, ParserChar, CName, BasName, BasPost ) \
47 : aTypeList.push_back( new SvMetaType( SvHash_##Name()->GetName(), \
48 : BasName, OdlName, ParserChar, CName, BasName, BasPost ) );
49 :
50 32800 : SvMetaTypeMemberList & SvIdlDataBase::GetTypeList()
51 : {
52 32800 : if( aTypeList.empty() )
53 : { // fill initially
54 8 : aTypeList.push_back( new SvMetaTypeString() );
55 8 : aTypeList.push_back( new SvMetaTypevoid() );
56 :
57 : // MI: IDispatch::Invoke can not unsigned
58 8 : ADD_TYPE( UINT16, "long", 'h', "unsigned short", "Long", "&" );
59 8 : ADD_TYPE( INT16, "short", 'h', "short", "Integer", "%" );
60 8 : ADD_TYPE( UINT32, "long", 'l', "unsigned long", "Long", "&" );
61 8 : ADD_TYPE( INT32, "long", 'l', "long", "Long", "&" );
62 8 : ADD_TYPE( int, "int", 'i', "int", "Integer", "%" );
63 8 : ADD_TYPE( BOOL, "boolean", 'b', "unsigned char", "Boolean", "" );
64 8 : ADD_TYPE( char, "char", 'c', "char", "Integer", "%" );
65 8 : ADD_TYPE( BYTE, "char", 'c', "unsigned char", "Integer", "%" );
66 8 : ADD_TYPE( float, "float", 'f', "float", "Single", "!" );
67 8 : ADD_TYPE( double, "double", 'F', "double", "Double", "#" );
68 8 : ADD_TYPE( SbxObject, "VARIANT", 'o', "C_Object", "Object", "" );
69 :
70 : // Attention! When adding types all binary data bases get incompatible
71 :
72 : }
73 32800 : return aTypeList;
74 : }
75 :
76 8 : SvMetaModule * SvIdlDataBase::GetModule( const OString& rName )
77 : {
78 8 : for( sal_uLong n = 0; n < aModuleList.size(); n++ )
79 0 : if( aModuleList[n]->GetName().getString().equals(rName) )
80 0 : return aModuleList[n];
81 8 : return NULL;
82 : }
83 :
84 5024 : void SvIdlDataBase::SetError( const OString& rError, SvToken * pTok )
85 : {
86 5024 : if( pTok->GetLine() > 10000 )
87 781 : aError.SetText( "line count overflow" );
88 :
89 10048 : if( aError.nLine < pTok->GetLine()
90 5024 : || (aError.nLine == pTok->GetLine() && aError.nColumn < pTok->GetColumn()) )
91 : {
92 4989 : aError = SvIdlError( pTok->GetLine(), pTok->GetColumn() );
93 4989 : aError.SetText( rError );
94 : }
95 5024 : }
96 :
97 8 : void SvIdlDataBase::Push( SvMetaObject * pObj )
98 : {
99 8 : GetStack().Push( pObj );
100 8 : }
101 :
102 42301 : bool SvIdlDataBase::FindId( const OString& rIdName, sal_uLong * pVal )
103 : {
104 42301 : if( pIdTable )
105 : {
106 : sal_uInt32 nHash;
107 42301 : if( pIdTable->Test( rIdName, &nHash ) )
108 : {
109 41940 : *pVal = pIdTable->Get( nHash )->GetValue();
110 41940 : return true;
111 : }
112 : }
113 361 : return false;
114 : }
115 :
116 20288 : bool SvIdlDataBase::InsertId( const OString& rIdName, sal_uLong nVal )
117 : {
118 20288 : if( !pIdTable )
119 8 : pIdTable = new SvStringHashTable( 20003 );
120 :
121 : sal_uInt32 nHash;
122 20288 : if( pIdTable->Insert( rIdName, &nHash ) )
123 : {
124 20288 : pIdTable->Get( nHash )->SetValue( nVal );
125 20288 : return true;
126 : }
127 0 : return false;
128 : }
129 :
130 185 : bool SvIdlDataBase::ReadIdFile( const OUString & rFileName )
131 : {
132 185 : OUString aFullName;
133 185 : osl::File::searchFileURL( rFileName, GetPath(), aFullName);
134 185 : osl::FileBase::getSystemPathFromFileURL( aFullName, aFullName );
135 :
136 1051 : for ( size_t i = 0, n = aIdFileList.size(); i < n; ++i )
137 958 : if ( aIdFileList[ i ] == rFileName )
138 92 : return true;
139 :
140 93 : aIdFileList.push_back( rFileName );
141 93 : this->AddDepFile( aFullName );
142 186 : SvTokenStream aTokStm( aFullName );
143 93 : if( aTokStm.GetStream().GetError() == SVSTREAM_OK )
144 : {
145 93 : SvToken * pTok = aTokStm.GetToken_Next();
146 :
147 22913 : while( !pTok->IsEof() )
148 : {
149 22727 : if( pTok->IsChar() && pTok->GetChar() == '#' )
150 : {
151 20807 : pTok = aTokStm.GetToken_Next();
152 20807 : if( pTok->Is( SvHash_define() ) )
153 : {
154 20292 : pTok = aTokStm.GetToken_Next();
155 20292 : OString aDefName;
156 20292 : if( pTok->IsIdentifier() )
157 20292 : aDefName = pTok->GetString();
158 : else
159 : {
160 0 : OString aStr("unexpected token after define");
161 : // set error
162 0 : SetError( aStr, pTok );
163 0 : WriteError( aTokStm );
164 0 : return false;
165 : }
166 :
167 20292 : sal_uLong nVal = 0;
168 20292 : bool bOk = true;
169 125635 : while( bOk )
170 : {
171 105339 : pTok = aTokStm.GetToken_Next();
172 105339 : if( pTok->IsIdentifier() )
173 : {
174 : sal_uLong n;
175 16881 : if( FindId( pTok->GetString(), &n ) )
176 16877 : nVal += n;
177 : else
178 4 : bOk = false;
179 : }
180 88458 : else if( pTok->IsChar() )
181 : {
182 137160 : if( pTok->GetChar() == '-'
183 68580 : || pTok->GetChar() == '/'
184 68580 : || pTok->GetChar() == '*'
185 68580 : || pTok->GetChar() == '&'
186 68580 : || pTok->GetChar() == '|'
187 68580 : || pTok->GetChar() == '^'
188 137160 : || pTok->GetChar() == '~' )
189 : {
190 0 : OStringBuffer aStr("unknown operator '");
191 0 : aStr.append(pTok->GetChar());
192 0 : aStr.append("'in define");
193 : // set error
194 0 : SetError( aStr.makeStringAndClear(), pTok );
195 0 : WriteError( aTokStm );
196 0 : return false;
197 : }
198 137160 : if( pTok->GetChar() != '+'
199 52035 : && pTok->GetChar() != '('
200 104194 : && pTok->GetChar() != ')' )
201 : // only + is allowed, parentheses are immaterial
202 : // because + is commutative
203 19193 : break;
204 : }
205 19878 : else if( pTok->IsInteger() )
206 : {
207 18783 : nVal += pTok->GetNumber();
208 : }
209 : else
210 1095 : break;
211 : }
212 20292 : if( bOk )
213 : {
214 20288 : if( !InsertId( aDefName, nVal ) )
215 : {
216 0 : OString aStr("hash table overflow: ");
217 0 : SetError( aStr, pTok );
218 0 : WriteError( aTokStm );
219 0 : return false;
220 : }
221 20292 : }
222 : }
223 515 : else if( pTok->Is( SvHash_include() ) )
224 : {
225 174 : pTok = aTokStm.GetToken_Next();
226 174 : OStringBuffer aName;
227 174 : if( pTok->IsString() )
228 9 : aName.append(pTok->GetString());
229 165 : else if( pTok->IsChar() && pTok->GetChar() == '<' )
230 : {
231 165 : pTok = aTokStm.GetToken_Next();
232 2121 : while( !pTok->IsEof()
233 978 : && !(pTok->IsChar() && pTok->GetChar() == '>') )
234 : {
235 813 : aName.append(pTok->GetTokenAsString());
236 813 : pTok = aTokStm.GetToken_Next();
237 : }
238 165 : if( pTok->IsEof() )
239 : {
240 0 : OString aStr("unexpected eof in #include");
241 : // set error
242 0 : SetError(aStr, pTok);
243 0 : WriteError( aTokStm );
244 0 : return false;
245 : }
246 : }
247 348 : if (!ReadIdFile(OStringToOUString(aName.toString(),
248 348 : RTL_TEXTENCODING_ASCII_US)))
249 : {
250 0 : OStringBuffer aStr("cannot read file: ");
251 0 : aStr.append(aName.makeStringAndClear());
252 0 : SetError(aStr.makeStringAndClear(), pTok);
253 0 : WriteError( aTokStm );
254 0 : return false;
255 174 : }
256 : }
257 : }
258 : else
259 1920 : pTok = aTokStm.GetToken_Next();
260 : }
261 : }
262 : else
263 0 : return false;
264 278 : return true;
265 : }
266 :
267 11786 : SvMetaType * SvIdlDataBase::FindType( const SvMetaType * pPType,
268 : SvMetaTypeMemberList & rList )
269 : {
270 1189547 : for( SvMetaTypeMemberList::const_iterator it = rList.begin(); it != rList.end(); ++it )
271 1187222 : if( *it == pPType )
272 9461 : return *it;
273 2325 : return NULL;
274 : }
275 :
276 2954 : SvMetaType * SvIdlDataBase::FindType( const OString& rName )
277 : {
278 43696 : for( SvMetaTypeMemberList::const_iterator it = aTypeList.begin(); it != aTypeList.end(); ++it )
279 43696 : if( rName.equals((*it)->GetName().getString()) )
280 2954 : return *it;
281 0 : return NULL;
282 : }
283 :
284 36653 : SvMetaType * SvIdlDataBase::ReadKnownType( SvTokenStream & rInStm )
285 : {
286 36653 : bool bIn = false;
287 36653 : bool bOut = false;
288 36653 : int nCall0 = CALL_VALUE;
289 36653 : int nCall1 = CALL_VALUE;
290 36653 : bool bSet = false; // any attribute set
291 :
292 36653 : sal_uInt32 nTokPos = rInStm.Tell();
293 36653 : SvToken * pTok = rInStm.GetToken_Next();
294 :
295 36653 : if( pTok->HasHash() )
296 : {
297 1824 : sal_uInt32 nBeginPos = 0; // can not happen with Tell
298 5472 : while( nBeginPos != rInStm.Tell() )
299 : {
300 1824 : nBeginPos = rInStm.Tell();
301 1824 : if( pTok->Is( SvHash_in() ) )
302 : {
303 0 : bIn = true;
304 0 : pTok = rInStm.GetToken_Next();
305 0 : bSet = true;
306 : }
307 1824 : if( pTok->Is( SvHash_out() ) )
308 : {
309 0 : bOut = true;
310 0 : pTok = rInStm.GetToken_Next();
311 0 : bSet = true;
312 : }
313 1824 : if( pTok->Is( SvHash_inout() ) )
314 : {
315 0 : bIn = true;
316 0 : bOut = true;
317 0 : pTok = rInStm.GetToken_Next();
318 0 : bSet = true;
319 : }
320 : }
321 : }
322 :
323 36653 : if( pTok->IsIdentifier() )
324 : {
325 31108 : OString aName = pTok->GetString();
326 31108 : SvMetaTypeMemberList & rList = GetTypeList();
327 31108 : SvMetaTypeMemberList::const_iterator it = rList.begin();
328 31108 : SvMetaType * pType = NULL;
329 2708362 : while( it != rList.end() )
330 : {
331 2669172 : if( (*it)->GetName().getString().equals(aName) )
332 : {
333 23026 : pType = *it;
334 23026 : break;
335 : }
336 2646146 : ++it;
337 : }
338 31108 : if( pType )
339 : {
340 23026 : pTok = rInStm.GetToken();
341 23026 : if( pTok->IsChar() )
342 : {
343 17 : if( pTok->GetChar() == '&' || pTok->GetChar() == '*' )
344 : {
345 0 : nCall0 = (pTok->GetChar() == '&') ? CALL_REFERENCE :
346 0 : CALL_POINTER;
347 0 : rInStm.GetToken_Next();
348 0 : pTok = rInStm.GetToken();
349 0 : if( pTok->GetChar() == '&' || pTok->GetChar() == '*' )
350 : {
351 0 : nCall1 = (pTok->GetChar() == '&') ? CALL_REFERENCE :
352 0 : CALL_POINTER;
353 0 : rInStm.GetToken_Next();
354 : }
355 0 : bSet = true;
356 : }
357 : }
358 :
359 23026 : if( !bSet )
360 : // is exactly this type
361 23026 : return pType;
362 :
363 : DBG_ASSERT( aTmpTypeList.front(), "mindestens ein Element" );
364 0 : SvMetaTypeRef xType = new SvMetaType( pType->GetName().getString(), 'h', "dummy" );
365 0 : xType->SetRef( pType );
366 0 : xType->SetIn( bIn );
367 0 : xType->SetOut( bOut );
368 0 : xType->SetCall0( nCall0 );
369 0 : xType->SetCall1( nCall1 );
370 :
371 0 : aTmpTypeList.push_back( xType );
372 0 : return xType;
373 8082 : }
374 : }
375 13627 : rInStm.Seek( nTokPos );
376 13627 : return NULL;
377 : }
378 :
379 12506 : SvMetaAttribute * SvIdlDataBase::ReadKnownAttr
380 : (
381 : SvTokenStream & rInStm,
382 : SvMetaType * pType /* If pType == NULL, then the type has
383 : still to be read. */
384 : )
385 : {
386 12506 : sal_uInt32 nTokPos = rInStm.Tell();
387 :
388 12506 : if( !pType )
389 12480 : pType = ReadKnownType( rInStm );
390 :
391 12506 : if( !pType )
392 : {
393 : // otherwise SlotId?
394 4372 : SvToken * pTok = rInStm.GetToken_Next();
395 4372 : if( pTok->IsIdentifier() )
396 : {
397 : sal_uLong n;
398 4041 : if( FindId( pTok->GetString(), &n ) )
399 : {
400 2880759 : for( sal_uLong i = 0; i < aAttrList.size(); i++ )
401 : {
402 2880759 : SvMetaAttribute * pAttr = aAttrList[i];
403 2880759 : if( pAttr->GetSlotId().getString().equals(pTok->GetString()) )
404 4041 : return pAttr;
405 : }
406 : }
407 :
408 0 : OStringBuffer aStr("Nicht gefunden : ");
409 0 : aStr.append(pTok->GetString());
410 0 : OSL_FAIL(aStr.getStr());
411 : }
412 : }
413 :
414 8465 : rInStm.Seek( nTokPos );
415 8465 : return NULL;
416 : }
417 :
418 8465 : SvMetaAttribute* SvIdlDataBase::SearchKnownAttr
419 : (
420 : const SvNumberIdentifier& rId
421 : )
422 : {
423 : sal_uLong n;
424 8465 : if( FindId( rId.getString(), &n ) )
425 : {
426 4471321 : for( sal_uLong i = 0; i < aAttrList.size(); i++ )
427 : {
428 4463262 : SvMetaAttribute * pAttr = aAttrList[i];
429 4463262 : if( pAttr->GetSlotId().getString() == rId.getString() )
430 49 : return pAttr;
431 : }
432 : }
433 :
434 8416 : return NULL;
435 : }
436 :
437 171 : SvMetaClass * SvIdlDataBase::ReadKnownClass( SvTokenStream & rInStm )
438 : {
439 171 : sal_uInt32 nTokPos = rInStm.Tell();
440 171 : SvToken * pTok = rInStm.GetToken_Next();
441 :
442 171 : if( pTok->IsIdentifier() )
443 3993 : for( sal_uLong n = 0; n < aClassList.size(); n++ )
444 : {
445 3993 : SvMetaClass * pClass = aClassList[n];
446 3993 : if( pClass->GetName().getString().equals(pTok->GetString()) )
447 171 : return pClass;
448 : }
449 :
450 0 : rInStm.Seek( nTokPos );
451 0 : return NULL;
452 : }
453 :
454 1663 : void SvIdlDataBase::Write(const OString& rText)
455 : {
456 1663 : if( nVerbosity != 0 )
457 0 : fprintf( stdout, "%s", rText.getStr() );
458 1663 : }
459 :
460 0 : void SvIdlDataBase::WriteError( const OString& rErrWrn,
461 : const OString& rFileName,
462 : const OString& rErrorText,
463 : sal_uLong nRow, sal_uLong nColumn ) const
464 : {
465 : // error treatment
466 : fprintf( stderr, "\n%s --- %s: ( %ld, %ld )\n",
467 0 : rFileName.getStr(), rErrWrn.getStr(), nRow, nColumn );
468 :
469 0 : if( !rErrorText.isEmpty() )
470 : { // error set
471 0 : fprintf( stderr, "\t%s\n", rErrorText.getStr() );
472 : }
473 0 : }
474 :
475 0 : void SvIdlDataBase::WriteError( SvTokenStream & rInStm )
476 : {
477 : // error treatment
478 0 : OUString aFileName( rInStm.GetFileName() );
479 0 : OStringBuffer aErrorText;
480 0 : sal_uLong nRow = 0, nColumn = 0;
481 :
482 0 : rInStm.SeekEnd();
483 0 : SvToken *pTok = rInStm.GetToken();
484 :
485 : // error position
486 0 : nRow = pTok->GetLine();
487 0 : nColumn = pTok->GetColumn();
488 :
489 0 : if( aError.IsError() )
490 : { // error set
491 : // search error token
492 : // error text
493 0 : if( !aError.GetText().isEmpty() )
494 : {
495 0 : aErrorText.append("may be <");
496 0 : aErrorText.append(aError.GetText());
497 : }
498 0 : SvToken * pPrevTok = NULL;
499 0 : while( pTok != pPrevTok )
500 : {
501 0 : pPrevTok = pTok;
502 0 : if( pTok->GetLine() == aError.nLine
503 0 : && pTok->GetColumn() == aError.nColumn )
504 0 : break;
505 0 : pTok = rInStm.GetToken_PrevAll();
506 : }
507 :
508 : // error position
509 0 : aErrorText.append("> at ( ");
510 0 : aErrorText.append(static_cast<sal_Int64>(aError.nLine));
511 0 : aErrorText.append(", ");
512 0 : aErrorText.append(static_cast<sal_Int64>(aError.nColumn));
513 0 : aErrorText.append(" )");
514 :
515 : // reset error
516 0 : aError = SvIdlError();
517 : }
518 :
519 : WriteError("error", OUStringToOString(aFileName,
520 0 : RTL_TEXTENCODING_UTF8), aErrorText.makeStringAndClear(), nRow, nColumn);
521 :
522 : DBG_ASSERT( pTok, "token must be found" );
523 0 : if( !pTok )
524 0 : return;
525 :
526 : // look for identifier close by
527 0 : if( !pTok->IsIdentifier() )
528 : {
529 0 : rInStm.GetToken_PrevAll();
530 0 : pTok = rInStm.GetToken();
531 : }
532 0 : if( pTok && pTok->IsIdentifier() )
533 : {
534 0 : OString aN = IDLAPP->pHashTable->GetNearString( pTok->GetString() );
535 0 : if( !aN.isEmpty() )
536 0 : fprintf( stderr, "%s versus %s\n", pTok->GetString().getStr(), aN.getStr() );
537 0 : }
538 : }
539 :
540 8 : SvIdlWorkingBase::SvIdlWorkingBase(const SvCommand& rCmd) : SvIdlDataBase(rCmd)
541 : {
542 8 : }
543 :
544 8 : bool SvIdlWorkingBase::ReadSvIdl( SvTokenStream & rInStm, bool bImported, const OUString & rPath )
545 : {
546 8 : aPath = rPath; // only valid for this iteration
547 8 : bool bOk = true;
548 8 : SvToken * pTok = rInStm.GetToken();
549 : // only one import at the very beginning
550 8 : if( pTok->Is( SvHash_import() ) )
551 : {
552 0 : rInStm.GetToken_Next();
553 0 : bOk = rInStm.Read( '(' ); // optional
554 0 : pTok = bOk ? rInStm.GetToken_Next() : NULL;
555 0 : if( pTok && pTok->IsString() )
556 : {
557 0 : OUString aFullName;
558 0 : if( osl::FileBase::E_None == osl::File::searchFileURL(
559 0 : OStringToOUString(pTok->GetString(), RTL_TEXTENCODING_ASCII_US),
560 : rPath,
561 0 : aFullName) )
562 : {
563 0 : osl::FileBase::getSystemPathFromFileURL( aFullName, aFullName );
564 0 : this->AddDepFile(aFullName);
565 0 : SvFileStream aStm( aFullName, STREAM_STD_READ | STREAM_NOCREATE );
566 0 : SvTokenStream aTokStm( aStm, aFullName );
567 0 : bOk = ReadSvIdl( aTokStm, true, rPath );
568 : }
569 : else
570 0 : bOk = false;
571 : }
572 : else
573 0 : bOk = false;
574 : }
575 :
576 8 : sal_uInt32 nBeginPos = 0xFFFFFFFF; // can not happen with Tell
577 :
578 24 : while( bOk && nBeginPos != rInStm.Tell() )
579 : {
580 16 : nBeginPos = rInStm.Tell();
581 16 : pTok = rInStm.GetToken();
582 16 : if( pTok->IsEof() )
583 8 : return true;
584 8 : if( pTok->IsEmpty() )
585 0 : bOk = false;
586 :
587 : // only one import at the very beginning
588 8 : if( pTok->Is( SvHash_module() ) )
589 : {
590 8 : SvMetaModuleRef aModule = new SvMetaModule( rInStm.GetFileName(), bImported );
591 8 : if( aModule->ReadSvIdl( *this, rInStm ) )
592 8 : GetModuleList().push_back( aModule );
593 : else
594 0 : bOk = false;
595 : }
596 : else
597 0 : bOk = false;
598 : }
599 0 : if( !bOk || !pTok->IsEof() )
600 : {
601 : // error treatment
602 0 : WriteError( rInStm );
603 0 : return false;
604 : }
605 0 : return true;
606 : }
607 :
608 8 : bool SvIdlWorkingBase::WriteSfx( SvStream & rOutStm )
609 : {
610 8 : if( rOutStm.GetError() != SVSTREAM_OK )
611 0 : return false;
612 :
613 : // reset all tmp variables for writing
614 8 : WriteReset();
615 8 : SvMemoryStream aTmpStm( 256000, 256000 );
616 : sal_uLong n;
617 16 : for( n = 0; n < GetModuleList().size(); n++ )
618 : {
619 8 : SvMetaModule * pModule = GetModuleList()[n];
620 8 : if( !pModule->IsImported() )
621 8 : pModule->WriteSfx( *this, aTmpStm );
622 8 : aTmpStm.Seek( 0 );
623 : }
624 2333 : for( n = 0; n < aUsedTypes.size(); n++ )
625 : {
626 2325 : SvMetaType * pType = aUsedTypes[n];
627 2325 : pType->WriteSfx( *this, rOutStm );
628 : }
629 8 : aUsedTypes.clear();
630 8 : rOutStm.WriteStream( aTmpStm );
631 8 : return true;
632 : }
633 :
634 133 : void SvIdlDataBase::StartNewFile( const OUString& rName )
635 : {
636 133 : bExport = ( aExportFile.equalsIgnoreAsciiCase( rName ) );
637 133 : }
638 :
639 8082 : void SvIdlDataBase::AppendAttr( SvMetaAttribute *pAttr )
640 : {
641 8082 : aAttrList.push_back( pAttr );
642 8082 : if ( bExport )
643 0 : pAttr->SetNewAttribute( true );
644 8082 : }
645 :
646 234 : void SvIdlDataBase::AddDepFile(OUString const& rFileName)
647 : {
648 234 : m_DepFiles.insert(rFileName);
649 234 : }
650 :
651 : struct WriteDep
652 : {
653 : SvFileStream & m_rStream;
654 8 : explicit WriteDep(SvFileStream & rStream) : m_rStream(rStream) { }
655 234 : void operator() (OUString const& rItem)
656 : {
657 234 : m_rStream.WriteCharPtr( " \\\n " );
658 234 : m_rStream.WriteCharPtr( OUStringToOString(rItem, RTL_TEXTENCODING_UTF8).getStr() );
659 234 : }
660 : };
661 :
662 : // write a dummy target for one included file, so the incremental build does
663 : // not break with "No rule to make target" if the included file is removed
664 : struct WriteDummy
665 : {
666 : SvFileStream & m_rStream;
667 8 : explicit WriteDummy(SvFileStream & rStream) : m_rStream(rStream) { }
668 234 : void operator() (OUString const& rItem)
669 : {
670 234 : m_rStream.WriteCharPtr( OUStringToOString(rItem, RTL_TEXTENCODING_UTF8).getStr() );
671 234 : m_rStream.WriteCharPtr( " :\n\n" );
672 234 : }
673 : };
674 :
675 8 : bool SvIdlDataBase::WriteDepFile(
676 : SvFileStream & rStream, OUString const& rTarget)
677 : {
678 8 : rStream.WriteCharPtr( OUStringToOString(rTarget, RTL_TEXTENCODING_UTF8).getStr() );
679 8 : rStream.WriteCharPtr( " :" );
680 8 : ::std::for_each(m_DepFiles.begin(), m_DepFiles.end(), WriteDep(rStream));
681 8 : rStream.WriteCharPtr( "\n\n" );
682 8 : ::std::for_each(m_DepFiles.begin(), m_DepFiles.end(), WriteDummy(rStream));
683 8 : return rStream.GetError() == SVSTREAM_OK;
684 : }
685 :
686 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
