rsc/source/tools/rscdef.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 // Programmuebergreifende Includes.
  22 #include <rscdef.hxx>
  23
  24 bool RscId::bNames = true;
  25
  26 void RscId::SetNames( bool bSet )
  27 {
  28     bNames = bSet;
  29 }
  30
  31 sal_Int32 RscId::GetNumber() const
  32 {
  33     sal_Int32 lVal;
  34     aExp.Evaluate( &lVal );
  35     return lVal;
  36 }
  37
  38 void RscId::Create( const RscExpType & rExpType )
  39 {
  40     aExp = rExpType;
  41     if( aExp.IsDefinition() )
  42         aExp.aExp.pDef->IncRef();
  43     else if( aExp.IsExpression() )
  44     {
  45         sal_Int32 lValue;
  46
  47         aExp.Evaluate( &lValue );
  48         aExp.SetLong( lValue );
  49     }
  50 }
  51
  52 void RscId::Destroy()
  53 {
  54     if( aExp.IsDefinition() )
  55         aExp.aExp.pDef->DecRef();
  56     aExp.cType = RSCEXP_NOTHING;
  57 }
  58
  59 RscId::RscId( const RscId& rRscId )
  60 {
  61     aExp = rRscId.aExp;
  62     if( aExp.IsDefinition() )
  63         aExp.aExp.pDef->IncRef();
  64 }
  65
  66 RscId::RscId( RscDefine * pDef )
  67 {
  68     RscExpType aExpType;
  69
  70     aExpType.aExp.pDef = pDef;
  71     aExpType.cType = RSCEXP_DEF;
  72     aExpType.cUnused = false;
  73     Create( aExpType );
  74 }
  75
  76 RscId& RscId::operator = ( const RscId& rRscId )
  77 {
  78     if( rRscId.aExp.IsDefinition() )
  79         rRscId.aExp.aExp.pDef->IncRef();
  80     Destroy();
  81     aExp = rRscId.aExp;
  82     return *this;
  83 }
  84
  85 bool RscId::operator == ( const RscId& rRscId ) const
  86 {
  87     return GetNumber() == rRscId.GetNumber();
  88 }
  89
  90 bool RscId::operator < ( const RscId& rRscId ) const
  91 {
  92     return GetNumber() < rRscId.GetNumber();
  93 }
  94
  95 bool RscId::operator > ( const RscId& rRscId ) const
  96 {
  97     return GetNumber() > rRscId.GetNumber();
  98 }
  99
 100 RscId::operator sal_Int32() const
 101 {
 102     return GetNumber();
 103 }
 104
 105 OString RscId::GetName() const
 106 {
 107     OStringBuffer aStr;
 108
 109     if ( !aExp.IsNothing() )
 110     {
 111         if( bNames )
 112             aExp.AppendMacro(aStr);
 113         else
 114             aStr.append(GetNumber());
 115     }
 116
 117     return aStr.makeStringAndClear();
 118 }
 119
 120 RscDefine::RscDefine( sal_uLong lKey, const OString& rDefName, sal_Int32 lDefId )
 121     : StringNode( rDefName )
 122 {
 123     nRefCount = 0;
 124     lFileKey  = lKey;
 125     lId       = lDefId;
 126     pExp      = NULL;
 127 }
 128
 129 RscDefine::RscDefine( sal_uLong lKey, const OString& rDefName,
 130                       RscExpression * pExpression  )
 131     : StringNode( rDefName )
 132     , lId(0)
 133 {
 134     nRefCount = 0;
 135     lFileKey  = lKey;
 136     pExpression->Evaluate( &lId );
 137     pExp      = pExpression;
 138 }
 139
 140 RscDefine::~RscDefine()
 141 {
 142     delete pExp;
 143     if( nRefCount )
 144         RscExit( 14 );
 145 }
 146
 147 void RscDefine::DecRef()
 148 {
 149     nRefCount--;
 150     if( 0 == nRefCount )
 151     {
 152         delete this;
 153     }
 154 }
 155
 156 void RscDefine::DefineToNumber()
 157 {
 158     if( pExp )
 159         delete pExp;
 160     pExp = NULL;
 161     SetName(OString::number(lId));
 162 }
 163
 164 bool RscDefine::Evaluate()
 165 {
 166     bool    bRet = true;
 167
 168     if( pExp )
 169         bRet = !pExp->Evaluate( &lId );
 170
 171     return bRet;
 172 }
 173
 174 RscDefine * RscDefine::Search( const char * pStr )
 175 {
 176     return static_cast<RscDefine *>(StringNode::Search( pStr ));
 177 }
 178
 179 OString RscDefine::GetMacro()
 180 {
 181     if( pExp )
 182         return pExp->GetMacro();
 183     return OString::number(lId);
 184 }
 185
 186 RscDefine * RscDefineList::New( sal_uLong lFileKey, const OString& rDefName,
 187                                 sal_Int32 lDefId, size_t lPos )
 188 {
 189     RscDefine * pDef;
 190
 191     pDef = new RscDefine( lFileKey, rDefName, lDefId );
 192     pDef->IncRef();
 193     if ( lPos < maList.size() )
 194     {
 195         RscSubDefList::iterator it = maList.begin();
 196         ::std::advance( it, lPos );
 197         maList.insert( it, pDef );
 198     }
 199     else
 200     {
 201         maList.push_back( pDef );
 202     }
 203     return pDef;
 204 }
 205
 206 RscDefine * RscDefineList::New( sal_uLong lFileKey, const OString& rDefName,
 207                                 RscExpression * pExpression, size_t lPos )
 208 {
 209     RscDefine * pDef;
 210
 211     pDef = new RscDefine( lFileKey, rDefName, pExpression );
 212     pDef->IncRef();
 213     if ( lPos < maList.size() )
 214     {
 215         RscSubDefList::iterator it = maList.begin();
 216         ::std::advance( it, lPos );
 217         maList.insert( it, pDef );
 218     }
 219     else
 220     {
 221         maList.push_back( pDef );
 222     }
 223     return pDef;
 224 }
 225
 226 bool RscDefineList::Remove()
 227 {
 228     if ( maList.empty() )
 229         return false;
 230
 231     maList[ 0 ]->DefineToNumber();
 232     maList[ 0 ]->DecRef();
 233     maList.erase( maList.begin() );
 234     return true;
 235 }
 236
 237 void RscDefineList::WriteAll( FILE * fOutput )
 238 {
 239     for ( size_t i = 0, n = maList.size(); i < n; ++i )
 240     {
 241         RscDefine* pDefEle = maList[ i ];
 242         fprintf( fOutput, "#define %s %s\n",
 243                  pDefEle->GetName().getStr(),
 244                  pDefEle->GetMacro().getStr()
 245         );
 246     }
 247 }
 248
 249 bool RscExpType::Evaluate( sal_Int32 * plValue ) const
 250 {
 251     if( IsDefinition() )
 252     {
 253         aExp.pDef->Evaluate();
 254         // Eventuellen Fehler ignorieren
 255         *plValue = aExp.pDef->GetNumber();
 256     }
 257     else if( IsExpression() )
 258         return aExp.pExp->Evaluate( plValue );
 259     else if( IsNothing() )
 260         *plValue = 0;
 261     else
 262         *plValue = GetLong();
 263
 264     return true;
 265 }
 266
 267 void RscExpType::AppendMacro(OStringBuffer& rStr) const
 268 {
 269     if( IsDefinition() )
 270         rStr.append(aExp.pDef->GetName());
 271     else if( IsExpression() )
 272         rStr.append(aExp.pExp->GetMacro());
 273     else if( IsNumber() )
 274         rStr.append(GetLong());
 275 }
 276
 277
 278 RscExpression::RscExpression( RscExpType aLE, char cOp, RscExpType aRE )
 279 {
 280     aLeftExp   = aLE;
 281     cOperation = cOp;
 282     aRightExp  = aRE;
 283     if( aLeftExp.IsDefinition() )
 284         aLeftExp.aExp.pDef->IncRef();
 285     if( aRightExp.IsDefinition() )
 286         aRightExp.aExp.pDef->IncRef();
 287 }
 288
 289 RscExpression::~RscExpression()
 290 {
 291     if( aLeftExp.IsDefinition() )
 292         aLeftExp.aExp.pDef->DecRef();
 293     else if( aLeftExp.IsExpression() )
 294         delete aLeftExp.aExp.pExp;
 295
 296     if( aRightExp.IsDefinition() )
 297         aRightExp.aExp.pDef->DecRef();
 298     else if( aRightExp.IsExpression() )
 299         delete aRightExp.aExp.pExp;
 300 }
 301
 302 bool RscExpression::Evaluate( sal_Int32 * plValue )
 303 {
 304     sal_Int32 lLeft;
 305     sal_Int32 lRight;
 306
 307     // linken und rechten Zweig auswerten
 308     if( aLeftExp.Evaluate( &lLeft ) && aRightExp.Evaluate( &lRight ) )
 309     {
 310         if( cOperation == '&' )
 311             *plValue = lLeft & lRight;
 312         else if( cOperation == '|' )
 313             *plValue = lLeft | lRight;
 314         else if( cOperation == '+' )
 315             *plValue = lLeft + lRight;
 316         else if( cOperation == '-' )
 317             *plValue = lLeft - lRight;
 318         else if( cOperation == '*' )
 319             *plValue = lLeft * lRight;
 320         else if( cOperation == 'r' )
 321             *plValue = lLeft >> lRight;
 322         else if( cOperation == 'l' )
 323             *plValue = lLeft << lRight;
 324         else
 325         {
 326             if( 0L == lRight )
 327                 return false;
 328             *plValue = lLeft / lRight;
 329         }
 330         return true;
 331     }
 332     return false;
 333 }
 334
 335 OString RscExpression::GetMacro()
 336 {
 337     OStringBuffer aLeft;
 338
 339     // Ausgabeoptimierung
 340     if( aLeftExp.IsNothing() )
 341     {
 342         if ( '-' == cOperation )
 343         {
 344             aLeft.append('(');
 345             aLeft.append('-');
 346         }
 347         aRightExp.AppendMacro(aLeft);
 348         if( '-' == cOperation )
 349         {
 350             aLeft.append(')');
 351         }
 352     }
 353     else if( aRightExp.IsNothing() )
 354         aLeftExp.AppendMacro(aLeft);
 355     else
 356     {
 357         aLeft.append('(');
 358         // linken Zweig auswerten
 359         aLeftExp.AppendMacro(aLeft);
 360
 361         aLeft.append(cOperation);
 362
 363         aLeft.append('(');
 364         // rechten Zweig auswerten
 365         aRightExp.AppendMacro(aLeft);
 366         aLeft.append(')');
 367
 368         aLeft.append(')');
 369     }
 370
 371     return aLeft.makeStringAndClear();
 372 }
 373
 374 RscFile :: RscFile()
 375 {
 376     bLoaded  = false;
 377     bIncFile = false;
 378     bDirty   = false;
 379     bScanned = false;
 380 }
 381
 382 RscFile :: ~RscFile()
 383 {
 384     for ( size_t i = 0, n = aDepLst.size(); i < n; ++i )
 385         delete aDepLst[ i ];
 386     aDepLst.clear();
 387
 388     //von hinten nach vorne ist besser wegen der Abhaengigkeiten
 389     //Objekte zerstoeren sich, wenn Referenzzaehler NULL
 390     while( aDefLst.Remove() ) ;
 391 }
 392
 393 bool RscFile::Depend( sal_uLong lDepend, sal_uLong lFree )
 394 {
 395     for ( size_t i = aDepLst.size(); i > 0; )
 396     {
 397         RscDepend * pDep = aDepLst[ --i ];
 398         if( pDep->GetFileKey() == lDepend )
 399         {
 400             for ( size_t j = i ? --i : 0; j > 0; )
 401             {
 402                 pDep = aDepLst[ --j ];
 403                 if( pDep->GetFileKey() == lFree )
 404                     return true;
 405             }
 406             return false;
 407         }
 408     }
 409     return true;
 410 }
 411
 412 bool RscFile :: InsertDependFile( sal_uLong lIncFile, size_t lPos )
 413 {
 414     for ( size_t i = 0, n = aDepLst.size(); i < n; ++i )
 415     {
 416         RscDepend* pDep = aDepLst[ i ];
 417         if( pDep->GetFileKey() == lIncFile )
 418             return true;
 419     }
 420
 421     // Current-Zeiger steht auf letztem Element
 422     if( lPos >= aDepLst.size() )
 423     { //letztes Element muss immer letztes bleiben
 424         // Abhaengigkeit vor der letzten Position eintragen
 425         aDepLst.push_back( new RscDepend( lIncFile ) );
 426     }
 427     else
 428     {
 429         RscDependList::iterator it = aDepLst.begin();
 430         ::std::advance( it, lPos );
 431         aDepLst.insert( it, new RscDepend( lIncFile ) );
 432     }
 433     return true;
 434 }
 435
 436 RscDefTree::~RscDefTree()
 437 {
 438     Remove();
 439 }
 440
 441 void RscDefTree::Remove()
 442 {
 443     while( pDefRoot )
 444     {
 445         RscDefine * pDef = pDefRoot;
 446         pDefRoot = static_cast<RscDefine *>(pDefRoot->Remove( pDefRoot ));
 447         pDef->DecRef();
 448     }
 449 }
 450
 451 RscDefine * RscDefTree::Search( const char * pName )
 452 {
 453     if( pDefRoot )
 454         return pDefRoot->Search( pName );
 455     return NULL;
 456 }
 457
 458 void RscDefTree::Insert( RscDefine * pDef )
 459 {
 460     if( pDefRoot )
 461         pDefRoot->Insert( pDef );
 462     else
 463         pDefRoot = pDef;
 464     pDef->IncRef();
 465 }
 466
 467 void RscDefTree::Remove( RscDefine * pDef )
 468 {
 469     if( pDefRoot )
 470     {
 471         //falls pDef == pDefRoot
 472         pDefRoot = static_cast<RscDefine *>(pDefRoot->Remove( pDef ));
 473     }
 474     pDef->DecRef();
 475 }
 476
 477 bool RscDefTree::Evaluate( RscDefine * pDef )
 478 {
 479     if( pDef )
 480     {
 481         if( !Evaluate( static_cast<RscDefine *>(pDef->Left()) ) )
 482             return false;
 483         if( !Evaluate( static_cast<RscDefine *>(pDef->Right()) ) )
 484             return false;
 485     }
 486     return true;
 487 }
 488
 489 RscFileTab::RscFileTab()
 490 {
 491 }
 492
 493 RscFileTab :: ~RscFileTab()
 494 {
 495
 496     aDefTree.Remove();
 497
 498     sal_uIntPtr aIndex = LastIndex();
 499     while( aIndex != UNIQUEINDEX_ENTRY_NOTFOUND )
 500     {
 501         delete Remove( aIndex );
 502         aIndex = LastIndex();
 503     };
 504 }
 505
 506 sal_uLong  RscFileTab :: Find( const OString& rName )
 507 {
 508     sal_uIntPtr aIndex = FirstIndex();
 509     while( aIndex != UNIQUEINDEX_ENTRY_NOTFOUND && (Get(aIndex)->aFileName != rName) )
 510         aIndex = NextIndex(aIndex);
 511
 512     if( aIndex != UNIQUEINDEX_ENTRY_NOTFOUND )
 513         return aIndex;
 514     else
 515         return NOFILE_INDEX;
 516 }
 517
 518 RscDefine * RscFileTab::FindDef( const char * pName )
 519 {
 520     return aDefTree.Search( pName );
 521 }
 522
 523 /* This method gives back true when lDepend
 524    exists and is behind lFree, or when lDepend does not exist. */
 525 bool RscFileTab::Depend( sal_uLong lDepend, sal_uLong lFree )
 526 {
 527     if( lDepend == lFree )
 528         return true;
 529
 530     sal_uIntPtr aIndex = FirstIndex();
 531     while( aIndex != UNIQUEINDEX_ENTRY_NOTFOUND )
 532     {
 533         RscFile * pFile = Get(aIndex);
 534         if( !pFile->IsIncFile() )
 535         {
 536             if( !pFile->Depend( lDepend, lFree ) )
 537                 return false;
 538         }
 539         aIndex = NextIndex(aIndex);
 540     }
 541
 542     return true;
 543 }
 544
 545 bool RscFileTab::TestDef( sal_uLong lFileKey, size_t lPos,
 546                           const RscDefine * pDefDec )
 547 {
 548     if( lFileKey == pDefDec->GetFileKey() )
 549     {
 550         RscFile * pFile = GetFile( pDefDec->GetFileKey() );
 551         if( pFile && (lPos <= pFile->aDefLst.GetPos( const_cast<RscDefine *>(pDefDec) ))
 552             && (lPos != ULONG_MAX ) )
 553         {
 554             return false;
 555         }
 556     }
 557     else if( !Depend( lFileKey, pDefDec->GetFileKey() ) )
 558         return false;
 559
 560     return TestDef( lFileKey, lPos, pDefDec->pExp );
 561 }
 562
 563 bool RscFileTab::TestDef( sal_uLong lFileKey, size_t lPos,
 564                           const RscExpression * pExpDec )
 565 {
 566     if( !pExpDec )
 567         return true;
 568
 569     if( pExpDec->aLeftExp.IsExpression() )
 570         if( !TestDef( lFileKey, lPos, pExpDec->aLeftExp.aExp.pExp ) )
 571             return false;
 572
 573     if( pExpDec->aLeftExp.IsDefinition() )
 574         if( !TestDef( lFileKey, lPos, pExpDec->aLeftExp.aExp.pDef ) )
 575             return false;
 576
 577     if( pExpDec->aRightExp.IsExpression() )
 578         if( !TestDef( lFileKey, lPos, pExpDec->aRightExp.aExp.pExp ) )
 579             return false;
 580
 581     if( pExpDec->aRightExp.IsDefinition() )
 582         if( !TestDef( lFileKey, lPos, pExpDec->aRightExp.aExp.pDef ) )
 583             return false;
 584
 585     return true;
 586 }
 587
 588 RscDefine * RscFileTab::NewDef( sal_uLong lFileKey, const OString& rDefName,
 589                                 sal_Int32 lId, sal_uLong lPos )
 590 {
 591     RscDefine * pDef = FindDef( rDefName );
 592
 593     if( !pDef )
 594     {
 595         RscFile * pFile = GetFile( lFileKey );
 596
 597         if( pFile )
 598         {
 599             pDef = pFile->aDefLst.New( lFileKey, rDefName, lId, lPos );
 600             aDefTree.Insert( pDef );
 601         }
 602     }
 603     else
 604         pDef = NULL;
 605
 606     return pDef;
 607 }
 608
 609 RscDefine * RscFileTab::NewDef( sal_uLong lFileKey, const OString& rDefName,
 610                                 RscExpression * pExp, sal_uLong lPos )
 611 {
 612     RscDefine * pDef = FindDef( rDefName );
 613
 614     if( !pDef )
 615     {
 616         //Macros in den Expressions sind definiert ?
 617         if( TestDef( lFileKey, lPos, pExp ) )
 618         {
 619             RscFile * pFile = GetFile( lFileKey );
 620
 621             if( pFile )
 622             {
 623                 pDef = pFile->aDefLst.New( lFileKey, rDefName, pExp, lPos );
 624                 aDefTree.Insert( pDef );
 625             }
 626         }
 627     }
 628     else
 629         pDef = NULL;
 630
 631     if( !pDef )
 632     {
 633         // pExp wird immer Eigentum und muss, wenn es nicht benoetigt wird
 634         // geloescht werden
 635         delete pExp;
 636     }
 637     return pDef;
 638 }
 639
 640 void RscFileTab :: DeleteFileContext( sal_uLong lFileKey )
 641 {
 642     RscFile     * pFName;
 643
 644     pFName = GetFile( lFileKey );
 645     if( pFName )
 646     {
 647         for ( size_t i = 0, n = pFName->aDefLst.maList.size(); i < n; ++i )
 648         {
 649             RscDefine * pDef = pFName->aDefLst.maList[ i ];
 650             aDefTree.Remove( pDef );
 651         };
 652
 653         while( pFName->aDefLst.Remove() ) ;
 654     }
 655 }
 656
 657 sal_uLong  RscFileTab :: NewCodeFile( const OString& rName )
 658 {
 659     sal_uLong lKey = Find( rName );
 660     if( UNIQUEINDEX_ENTRY_NOTFOUND == lKey )
 661     {
 662         RscFile * pFName = new RscFile();
 663         pFName->aFileName = rName;
 664         pFName->aPathName = rName;
 665         lKey = Insert( pFName );
 666         pFName->InsertDependFile( lKey, ULONG_MAX );
 667     }
 668     return lKey;
 669 }
 670
 671 sal_uLong  RscFileTab :: NewIncFile(const OString& rName,
 672                                     const OString& rPath)
 673 {
 674     sal_uLong lKey = Find( rName );
 675     if( UNIQUEINDEX_ENTRY_NOTFOUND == lKey )
 676     {
 677         RscFile * pFName = new RscFile();
 678         pFName->aFileName = rName;
 679         pFName->aPathName = rPath;
 680         pFName->SetIncFlag();
 681         lKey = Insert( pFName );
 682         pFName->InsertDependFile( lKey, ULONG_MAX );
 683     }
 684     return lKey;
 685 }
 686
 687 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */