idl/source/prj/database.cxx

   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 SvIdlDataBase::SvIdlDataBase( const SvCommand& rCmd )
  31     : bExport( sal_False )
  32     , nUniqueId( 0 )
  33     , nVerbosity( rCmd.nVerbosity )
  34     , aPersStream( *IDLAPP->pClassMgr, NULL )
  35     , pIdTable( NULL )
  36 {
  37 }
  38
  39 SvIdlDataBase::~SvIdlDataBase()
  40 {
  41     for ( size_t i = 0, n = aIdFileList.size(); i < n; ++i )
  42         delete aIdFileList[ i ];
  43     aIdFileList.clear();
  44
  45     delete pIdTable;
  46 }
  47
  48 #define ADD_TYPE( Name, OdlName, ParserChar, CName, BasName, BasPost )            \
  49     aTypeList.push_back( new SvMetaType( SvHash_##Name()->GetName(),   \
  50                      BasName, OdlName, ParserChar, CName, BasName, BasPost ) );
  51
  52 SvMetaTypeMemberList & SvIdlDataBase::GetTypeList()
  53 {
  54     if( aTypeList.empty() )
  55     { // fill initially
  56         aTypeList.push_back( new SvMetaTypeString() );
  57         aTypeList.push_back( new SvMetaTypevoid() );
  58
  59         // MI: IDispatch::Invoke can not unsigned
  60         ADD_TYPE( UINT16,    "long", 'h', "unsigned short", "Long", "&" );
  61         ADD_TYPE( INT16,     "short", 'h', "short", "Integer", "%" );
  62         ADD_TYPE( UINT32,    "long", 'l', "unsigned long", "Long", "&" );
  63         ADD_TYPE( INT32,     "long", 'l', "long", "Long", "&" );
  64         ADD_TYPE( int,       "int", 'i', "int", "Integer", "%" );
  65         ADD_TYPE( BOOL,      "boolean", 'b', "unsigned char", "Boolean", "" );
  66         ADD_TYPE( char,      "char", 'c', "char", "Integer", "%" );
  67         ADD_TYPE( BYTE,      "char", 'c', "unsigned char", "Integer", "%" );
  68         ADD_TYPE( float,     "float", 'f', "float", "Single", "!" );
  69         ADD_TYPE( double,    "double", 'F', "double", "Double", "#" );
  70         ADD_TYPE( SbxObject, "VARIANT", 'o', "C_Object", "Object", "" );
  71
  72         // Attention! When adding types all binary data bases get incompatible
  73
  74     }
  75     return aTypeList;
  76 }
  77
  78 SvMetaModule * SvIdlDataBase::GetModule( const OString& rName )
  79 {
  80     for( sal_uLong n = 0; n < aModuleList.size(); n++ )
  81         if( aModuleList[n]->GetName().getString().equals(rName) )
  82             return aModuleList[n];
  83     return NULL;
  84 }
  85
  86 #define DATABASE_SIGNATURE  (sal_uInt32)0x13B799F2
  87 #define DATABASE_VER 0x0006
  88 sal_Bool SvIdlDataBase::IsBinaryFormat( SvStream & rStm )
  89 {
  90     sal_uInt32  nSig = 0;
  91     sal_uLong   nPos = rStm.Tell();
  92     rStm >> nSig;
  93     rStm.Seek( nPos );
  94
  95     return nSig == DATABASE_SIGNATURE;
  96 }
  97
  98 void SvIdlDataBase::Load( SvStream & rStm )
  99 {
 100     DBG_ASSERT( aTypeList.empty(), "type list already initialized" );
 101     SvPersistStream aPStm( *IDLAPP->pClassMgr, &rStm );
 102
 103     sal_uInt16  nVersion = 0;
 104     sal_uInt32  nSig = 0;
 105
 106     aPStm >> nSig;
 107     aPStm >> nVersion;
 108     if( nSig != DATABASE_SIGNATURE )
 109     {
 110         aPStm.SetError( SVSTREAM_FILEFORMAT_ERROR );
 111         return;
 112     }
 113     if( nVersion != DATABASE_VER )
 114     {
 115         aPStm.SetError( SVSTREAM_WRONGVERSION );
 116         return;
 117     }
 118     aPStm >> aClassList;
 119     aPStm >> aTypeList;
 120     aPStm >> aAttrList;
 121     aPStm >> aModuleList;
 122     aPStm >> nUniqueId;
 123
 124     if( aPStm.IsEof() )
 125         aPStm.SetError( SVSTREAM_GENERALERROR );
 126 }
 127
 128 void SvIdlDataBase::Save( SvStream & rStm, sal_uInt32 nFlags )
 129 {
 130     SvPersistStream aPStm( *IDLAPP->pClassMgr, &rStm );
 131     aPStm.SetContextFlags( nFlags );
 132
 133     aPStm << (sal_uInt32)DATABASE_SIGNATURE;
 134     aPStm << (sal_uInt16)DATABASE_VER;
 135
 136     sal_Bool bOnlyStreamedObjs = sal_False;
 137     if( nFlags & IDL_WRITE_CALLING )
 138         bOnlyStreamedObjs = sal_True;
 139
 140     if( bOnlyStreamedObjs )
 141     {
 142         SvMetaClassMemberList aList;
 143         for( sal_uLong n = 0; n < GetModuleList().size(); n++ )
 144         {
 145             SvMetaModule * pModule = GetModuleList()[n];
 146             if( !pModule->IsImported() )
 147                 aList.insert( pModule->GetClassList() );
 148         }
 149         aPStm << aList;
 150     }
 151     else
 152         aPStm << aClassList;
 153
 154     aTypeList.WriteObjects( aPStm, bOnlyStreamedObjs );
 155     aAttrList.WriteObjects( aPStm, bOnlyStreamedObjs );
 156     aModuleList.WriteObjects( aPStm, bOnlyStreamedObjs );
 157     aPStm << nUniqueId;
 158 }
 159
 160 void SvIdlDataBase::SetError( const OString& rError, SvToken * pTok )
 161 {
 162     if( pTok->GetLine() > 10000 )
 163         aError.SetText( "line count overflow" );
 164
 165     if( aError.nLine < pTok->GetLine()
 166       || (aError.nLine == pTok->GetLine() && aError.nColumn < pTok->GetColumn()) )
 167     {
 168         aError = SvIdlError( pTok->GetLine(), pTok->GetColumn() );
 169         aError.SetText( rError );
 170     }
 171 }
 172
 173 void SvIdlDataBase::Push( SvMetaObject * pObj )
 174 {
 175     GetStack().Push( pObj );
 176 }
 177
 178 sal_Bool SvIdlDataBase::FindId( const OString& rIdName, sal_uLong * pVal )
 179 {
 180     if( pIdTable )
 181     {
 182         sal_uInt32 nHash;
 183         if( pIdTable->Test( rIdName, &nHash ) )
 184         {
 185             *pVal = pIdTable->Get( nHash )->GetValue();
 186             return sal_True;
 187         }
 188     }
 189     return sal_False;
 190 }
 191
 192 sal_Bool SvIdlDataBase::InsertId( const OString& rIdName, sal_uLong nVal )
 193 {
 194     if( !pIdTable )
 195         pIdTable = new SvStringHashTable( 20003 );
 196
 197     sal_uInt32 nHash;
 198     if( pIdTable->Insert( rIdName, &nHash ) )
 199     {
 200         pIdTable->Get( nHash )->SetValue( nVal );
 201         return sal_True;
 202     }
 203     return sal_False;
 204 }
 205
 206 sal_Bool SvIdlDataBase::ReadIdFile( const String & rFileName )
 207 {
 208     OUString aFullName;
 209     osl::File::searchFileURL( rFileName, GetPath(), aFullName);
 210     osl::FileBase::getSystemPathFromFileURL( aFullName, aFullName );
 211
 212     for ( size_t i = 0, n = aIdFileList.size(); i < n; ++i )
 213         if ( *aIdFileList[ i ] == rFileName )
 214             return sal_True;
 215
 216     aIdFileList.push_back( new String( rFileName ) );
 217     this->AddDepFile( aFullName );
 218     SvTokenStream aTokStm( aFullName );
 219     if( aTokStm.GetStream().GetError() == SVSTREAM_OK )
 220     {
 221         SvToken * pTok = aTokStm.GetToken_Next();
 222
 223         while( !pTok->IsEof() )
 224         {
 225             if( pTok->IsChar() && pTok->GetChar() == '#' )
 226             {
 227                 pTok = aTokStm.GetToken_Next();
 228                 if( pTok->Is( SvHash_define() ) )
 229                 {
 230                     pTok = aTokStm.GetToken_Next();
 231                     OString aDefName;
 232                     if( pTok->IsIdentifier() )
 233                         aDefName = pTok->GetString();
 234                     else
 235                     {
 236                         OString aStr(RTL_CONSTASCII_STRINGPARAM(
 237                             "unexpected token after define"));
 238                         // set error
 239                         SetError( aStr, pTok );
 240                         WriteError( aTokStm );
 241                         return sal_False;
 242                     }
 243
 244                     sal_uLong nVal = 0;
 245                     sal_Bool bOk = sal_True;
 246                     while( bOk )
 247                     {
 248                         pTok = aTokStm.GetToken_Next();
 249                         if( pTok->IsIdentifier() )
 250                         {
 251                             sal_uLong n;
 252                             if( FindId( pTok->GetString(), &n ) )
 253                                 nVal += n;
 254                             else
 255                                 bOk = sal_False;
 256                         }
 257                         else if( pTok->IsChar() )
 258                         {
 259                             if( pTok->GetChar() == '-'
 260                               || pTok->GetChar() == '/'
 261                               || pTok->GetChar() == '*'
 262                               || pTok->GetChar() == '&'
 263                               || pTok->GetChar() == '|'
 264                               || pTok->GetChar() == '^'
 265                               || pTok->GetChar() == '~' )
 266                             {
 267                                 OStringBuffer aStr("unknown operator '");
 268                                 aStr.append(pTok->GetChar());
 269                                 aStr.append("'in define");
 270                                 // set error
 271                                 SetError( aStr.makeStringAndClear(), pTok );
 272                                 WriteError( aTokStm );
 273                                 return sal_False;
 274                             }
 275                             if( pTok->GetChar() != '+'
 276                               && pTok->GetChar() != '('
 277                               && pTok->GetChar() != ')' )
 278                                 // only + is allowed, parentheses are immaterial
 279                                 // because + is commutative
 280                                 break;
 281                         }
 282                         else if( pTok->IsInteger() )
 283                         {
 284                             nVal += pTok->GetNumber();
 285                         }
 286                         else
 287                             break;
 288                     }
 289                     if( bOk )
 290                     {
 291                         if( !InsertId( aDefName, nVal ) )
 292                         {
 293                             OString aStr(RTL_CONSTASCII_STRINGPARAM("hash table overflow: "));
 294                             SetError( aStr, pTok );
 295                             WriteError( aTokStm );
 296                             return sal_False;
 297                         }
 298                     }
 299                 }
 300                 else if( pTok->Is( SvHash_include() ) )
 301                 {
 302                     pTok = aTokStm.GetToken_Next();
 303                     OStringBuffer aName;
 304                     if( pTok->IsString() )
 305                         aName.append(pTok->GetString());
 306                     else if( pTok->IsChar() && pTok->GetChar() == '<' )
 307                     {
 308                         pTok = aTokStm.GetToken_Next();
 309                         while( !pTok->IsEof()
 310                           && !(pTok->IsChar() && pTok->GetChar() == '>') )
 311                         {
 312                             aName.append(pTok->GetTokenAsString());
 313                             pTok = aTokStm.GetToken_Next();
 314                         }
 315                         if( pTok->IsEof() )
 316                         {
 317                             OString aStr(RTL_CONSTASCII_STRINGPARAM(
 318                                 "unexpected eof in #include"));
 319                             // set error
 320                             SetError(aStr, pTok);
 321                             WriteError( aTokStm );
 322                             return sal_False;
 323                         }
 324                     }
 325                     if (!ReadIdFile(OStringToOUString(aName.toString(),
 326                         RTL_TEXTENCODING_ASCII_US)))
 327                     {
 328                         OStringBuffer aStr(RTL_CONSTASCII_STRINGPARAM(
 329                             "cannot read file: "));
 330                         aStr.append(aName.makeStringAndClear());
 331                         SetError(aStr.makeStringAndClear(), pTok);
 332                         WriteError( aTokStm );
 333                         return sal_False;
 334                     }
 335                 }
 336             }
 337             else
 338                 pTok = aTokStm.GetToken_Next();
 339         }
 340     }
 341     else
 342         return sal_False;
 343     return sal_True;
 344 }
 345
 346 SvMetaType * SvIdlDataBase::FindType( const SvMetaType * pPType,
 347                                     SvMetaTypeMemberList & rList )
 348 {
 349     for( SvMetaTypeMemberList::const_iterator it = rList.begin(); it != rList.end(); ++it )
 350         if( *it == pPType )
 351             return *it;
 352     return NULL;
 353 }
 354
 355 SvMetaType * SvIdlDataBase::FindType( const OString& rName )
 356 {
 357     for( SvMetaTypeMemberList::const_iterator it = aTypeList.begin(); it != aTypeList.end(); ++it )
 358         if( rName.equals((*it)->GetName().getString()) )
 359             return *it;
 360     return NULL;
 361 }
 362
 363 SvMetaType * SvIdlDataBase::ReadKnownType( SvTokenStream & rInStm )
 364 {
 365     sal_Bool bIn    = sal_False;
 366     sal_Bool bOut   = sal_False;
 367     int nCall0  = CALL_VALUE;
 368     int nCall1  = CALL_VALUE;
 369     sal_Bool bSet   = sal_False; // any attribute set
 370
 371     sal_uInt32  nTokPos = rInStm.Tell();
 372     SvToken * pTok = rInStm.GetToken_Next();
 373
 374     if( pTok->HasHash() )
 375     {
 376         sal_uInt32 nBeginPos = 0; // can not happen with Tell
 377         while( nBeginPos != rInStm.Tell() )
 378         {
 379             nBeginPos = rInStm.Tell();
 380             if( pTok->Is( SvHash_in() ) )
 381             {
 382                 bIn  = sal_True;
 383                 pTok = rInStm.GetToken_Next();
 384                 bSet = sal_True;
 385             }
 386             if( pTok->Is( SvHash_out() ) )
 387             {
 388                 bOut = sal_True;
 389                 pTok = rInStm.GetToken_Next();
 390                 bSet = sal_True;
 391             }
 392             if( pTok->Is( SvHash_inout() ) )
 393             {
 394                 bIn  = sal_True;
 395                 bOut = sal_True;
 396                 pTok = rInStm.GetToken_Next();
 397                 bSet = sal_True;
 398             }
 399         }
 400     }
 401
 402     if( pTok->IsIdentifier() )
 403     {
 404         OString aName = pTok->GetString();
 405         SvMetaTypeMemberList & rList = GetTypeList();
 406         SvMetaTypeMemberList::const_iterator it = rList.begin();
 407         SvMetaType * pType = NULL;
 408         while( it != rList.end() )
 409         {
 410             if( (*it)->GetName().getString().equals(aName) )
 411             {
 412                 pType = *it;
 413                 break;
 414             }
 415             ++it;
 416         }
 417         if( pType )
 418         {
 419             pTok = rInStm.GetToken();
 420             if( pTok->IsChar() )
 421             {
 422                 if( pTok->GetChar() == '&' || pTok->GetChar() == '*' )
 423                 {
 424                     nCall0 = (pTok->GetChar() == '&') ? CALL_REFERENCE :
 425                                                         CALL_POINTER;
 426                     rInStm.GetToken_Next();
 427                     pTok = rInStm.GetToken();
 428                     if( pTok->GetChar() == '&' || pTok->GetChar() == '*' )
 429                     {
 430                         nCall1 = (pTok->GetChar() == '&') ? CALL_REFERENCE :
 431                                                             CALL_POINTER;
 432                         rInStm.GetToken_Next();
 433                     }
 434                     bSet = sal_True;
 435                 }
 436             }
 437
 438             if( !bSet )
 439                 // is exactly this type
 440                 return pType;
 441
 442             DBG_ASSERT( aTmpTypeList.front(), "mindestens ein Element" );
 443             SvMetaTypeRef xType = new SvMetaType( pType->GetName().getString(), 'h', "dummy" );
 444             xType->SetRef( pType );
 445             xType->SetIn( bIn );
 446             xType->SetOut( bOut );
 447             xType->SetCall0( nCall0 );
 448             xType->SetCall1( nCall1 );
 449
 450             aTmpTypeList.push_back( xType );
 451             return xType;
 452         }
 453     }
 454     rInStm.Seek( nTokPos );
 455     return NULL;
 456 }
 457
 458 SvMetaAttribute * SvIdlDataBase::ReadKnownAttr
 459 (
 460     SvTokenStream & rInStm,
 461     SvMetaType *    pType   /* If pType == NULL, then the type has
 462                                still to be read. */
 463 )
 464 {
 465     sal_uInt32  nTokPos = rInStm.Tell();
 466
 467     if( !pType )
 468         pType = ReadKnownType( rInStm );
 469
 470     if( !pType )
 471     {
 472         // otherwise SlotId?
 473         SvToken * pTok = rInStm.GetToken_Next();
 474         if( pTok->IsIdentifier() )
 475         {
 476             sal_uLong n;
 477             if( FindId( pTok->GetString(), &n ) )
 478             {
 479                 for( sal_uLong i = 0; i < aAttrList.size(); i++ )
 480                 {
 481                     SvMetaAttribute * pAttr = aAttrList[i];
 482                     if( pAttr->GetSlotId().getString().equals(pTok->GetString()) )
 483                         return pAttr;
 484                 }
 485             }
 486
 487             OStringBuffer aStr("Nicht gefunden : ");
 488             aStr.append(pTok->GetString());
 489             OSL_FAIL(aStr.getStr());
 490         }
 491     }
 492
 493     rInStm.Seek( nTokPos );
 494     return NULL;
 495 }
 496
 497 SvMetaAttribute* SvIdlDataBase::SearchKnownAttr
 498 (
 499     const SvNumberIdentifier& rId
 500 )
 501 {
 502     sal_uLong n;
 503     if( FindId( rId.getString(), &n ) )
 504     {
 505         for( sal_uLong i = 0; i < aAttrList.size(); i++ )
 506         {
 507             SvMetaAttribute * pAttr = aAttrList[i];
 508             if( pAttr->GetSlotId().getString() == rId.getString() )
 509                 return pAttr;
 510         }
 511     }
 512
 513     return NULL;
 514 }
 515
 516 SvMetaClass * SvIdlDataBase::ReadKnownClass( SvTokenStream & rInStm )
 517 {
 518     sal_uInt32  nTokPos = rInStm.Tell();
 519     SvToken * pTok = rInStm.GetToken_Next();
 520
 521     if( pTok->IsIdentifier() )
 522         for( sal_uLong n = 0; n < aClassList.size(); n++ )
 523         {
 524             SvMetaClass * pClass = aClassList[n];
 525             if( pClass->GetName().getString().equals(pTok->GetString()) )
 526                 return pClass;
 527         }
 528
 529     rInStm.Seek( nTokPos );
 530     return NULL;
 531 }
 532
 533 void SvIdlDataBase::Write(const OString& rText)
 534 {
 535     if( nVerbosity != 0 )
 536         fprintf( stdout, "%s", rText.getStr() );
 537 }
 538
 539 void SvIdlDataBase::WriteError( const OString& rErrWrn,
 540                                 const OString& rFileName,
 541                                 const OString& rErrorText,
 542                                 sal_uLong nRow, sal_uLong nColumn ) const
 543 {
 544     // error treatment
 545     fprintf( stderr, "\n%s --- %s: ( %ld, %ld )\n",
 546              rFileName.getStr(), rErrWrn.getStr(), nRow, nColumn );
 547
 548     if( !rErrorText.isEmpty() )
 549     { // error set
 550         fprintf( stderr, "\t%s\n", rErrorText.getStr() );
 551     }
 552 }
 553
 554 void SvIdlDataBase::WriteError( SvTokenStream & rInStm )
 555 {
 556     // error treatment
 557     String aFileName( rInStm.GetFileName() );
 558     OStringBuffer aErrorText;
 559     sal_uLong   nRow = 0, nColumn = 0;
 560
 561     rInStm.SeekEnd();
 562     SvToken *pTok = rInStm.GetToken();
 563
 564     // error position
 565     nRow    = pTok->GetLine();
 566     nColumn = pTok->GetColumn();
 567
 568     if( aError.IsError() )
 569     { // error set
 570         // search error token
 571         // error text
 572         if( !aError.GetText().isEmpty() )
 573         {
 574             aErrorText.append(RTL_CONSTASCII_STRINGPARAM("may be <"));
 575             aErrorText.append(aError.GetText());
 576         }
 577         SvToken * pPrevTok = NULL;
 578         while( pTok != pPrevTok )
 579         {
 580             pPrevTok = pTok;
 581             if( pTok->GetLine() == aError.nLine
 582               && pTok->GetColumn() == aError.nColumn )
 583                 break;
 584             pTok = rInStm.GetToken_PrevAll();
 585         }
 586
 587         // error position
 588         aErrorText.append(RTL_CONSTASCII_STRINGPARAM("> at ( "));
 589         aErrorText.append(static_cast<sal_Int64>(aError.nLine));
 590         aErrorText.append(RTL_CONSTASCII_STRINGPARAM(", "));
 591         aErrorText.append(static_cast<sal_Int64>(aError.nColumn));
 592         aErrorText.append(RTL_CONSTASCII_STRINGPARAM(" )"));
 593
 594         // reset error
 595         aError = SvIdlError();
 596     }
 597
 598     WriteError("error", OUStringToOString(aFileName,
 599         RTL_TEXTENCODING_UTF8), aErrorText.makeStringAndClear(), nRow, nColumn);
 600
 601     DBG_ASSERT( pTok, "token must be found" );
 602     if( !pTok )
 603         return;
 604
 605     // look for identifier close by
 606     if( !pTok->IsIdentifier() )
 607     {
 608         rInStm.GetToken_PrevAll();
 609         pTok = rInStm.GetToken();
 610     }
 611     if( pTok && pTok->IsIdentifier() )
 612     {
 613         OString aN = IDLAPP->pHashTable->GetNearString( pTok->GetString() );
 614         if( !aN.isEmpty() )
 615             fprintf( stderr, "%s versus %s\n", pTok->GetString().getStr(), aN.getStr() );
 616     }
 617 }
 618
 619 SvIdlWorkingBase::SvIdlWorkingBase(const SvCommand& rCmd) : SvIdlDataBase(rCmd)
 620 {
 621 }
 622
 623 sal_Bool SvIdlWorkingBase::ReadSvIdl( SvTokenStream & rInStm, sal_Bool bImported, const String & rPath )
 624 {
 625     aPath = rPath; // only valid for this iteration
 626     SvToken * pTok;
 627     sal_Bool bOk = sal_True;
 628         pTok = rInStm.GetToken();
 629         // only one import at the very beginning
 630         if( pTok->Is( SvHash_import() ) )
 631         {
 632             rInStm.GetToken_Next();
 633             rInStm.Read( '(' ); // optional
 634             pTok = rInStm.GetToken_Next();
 635             if( pTok->IsString() )
 636             {
 637                 OUString aFullName;
 638                 if( osl::FileBase::E_None == osl::File::searchFileURL(
 639                     OStringToOUString(pTok->GetString(), RTL_TEXTENCODING_ASCII_US),
 640                     rPath,
 641                     aFullName) )
 642                 {
 643                     osl::FileBase::getSystemPathFromFileURL( aFullName, aFullName );
 644                     this->AddDepFile(aFullName);
 645                     SvFileStream aStm( aFullName, STREAM_STD_READ | STREAM_NOCREATE );
 646                     Load( aStm );
 647                     if( aStm.GetError() != SVSTREAM_OK )
 648                     {
 649                         if( aStm.GetError() == SVSTREAM_WRONGVERSION )
 650                         {
 651                             OStringBuffer aStr("wrong version, file ");
 652                             aStr.append(OUStringToOString( aFullName, RTL_TEXTENCODING_UTF8));
 653                             SetError(aStr.makeStringAndClear(), pTok);
 654                             WriteError( rInStm );
 655                             bOk = sal_False;
 656                         }
 657                         else
 658                         {
 659                             aStm.Seek( 0 );
 660                             aStm.ResetError();
 661                             SvTokenStream aTokStm( aStm, aFullName );
 662                             bOk = ReadSvIdl( aTokStm, sal_True, rPath );
 663                         }
 664                     }
 665                 }
 666                 else
 667                     bOk = sal_False;
 668             }
 669             else
 670                 bOk = sal_False;
 671         }
 672
 673     sal_uInt32 nBeginPos = 0xFFFFFFFF; // can not happen with Tell
 674
 675     while( bOk && nBeginPos != rInStm.Tell() )
 676     {
 677         nBeginPos = rInStm.Tell();
 678         pTok = rInStm.GetToken();
 679         if( pTok->IsEof() )
 680             return sal_True;
 681         if( pTok->IsEmpty() )
 682             bOk = sal_False;
 683
 684         // only one import at the very beginning
 685         if( pTok->Is( SvHash_module() ) )
 686         {
 687             SvMetaModuleRef aModule = new SvMetaModule( rInStm.GetFileName(), bImported );
 688             if( aModule->ReadSvIdl( *this, rInStm ) )
 689                 GetModuleList().push_back( aModule );
 690             else
 691                 bOk = sal_False;
 692         }
 693         else
 694             bOk = sal_False;
 695     }
 696     if( !bOk || !pTok->IsEof() )
 697     {
 698          // error treatment
 699          WriteError( rInStm );
 700          return sal_False;
 701     }
 702     return sal_True;
 703 }
 704
 705 sal_Bool SvIdlWorkingBase::WriteSvIdl( SvStream & rOutStm )
 706 {
 707     if( rOutStm.GetError() != SVSTREAM_OK )
 708         return sal_False;
 709
 710     SvStringHashList aList;
 711     if( GetIdTable() )
 712     {
 713         GetIdTable()->FillHashList( &aList );
 714         for ( size_t i = 0, n = aList.size(); i < n; ++i )
 715         {
 716             SvStringHashEntry* pEntry = aList[ i ];
 717             rOutStm << "#define " << pEntry->GetName().getStr()
 718                     << '\t'
 719                     << OString::valueOf(static_cast<sal_Int64>(
 720                         pEntry->GetValue())).getStr()
 721                     << endl;
 722         }
 723     }
 724
 725     for( sal_uLong n = 0; n < GetModuleList().size(); n++ )
 726     {
 727         SvMetaModule * pModule = GetModuleList()[n];
 728         pModule->WriteSvIdl( *this, rOutStm, 0 );
 729     }
 730     return sal_True;
 731 }
 732
 733 sal_Bool SvIdlWorkingBase::WriteSfx( SvStream & rOutStm )
 734 {
 735     if( rOutStm.GetError() != SVSTREAM_OK )
 736         return sal_False;
 737
 738     // reset all tmp variables for writing
 739     WriteReset();
 740     SvMemoryStream aTmpStm( 256000, 256000 );
 741     sal_uLong n;
 742     for( n = 0; n < GetModuleList().size(); n++ )
 743     {
 744         SvMetaModule * pModule = GetModuleList()[n];
 745         if( !pModule->IsImported() )
 746             pModule->WriteSfx( *this, aTmpStm );
 747         aTmpStm.Seek( 0 );
 748     }
 749     for( n = 0; n < aUsedTypes.size(); n++ )
 750     {
 751         SvMetaType * pType = aUsedTypes[n];
 752         pType->WriteSfx( *this, rOutStm );
 753     }
 754     aUsedTypes.clear();
 755     rOutStm << aTmpStm;
 756     return sal_True;
 757 }
 758
 759 sal_Bool SvIdlWorkingBase::WriteHelpIds( SvStream& rOutStm )
 760 {
 761     if( rOutStm.GetError() != SVSTREAM_OK )
 762         return sal_False;
 763
 764     HelpIdTable aIdTable;
 765     sal_uLong n;
 766     for( n = 0; n < GetModuleList().size(); n++ )
 767     {
 768         SvMetaModule * pModule = GetModuleList()[n];
 769         pModule->WriteHelpIds( *this, rOutStm, aIdTable );
 770     }
 771
 772     const SvMetaAttributeMemberList & rAttrList = GetAttrList();
 773     for( n = 0; n < rAttrList.size(); n++ )
 774     {
 775         SvMetaAttribute * pAttr = rAttrList[n];
 776         pAttr->WriteHelpId( *this, rOutStm, aIdTable );
 777     }
 778
 779     return sal_True;
 780 }
 781
 782 sal_Bool SvIdlWorkingBase::WriteSfxItem( SvStream & )
 783 {
 784     return sal_False;
 785 }
 786
 787 void SvIdlDataBase::StartNewFile( const String& rName )
 788 {
 789     bExport = ( aExportFile.EqualsIgnoreCaseAscii( rName ) );
 790 }
 791
 792 void SvIdlDataBase::AppendAttr( SvMetaAttribute *pAttr )
 793 {
 794     aAttrList.push_back( pAttr );
 795     if ( bExport )
 796         pAttr->SetNewAttribute( sal_True );
 797 }
 798
 799 sal_Bool SvIdlWorkingBase::WriteCSV( SvStream& rStrm )
 800 {
 801     SvMetaAttributeMemberList &rList = GetAttrList();
 802     sal_uLong nCount = rList.size();
 803     for ( sal_uLong n=0; n<nCount; n++ )
 804     {
 805         if ( rList[n]->IsNewAttribute() )
 806         {
 807             rList[n]->WriteCSV( *this, rStrm );
 808         }
 809     }
 810
 811     if ( rStrm.GetError() != SVSTREAM_OK )
 812         return sal_False;
 813     else
 814         return sal_True;
 815 }
 816
 817 sal_Bool SvIdlWorkingBase::WriteDocumentation( SvStream & rOutStm )
 818 {
 819     if( rOutStm.GetError() != SVSTREAM_OK )
 820         return sal_False;
 821
 822     for( sal_uLong n = 0; n < GetModuleList().size(); n++ )
 823     {
 824         SvMetaModule * pModule = GetModuleList()[n];
 825         if( !pModule->IsImported() )
 826             pModule->Write( *this, rOutStm, 0, WRITE_DOCU );
 827     }
 828     return sal_True;
 829 }
 830
 831 void SvIdlDataBase::AddDepFile(String const& rFileName)
 832 {
 833     m_DepFiles.insert(rFileName);
 834 }
 835
 836 struct WriteDep
 837 {
 838     SvFileStream & m_rStream;
 839     explicit WriteDep(SvFileStream & rStream) : m_rStream(rStream) { }
 840     void operator() (OUString const& rItem)
 841     {
 842         m_rStream << " \\\n ";
 843         m_rStream << OUStringToOString(rItem, RTL_TEXTENCODING_UTF8).getStr();
 844     }
 845 };
 846
 847 // write a dummy target for one included file, so the incremental build does
 848 // not break with "No rule to make target" if the included file is removed
 849 struct WriteDummy
 850 {
 851     SvFileStream & m_rStream;
 852     explicit WriteDummy(SvFileStream & rStream) : m_rStream(rStream) { }
 853     void operator() (OUString const& rItem)
 854     {
 855         m_rStream << OUStringToOString(rItem, RTL_TEXTENCODING_UTF8).getStr();
 856         m_rStream << " :\n\n";
 857     }
 858 };
 859
 860 bool SvIdlDataBase::WriteDepFile(
 861         SvFileStream & rStream, OUString const& rTarget)
 862 {
 863     rStream << OUStringToOString(rTarget, RTL_TEXTENCODING_UTF8).getStr();
 864     rStream << " :";
 865     ::std::for_each(m_DepFiles.begin(), m_DepFiles.end(), WriteDep(rStream));
 866     rStream << "\n\n";
 867     ::std::for_each(m_DepFiles.begin(), m_DepFiles.end(), WriteDummy(rStream));
 868     return rStream.GetError() == SVSTREAM_OK;
 869 }
 870
 871 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */