rsc/source/tools/rscdef.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 // MARKER(update_precomp.py): autogen include statement, do not remove
  29 #include "precompiled_rsc.hxx"
  30 /****************** I N C L U D E S **************************************/
  31
  32 // Programmuebergreifende Includes.
  33 #include <rscdef.hxx>
  34
  35 /****************** C o d e **********************************************/
  36 /****************** R s c I d ********************************************/
  37 sal_Bool RscId::bNames = sal_True;
  38
  39 /*************************************************************************
  40 |*
  41 |*    static RscId::SetNames
  42 |*    static RscId::SetNoNames
  43 |*
  44 |*    Beschreibung
  45 |*    Ersterstellung    MM 26.06.91
  46 |*    Letzte Aenderung  MM 26.06.91
  47 |*
  48 *************************************************************************/
  49 void RscId::SetNames( sal_Bool bSet )  { bNames = bSet;  }
  50 sal_Bool RscId::IsSetNames()           { return bNames;  }
  51
  52 /*************************************************************************
  53 |*
  54 |*    RscId::GetNumber
  55 |*
  56 |*    Beschreibung
  57 |*    Ersterstellung    MM 17.05.91
  58 |*    Letzte Aenderung  MM 17.05.91
  59 |*
  60 *************************************************************************/
  61 sal_Int32 RscId::GetNumber() const{
  62     sal_Int32 lVal;
  63     aExp.Evaluate( &lVal );
  64     return lVal;
  65 }
  66
  67 /*************************************************************************
  68 |*
  69 |*    RscId::Create()
  70 |*
  71 |*    Beschreibung
  72 |*    Ersterstellung    MM 01.11.91
  73 |*    Letzte Aenderung  MM 01.11.91
  74 |*
  75 *************************************************************************/
  76 void RscId::Create( const RscExpType & rExpType )
  77 {
  78     aExp = rExpType;
  79     if( aExp.IsDefinition() )
  80         aExp.aExp.pDef->IncRef();
  81     else if( aExp.IsExpression() ){
  82         sal_Int32 lValue;
  83
  84         aExp.Evaluate( &lValue );
  85         aExp.SetLong( lValue );
  86     }
  87 }
  88
  89 /*************************************************************************
  90 |*
  91 |*    RscId::Destroy()
  92 |*
  93 |*    Beschreibung
  94 |*    Ersterstellung    MM 01.11.91
  95 |*    Letzte Aenderung  MM 01.11.91
  96 |*
  97 *************************************************************************/
  98 void RscId::Destroy(){
  99     if( aExp.IsDefinition() )
 100         aExp.aExp.pDef->DecRef();
 101     aExp.cType = RSCEXP_NOTHING;
 102 }
 103
 104 /*************************************************************************
 105 |*
 106 |*    RscId::RscId()
 107 |*
 108 |*    Beschreibung
 109 |*    Ersterstellung    MM 01.11.91
 110 |*    Letzte Aenderung  MM 01.11.91
 111 |*
 112 *************************************************************************/
 113 RscId::RscId( const RscId& rRscId ){
 114     aExp = rRscId.aExp;
 115     if( aExp.IsDefinition() )
 116         aExp.aExp.pDef->IncRef();
 117 }
 118
 119 /*************************************************************************
 120 |*
 121 |*    RscId::RscId()
 122 |*
 123 |*    Beschreibung
 124 |*    Ersterstellung    MM 01.11.91
 125 |*    Letzte Aenderung  MM 25.11.91
 126 |*
 127 *************************************************************************/
 128 RscId::RscId( RscDefine * pDef ){
 129     RscExpType aExpType;
 130
 131     aExpType.aExp.pDef = pDef;
 132     aExpType.cType = RSCEXP_DEF;
 133     Create( aExpType );
 134 }
 135
 136 /*************************************************************************
 137 |*
 138 |*    RscId:: =
 139 |*
 140 |*    Beschreibung
 141 |*    Ersterstellung    MM 01.11.91
 142 |*    Letzte Aenderung  MM 01.11.91
 143 |*
 144 *************************************************************************/
 145 RscId& RscId::operator = ( const RscId& rRscId ){
 146     if( rRscId.aExp.IsDefinition() )
 147         rRscId.aExp.aExp.pDef->IncRef();
 148     Destroy();
 149     aExp = rRscId.aExp;
 150     return *this;
 151 }
 152
 153 /*************************************************************************
 154 |*
 155 |*    RscId::operator ==
 156 |*
 157 |*    Beschreibung
 158 |*    Ersterstellung    MM 16.05.91
 159 |*    Letzte Aenderung  MM 16.05.91
 160 |*
 161 *************************************************************************/
 162 sal_Bool RscId::operator == ( const RscId& rRscId ) const
 163 {
 164     return( GetNumber() == rRscId.GetNumber() );
 165 }
 166
 167 /*************************************************************************
 168 |*
 169 |*    RscId::operator <
 170 |*
 171 |*    Beschreibung
 172 |*    Ersterstellung    MM 16.05.91
 173 |*    Letzte Aenderung  MM 16.05.91
 174 |*
 175 *************************************************************************/
 176 sal_Bool RscId::operator < ( const RscId& rRscId ) const
 177 {
 178     return( GetNumber() < rRscId.GetNumber() );
 179 }
 180
 181 /*************************************************************************
 182 |*
 183 |*    RscId::operator >
 184 |*
 185 |*    Beschreibung
 186 |*    Ersterstellung    MM 16.05.91
 187 |*    Letzte Aenderung  MM 16.05.91
 188 |*
 189 *************************************************************************/
 190 sal_Bool RscId::operator > ( const RscId& rRscId ) const
 191 {
 192     return( GetNumber() > rRscId.GetNumber() );
 193 }
 194
 195 /*************************************************************************
 196 |*
 197 |*    RscId::sal_Int32()
 198 |*
 199 |*    Beschreibung
 200 |*    Ersterstellung    MM 16.05.91
 201 |*    Letzte Aenderung  MM 16.05.91
 202 |*
 203 *************************************************************************/
 204 RscId::operator sal_Int32() const
 205 {
 206     return( GetNumber() );
 207 }
 208
 209 /*************************************************************************
 210 |*
 211 |*    RscId::GetNames()
 212 |*
 213 |*    Beschreibung
 214 |*    Ersterstellung    MM 16.05.91
 215 |*    Letzte Aenderung  MM 25.11.91
 216 |*
 217 *************************************************************************/
 218 ByteString RscId::GetName() const
 219 {
 220     ByteString aStr;
 221
 222     if ( !aExp.IsNothing() )
 223     {
 224         if( bNames )
 225             aExp.GetMacro( aStr );
 226         else
 227             aStr = ByteString::CreateFromInt32( GetNumber() );
 228     }
 229
 230     return aStr;
 231 }
 232
 233 /*************************************************************************
 234 |*
 235 |*    RscId::GetMacro()
 236 |*
 237 |*    Beschreibung
 238 |*    Ersterstellung    MM 01.11.91
 239 |*    Letzte Aenderung  MM 25.11.91
 240 |*
 241 *************************************************************************/
 242 ByteString RscId::GetMacro() const
 243 {
 244     ByteString aStr;
 245
 246     if ( aExp.IsDefinition() )
 247         aStr = aExp.aExp.pDef->GetMacro();
 248     else
 249         aExp.GetMacro( aStr );
 250
 251     return aStr;
 252 }
 253
 254 /****************** R s c D e f i n e ************************************/
 255 /*************************************************************************
 256 |*
 257 |*    RscDefine::RscDefine()
 258 |*
 259 |*    Beschreibung
 260 |*    Ersterstellung    MM 01.11.91
 261 |*    Letzte Aenderung  MM 01.11.91
 262 |*
 263 *************************************************************************/
 264 RscDefine::RscDefine( sal_uLong lKey, const ByteString & rDefName, sal_Int32 lDefId )
 265     : StringNode( rDefName )
 266 {
 267     nRefCount = 0;
 268     lFileKey  = lKey;
 269     lId       = lDefId;
 270     pExp      = NULL;
 271 }
 272
 273 RscDefine::RscDefine( sal_uLong lKey, const ByteString & rDefName,
 274                       RscExpression * pExpression  )
 275     : StringNode( rDefName )
 276 {
 277     nRefCount = 0;
 278     lFileKey  = lKey;
 279     pExpression->Evaluate( &lId );
 280     pExp      = pExpression;
 281 }
 282
 283 /*************************************************************************
 284 |*
 285 |*    RscDefine::~RscDefine()
 286 |*
 287 |*    Beschreibung
 288 |*    Ersterstellung    MM 01.11.91
 289 |*    Letzte Aenderung  MM 01.11.91
 290 |*
 291 *************************************************************************/
 292 RscDefine::~RscDefine(){
 293     if( pExp )
 294         delete pExp;
 295     if( nRefCount )
 296         RscExit( 14 );
 297 }
 298
 299 /*************************************************************************
 300 |*
 301 |*    RscDefine::DecRef()
 302 |*
 303 |*    Beschreibung
 304 |*    Ersterstellung    MM 01.11.91
 305 |*    Letzte Aenderung  MM 01.11.91
 306 |*
 307 *************************************************************************/
 308 void RscDefine::DecRef(){
 309     nRefCount--;
 310     if( 0 == nRefCount ){
 311         delete this;
 312     }
 313 }
 314
 315 /*************************************************************************
 316 |*
 317 |*    RscDefine::DefineToNumber()
 318 |*
 319 |*    Beschreibung
 320 |*    Ersterstellung    MM 07.11.91
 321 |*    Letzte Aenderung  MM 07.11.91
 322 |*
 323 *************************************************************************/
 324 void RscDefine::DefineToNumber()
 325 {
 326     if( pExp )
 327         delete pExp;
 328     pExp = NULL;
 329     SetName( ByteString::CreateFromInt32( lId ) );
 330 }
 331
 332 /*************************************************************************
 333 |*
 334 |*    RscDefine::ChangeMacro()
 335 |*
 336 |*    Beschreibung
 337 |*    Ersterstellung    MM 04.11.91
 338 |*    Letzte Aenderung  MM 04.11.91
 339 |*
 340 *************************************************************************/
 341 void RscDefine::ChangeMacro( RscExpression * pExpression ){
 342     if( pExp )
 343         delete pExp;
 344     pExp = pExpression;
 345     pExp->Evaluate( &lId );
 346 }
 347
 348 void RscDefine::ChangeMacro( sal_Int32 lIdentifier ){
 349     if( pExp ){
 350         delete pExp;
 351         pExp = NULL;
 352     }
 353     lId = lIdentifier;
 354 }
 355
 356 /*************************************************************************
 357 |*
 358 |*    RscDefine::Evaluate()
 359 |*
 360 |*    Beschreibung
 361 |*    Ersterstellung    MM 01.11.91
 362 |*    Letzte Aenderung  MM 01.11.91
 363 |*
 364 *************************************************************************/
 365 sal_Bool RscDefine::Evaluate(){
 366     sal_Bool    bRet = sal_True;
 367
 368     if( pExp )
 369         bRet = !pExp->Evaluate( &lId );
 370
 371     return bRet;
 372 }
 373
 374 /*************************************************************************
 375 |*
 376 |*    RscDefine::Search()
 377 |*
 378 |*    Beschreibung
 379 |*    Ersterstellung    MM 11.11.91
 380 |*    Letzte Aenderung  MM 11.11.91
 381 |*
 382 *************************************************************************/
 383 RscDefine * RscDefine::Search( const char * pStr ){
 384     return (RscDefine *)StringNode::Search( pStr );
 385 }
 386
 387 /*************************************************************************
 388 |*
 389 |*    RscDefine::GetMacro()
 390 |*
 391 |*    Beschreibung
 392 |*    Ersterstellung    MM 01.11.91
 393 |*    Letzte Aenderung  MM 01.11.91
 394 |*
 395 *************************************************************************/
 396 ByteString RscDefine::GetMacro()
 397 {
 398     if( pExp )
 399         return pExp->GetMacro();
 400     return ByteString::CreateFromInt32( lId );
 401 }
 402
 403 /****************** R s c D e f i n e L i s t ****************************/
 404 /*************************************************************************
 405 |*
 406 |*    RscDefineList::New()
 407 |*
 408 |*    Beschreibung
 409 |*    Ersterstellung    MM 04.11.91
 410 |*    Letzte Aenderung  MM 04.11.91
 411 |*
 412 *************************************************************************/
 413 RscDefine * RscDefineList::New( sal_uLong lFileKey, const ByteString & rDefName,
 414                                 sal_Int32 lDefId, sal_uLong lPos )
 415 {
 416     RscDefine * pDef;
 417
 418     pDef = new RscDefine( lFileKey, rDefName, lDefId );
 419     pDef->IncRef();
 420     Insert( pDef, lPos );
 421     return pDef;
 422 }
 423
 424 RscDefine * RscDefineList::New( sal_uLong lFileKey, const ByteString & rDefName,
 425                                 RscExpression * pExpression, sal_uLong lPos )
 426 {
 427     RscDefine * pDef;
 428
 429     pDef = new RscDefine( lFileKey, rDefName, pExpression );
 430     pDef->IncRef();
 431     Insert( pDef, lPos );
 432
 433     return pDef;
 434 }
 435
 436 /*************************************************************************
 437 |*
 438 |*    RscDefineList::Remove()
 439 |*
 440 |*    Beschreibung
 441 |*    Ersterstellung    MM 04.11.91
 442 |*    Letzte Aenderung  MM 04.11.91
 443 |*
 444 *************************************************************************/
 445 sal_Bool RscDefineList::Remove( RscDefine * pDef ){
 446     pDef = RscSubDefList::Remove( pDef );
 447     if( pDef ){
 448         pDef->DefineToNumber();
 449         pDef->DecRef();
 450     }
 451
 452     return( NULL != pDef );
 453 }
 454
 455 sal_Bool RscDefineList::Remove( sal_uLong lIndex ){
 456     RscDefine * pDef = RscSubDefList::Remove( lIndex );
 457     if( pDef ){
 458         pDef->DefineToNumber();
 459         pDef->DecRef();
 460     }
 461
 462     return( NULL != pDef );
 463 }
 464
 465 sal_Bool RscDefineList::Remove(){
 466     RscDefine * pDef;
 467
 468     pDef = RscSubDefList::Remove( (sal_uLong)0 );
 469
 470     if( pDef ){
 471         pDef->DefineToNumber();
 472         pDef->DecRef();
 473     }
 474     return( NULL != pDef );
 475 }
 476
 477 /*************************************************************************
 478 |*
 479 |*    RscDefineList::Befor()
 480 |*
 481 |*    Beschreibung
 482 |*    Ersterstellung    MM 12.11.91
 483 |*    Letzte Aenderung  MM 12.11.91
 484 |*
 485 *************************************************************************/
 486 sal_Bool RscDefineList::Befor( const RscDefine * pFree,
 487                            const RscDefine * pDepend )
 488 {
 489     RscDefine * pDef;
 490
 491     pDef = First();
 492     while( pDef ){
 493         if( pDef == pFree ){
 494             pDef = Next();
 495             while( pDef ){
 496                 if( pDef == pDepend )
 497                     return sal_True;
 498                 pDef = Next();
 499             }
 500         }
 501         pDef = Next();
 502     };
 503     return sal_False;
 504 }
 505
 506 /*************************************************************************
 507 |*
 508 |*    RscDefineList::WriteAll()
 509 |*
 510 |*    Beschreibung
 511 |*    Ersterstellung    MM 28.10.91
 512 |*    Letzte Aenderung  MM 28.10.91
 513 |*
 514 *************************************************************************/
 515 void RscDefineList::WriteAll( FILE * fOutput )
 516 {
 517     RscDefine * pDefEle = First();
 518
 519     while( pDefEle )
 520     {
 521         fprintf( fOutput, "#define %s %s\n",
 522                  pDefEle->GetName().GetBuffer(),
 523                  pDefEle->GetMacro().GetBuffer() );
 524         pDefEle = Next();
 525     };
 526 }
 527
 528 /****************** R s c E x p T y p e **********************************/
 529 /*************************************************************************
 530 |*
 531 |*    RscExpType::Evaluate()
 532 |*
 533 |*    Beschreibung
 534 |*    Ersterstellung    MM 01.11.91
 535 |*    Letzte Aenderung  MM 01.11.91
 536 |*
 537 *************************************************************************/
 538 sal_Bool RscExpType::Evaluate( sal_Int32 * plValue ) const{
 539     if( IsDefinition() ){
 540         aExp.pDef->Evaluate();
 541         // Eventuellen Fehler ignorieren
 542         *plValue = aExp.pDef->GetNumber();
 543     }
 544     else if( IsExpression() )
 545         return( aExp.pExp->Evaluate( plValue ) );
 546     else if( IsNothing() )
 547         *plValue = 0;
 548     else
 549         *plValue = GetLong();
 550
 551     return sal_True;
 552 }
 553
 554 /*************************************************************************
 555 |*
 556 |*    RscExpType::GetMacro()
 557 |*
 558 |*    Beschreibung
 559 |*    Ersterstellung    MM 01.11.91
 560 |*    Letzte Aenderung  MM 01.11.91
 561 |*
 562 *************************************************************************/
 563 void RscExpType::GetMacro( ByteString & rStr ) const
 564 {
 565     ByteString aStr;
 566
 567     if( IsDefinition() )
 568     {
 569         rStr += aExp.pDef->GetName();
 570     }
 571     else if( IsExpression() )
 572         rStr += aExp.pExp->GetMacro();
 573     else if( IsNumber() )
 574         rStr += ByteString::CreateFromInt32( GetLong() );
 575 }
 576
 577
 578 /****************** R s c E x p r e s s i o n ****************************/
 579 /*************************************************************************
 580 |*
 581 |*    RscExpression::RscExpression()
 582 |*
 583 |*    Beschreibung
 584 |*    Ersterstellung    MM 01.11.91
 585 |*    Letzte Aenderung  MM 01.11.91
 586 |*
 587 *************************************************************************/
 588 RscExpression::RscExpression( RscExpType aLE, char cOp, RscExpType aRE )
 589 {
 590     aLeftExp   = aLE;
 591     cOperation = cOp;
 592     aRightExp  = aRE;
 593     if( aLeftExp.IsDefinition() )
 594         aLeftExp.aExp.pDef->IncRef();
 595     if( aRightExp.IsDefinition() )
 596         aRightExp.aExp.pDef->IncRef();
 597 }
 598
 599 /*************************************************************************
 600 |*
 601 |*    RscExpression::~RscExpression()
 602 |*
 603 |*    Beschreibung
 604 |*    Ersterstellung    MM 01.11.91
 605 |*    Letzte Aenderung  MM 01.11.91
 606 |*
 607 *************************************************************************/
 608 RscExpression::~RscExpression(){
 609     if( aLeftExp.IsDefinition() )
 610         aLeftExp.aExp.pDef->DecRef();
 611     else if( aLeftExp.IsExpression() )
 612         delete aLeftExp.aExp.pExp;
 613
 614     if( aRightExp.IsDefinition() )
 615         aRightExp.aExp.pDef->DecRef();
 616     else if( aRightExp.IsExpression() )
 617         delete aRightExp.aExp.pExp;
 618 }
 619
 620 /*************************************************************************
 621 |*
 622 |*    RscExpression::Evaluate()
 623 |*
 624 |*    Beschreibung
 625 |*    Ersterstellung    MM 01.11.91
 626 |*    Letzte Aenderung  MM 01.11.91
 627 |*
 628 *************************************************************************/
 629 sal_Bool RscExpression::Evaluate( sal_Int32 * plValue ){
 630     sal_Int32 lLeft;
 631     sal_Int32 lRight;
 632
 633     // linken und rechten Zweig auswerten
 634     if( aLeftExp.Evaluate( &lLeft ) && aRightExp.Evaluate( &lRight ) ){
 635         if( cOperation == '&' )
 636             *plValue = lLeft & lRight;
 637         else if( cOperation == '|' )
 638             *plValue = lLeft | lRight;
 639         else if( cOperation == '+' )
 640             *plValue = lLeft + lRight;
 641         else if( cOperation == '-' )
 642             *plValue = lLeft - lRight;
 643         else if( cOperation == '*' )
 644             *plValue = lLeft * lRight;
 645         else if( cOperation == 'r' )
 646             *plValue = lLeft >> lRight;
 647         else if( cOperation == 'l' )
 648             *plValue = lLeft << lRight;
 649         else{
 650             if( 0L == lRight )
 651                 return sal_False;
 652             *plValue = lLeft / lRight;
 653         };
 654         return sal_True;
 655     }
 656     return sal_False;
 657 }
 658
 659 /*************************************************************************
 660 |*
 661 |*    RscExpression::GetMacro()
 662 |*
 663 |*    Beschreibung
 664 |*    Ersterstellung    MM 01.11.91
 665 |*    Letzte Aenderung  MM 01.11.91
 666 |*
 667 *************************************************************************/
 668 ByteString RscExpression::GetMacro()
 669 {
 670     ByteString aLeft;
 671
 672     // Ausgabeoptimierung
 673     if( aLeftExp.IsNothing() )
 674     {
 675         if ( '-' == cOperation )
 676         {
 677             aLeft += '(';
 678             aLeft += '-';
 679         }
 680         aRightExp.GetMacro( aLeft );
 681         if( '-' == cOperation )
 682             aLeft += ')';
 683     }
 684     else if( aRightExp.IsNothing() )
 685         aLeftExp.GetMacro( aLeft );
 686     else{
 687         aLeft += '(';
 688         // linken Zweig auswerten
 689         aLeftExp.GetMacro( aLeft );
 690
 691         aLeft += cOperation;
 692
 693         aLeft += '(';
 694         // rechten Zweig auswerten
 695         aRightExp.GetMacro( aLeft );
 696         aLeft += ')';
 697
 698         aLeft += ')';
 699     }
 700
 701     return aLeft;
 702 }
 703
 704 /****************** R s c F i l e ****************************************/
 705 /*************************************************************************
 706 |*
 707 |*    RscFile::RscFile()
 708 |*
 709 |*    Beschreibung
 710 |*    Ersterstellung    MM 04.11.91
 711 |*    Letzte Aenderung  MM 04.11.91
 712 |*
 713 *************************************************************************/
 714 RscFile :: RscFile(){
 715     bLoaded  = sal_False;
 716     bIncFile = sal_False;
 717     bDirty   = sal_False;
 718     bScanned = sal_False;
 719 }
 720
 721 /*************************************************************************
 722 |*
 723 |*    RscFile::~RscFile()
 724 |*
 725 |*    Beschreibung
 726 |*    Ersterstellung    MM 04.11.91
 727 |*    Letzte Aenderung  MM 04.11.91
 728 |*
 729 *************************************************************************/
 730 RscFile :: ~RscFile(){
 731     RscDepend * pDep = Remove( (sal_uLong)0 );
 732
 733     while( pDep ){
 734         delete pDep;
 735         pDep = Remove( (sal_uLong)0 );
 736     }
 737
 738     //von hinten nach vorne ist besser wegen der Abhaengigkeiten
 739     //Objekte zerstoeren sich, wenn Referenzzaehler NULL
 740     aDefLst.Last();
 741     while( aDefLst.Remove() ) ;
 742 }
 743
 744 /*************************************************************************
 745 |*
 746 |*    RscFile::Depend()
 747 |*
 748 |*    Beschreibung      Diese Methode gibt sal_True zurueck, wenn lDepend
 749 |*                      existiert und hinter lFree steht, oder wenn
 750 |*                      lDepend nicht existiert.
 751 |*    Ersterstellung    MM 12.11.91
 752 |*    Letzte Aenderung  MM 12.11.91
 753 |*
 754 *************************************************************************/
 755 sal_Bool RscFile::Depend( sal_uLong lDepend, sal_uLong lFree ){
 756     RscDepend * pDep;
 757
 758     pDep = Last();
 759     while( pDep ){
 760         if( pDep->GetFileKey() == lDepend ){
 761             while( pDep ){
 762                 if( pDep->GetFileKey() == lFree )
 763                     return sal_True;
 764                 pDep = Prev();
 765             }
 766             return sal_False;
 767         }
 768         pDep = Prev();
 769     };
 770
 771     return sal_True;
 772 }
 773
 774 /*************************************************************************
 775 |*
 776 |*    RscFile::InsertDependFile()
 777 |*
 778 |*    Beschreibung
 779 |*    Ersterstellung    MM 06.01.92
 780 |*    Letzte Aenderung  MM 06.01.92
 781 |*
 782 *************************************************************************/
 783 sal_Bool RscFile :: InsertDependFile( sal_uLong lIncFile, sal_uLong lPos )
 784 {
 785     RscDepend * pDep;
 786
 787     pDep = First();
 788     while( pDep ){
 789         if( pDep->GetFileKey() == lIncFile )
 790             return sal_True;
 791         pDep = Next();
 792     }
 793
 794     // Current-Zeiger steht auf letztem Element
 795     if( lPos >= Count() ){ //letztes Element muss immer letztes bleiben
 796         // Abhaengigkeit vor der letzten Position eintragen
 797         Insert( new RscDepend( lIncFile ) );
 798     }
 799     else
 800         Insert( new RscDepend( lIncFile ), lPos );
 801
 802     return sal_True;
 803 }
 804
 805 /*************************************************************************
 806 |*
 807 |*    RscFile::RemoveDependFile()
 808 |*
 809 |*    Beschreibung
 810 |*    Ersterstellung    MM 18.11.91
 811 |*    Letzte Aenderung  MM 18.11.91
 812 |*
 813 *************************************************************************/
 814 void RscFile :: RemoveDependFile( sal_uLong lDepFile )
 815 {
 816
 817     RscDepend * pDep = Last();
 818
 819     while( pDep ){
 820         if( pDep->GetFileKey() == lDepFile ){
 821             Remove( pDep );
 822             delete pDep;
 823         }
 824         pDep = Prev();
 825     }
 826 }
 827
 828 /****************** R s c D e f T r e e **********************************/
 829 /*************************************************************************
 830 |*
 831 |*    RscDefTree::~RscDefTree()
 832 |*
 833 |*    Beschreibung
 834 |*    Ersterstellung    MM 12.11.91
 835 |*    Letzte Aenderung  MM 12.11.91
 836 |*
 837 *************************************************************************/
 838 RscDefTree::~RscDefTree(){
 839     Remove();
 840 }
 841
 842 /*************************************************************************
 843 |*
 844 |*    RscDefTree::Remove()
 845 |*
 846 |*    Beschreibung
 847 |*    Ersterstellung    MM 12.11.91
 848 |*    Letzte Aenderung  MM 12.11.91
 849 |*
 850 *************************************************************************/
 851 void RscDefTree::Remove(){
 852     RscDefine * pDef;
 853     while( pDefRoot ){
 854         pDef = pDefRoot;
 855         pDefRoot = (RscDefine *)pDefRoot->Remove( pDefRoot );
 856         pDef->DecRef();
 857     }
 858 }
 859
 860 /*************************************************************************
 861 |*
 862 |*    RscDefTree::~Search()
 863 |*
 864 |*    Beschreibung
 865 |*    Ersterstellung    MM 12.11.91
 866 |*    Letzte Aenderung  MM 12.11.91
 867 |*
 868 *************************************************************************/
 869 RscDefine * RscDefTree::Search( const char * pName ){
 870     if( pDefRoot )
 871         return pDefRoot->Search( pName );
 872     return NULL;
 873 }
 874
 875 /*************************************************************************
 876 |*
 877 |*    RscDefTree::Insert()
 878 |*
 879 |*    Beschreibung
 880 |*    Ersterstellung    MM 12.11.91
 881 |*    Letzte Aenderung  MM 12.11.91
 882 |*
 883 *************************************************************************/
 884 void RscDefTree::Insert( RscDefine * pDef ){
 885     if( pDefRoot )
 886         pDefRoot->Insert( pDef );
 887     else
 888         pDefRoot = pDef;
 889     pDef->IncRef();
 890 }
 891
 892 /*************************************************************************
 893 |*
 894 |*    RscDefTree::Remove()
 895 |*
 896 |*    Beschreibung
 897 |*    Ersterstellung    MM 12.11.91
 898 |*    Letzte Aenderung  MM 12.11.91
 899 |*
 900 *************************************************************************/
 901 void RscDefTree::Remove( RscDefine * pDef ){
 902     if( pDefRoot ){
 903         //falls pDef == pDefRoot
 904         pDefRoot = (RscDefine *)pDefRoot->Remove( pDef );
 905     }
 906     pDef->DecRef();
 907 }
 908
 909 /*************************************************************************
 910 |*
 911 |*    RscDefTree::Evaluate()
 912 |*
 913 |*    Beschreibung
 914 |*    Ersterstellung    MM 12.11.91
 915 |*    Letzte Aenderung  MM 12.11.91
 916 |*
 917 *************************************************************************/
 918 sal_Bool RscDefTree::Evaluate( RscDefine * pDef ){
 919     if( pDef ){
 920         if( !Evaluate( (RscDefine *)pDef->Left() ) )
 921             return sal_False;
 922         if( !Evaluate( (RscDefine *)pDef->Right() ) )
 923             return sal_False;
 924     };
 925     return sal_True;
 926 }
 927
 928 sal_Bool RscDefTree::Evaluate(){
 929     return Evaluate( pDefRoot );
 930 }
 931
 932 /****************** R s c F i l e T a b **********************************/
 933 /*************************************************************************
 934 |*
 935 |*    RscFileTab::RscFileTab()
 936 |*
 937 |*    Beschreibung
 938 |*    Ersterstellung    MM 07.11.91
 939 |*    Letzte Aenderung  MM 07.11.91
 940 |*
 941 *************************************************************************/
 942 RscFileTab::RscFileTab(){
 943 }
 944
 945 /*************************************************************************
 946 |*
 947 |*    RscFileTab::~RscFileTab()
 948 |*
 949 |*    Beschreibung
 950 |*    Ersterstellung    MM 04.11.91
 951 |*    Letzte Aenderung  MM 04.11.91
 952 |*
 953 *************************************************************************/
 954 RscFileTab :: ~RscFileTab(){
 955     RscFile * pFile;
 956
 957     aDefTree.Remove();
 958
 959     pFile = Last();
 960     while( pFile ){
 961         Remove( GetIndex( pFile ) );
 962         delete pFile;
 963         pFile = Prev();
 964     };
 965 }
 966
 967 /*************************************************************************
 968 |*
 969 |*    RscFileTab::Find()
 970 |*
 971 |*    Beschreibung
 972 |*    Ersterstellung    MM 16.05.91
 973 |*    Letzte Aenderung  MM 16.05.91
 974 |*
 975 *************************************************************************/
 976 sal_uLong  RscFileTab :: Find( const ByteString & rName )
 977 {
 978     RscFile * pFName;
 979
 980     pFName = First();
 981     while( pFName && (pFName->aFileName != rName) )
 982         pFName = Next();
 983
 984     if( pFName )
 985         return( GetIndex( pFName ) );
 986     else
 987         return( NOFILE_INDEX );
 988 }
 989
 990 /*************************************************************************
 991 |*
 992 |*    RscFileTab::FindDef()
 993 |*
 994 |*    Beschreibung
 995 |*    Ersterstellung    MM 30.10.91
 996 |*    Letzte Aenderung  MM 01.11.91
 997 |*
 998 *************************************************************************/
 999 RscDefine * RscFileTab::FindDef( const char * pName ){
1000     return aDefTree.Search( pName );
1001 }
1002
1003 /*************************************************************************
1004 |*
1005 |*    RscFileTab::FindDef()
1006 |*
1007 |*    Beschreibung
1008 |*    Ersterstellung    MM 30.10.91
1009 |*    Letzte Aenderung  MM 01.11.91
1010 |*
1011 *************************************************************************/
1012 RscDefine * RscFileTab::FindDef( sal_uLong lFileKey, const ByteString & rName )
1013 {
1014     RscDefine   * pDef = FindDef( rName );
1015
1016     if( pDef )
1017         //befindet sich das DEFINE in einer Include-Datei in der
1018         //Datei lFileKey
1019         if( Depend( lFileKey, pDef->GetFileKey() ) )
1020             return pDef;
1021     return NULL;
1022 }
1023
1024 /*************************************************************************
1025 |*
1026 |*    RscFileTab::Depend()
1027 |*
1028 |*    Beschreibung
1029 |*    Ersterstellung    MM 08.11.91
1030 |*    Letzte Aenderung  MM 08.11.91
1031 |*
1032 *************************************************************************/
1033 sal_Bool RscFileTab::Depend( sal_uLong lDepend, sal_uLong lFree ){
1034     if( lDepend == lFree )
1035         return sal_True;
1036
1037     RscFile * pFile = First();
1038     while( pFile ){
1039         if( !pFile->IsIncFile() ){
1040             if( !pFile->Depend( lDepend, lFree ) )
1041                 return sal_False;
1042         };
1043         pFile = Next();
1044     };
1045
1046     return sal_True;
1047 }
1048
1049 /*************************************************************************
1050 |*
1051 |*    RscFileTab::TestDef()
1052 |*
1053 |*    Beschreibung
1054 |*    Ersterstellung    MM 14.01.92
1055 |*    Letzte Aenderung  MM 14.01.92
1056 |*
1057 *************************************************************************/
1058 sal_Bool RscFileTab::TestDef( sal_uLong lFileKey, sal_uLong lPos,
1059                           const RscDefine * pDefDec )
1060 {
1061     if( lFileKey == pDefDec->GetFileKey() ){
1062         RscFile * pFile = GetFile( pDefDec->GetFileKey() );
1063         if( pFile && (lPos <= pFile->aDefLst.GetPos( (RscDefine *)pDefDec ))
1064           && (lPos != LIST_APPEND) )
1065             return sal_False;
1066     }
1067     else if( !Depend( lFileKey, pDefDec->GetFileKey() ) )
1068         return sal_False;
1069
1070     return TestDef( lFileKey, lPos, pDefDec->pExp );
1071 }
1072
1073 /*************************************************************************
1074 |*
1075 |*    RscFileTab::TestDef()
1076 |*
1077 |*    Beschreibung
1078 |*    Ersterstellung    MM 14.01.92
1079 |*    Letzte Aenderung  MM 14.01.92
1080 |*
1081 *************************************************************************/
1082 sal_Bool RscFileTab::TestDef( sal_uLong lFileKey, sal_uLong lPos,
1083                           const RscExpression * pExpDec )
1084 {
1085     if( !pExpDec )
1086         return sal_True;
1087
1088     if( pExpDec->aLeftExp.IsExpression() )
1089         if( !TestDef( lFileKey, lPos, pExpDec->aLeftExp.aExp.pExp ) )
1090             return sal_False;
1091
1092     if( pExpDec->aLeftExp.IsDefinition() )
1093         if( !TestDef( lFileKey, lPos, pExpDec->aLeftExp.aExp.pDef ) )
1094             return sal_False;
1095
1096     if( pExpDec->aRightExp.IsExpression() )
1097         if( !TestDef( lFileKey, lPos, pExpDec->aRightExp.aExp.pExp ) )
1098             return sal_False;
1099
1100     if( pExpDec->aRightExp.IsDefinition() )
1101         if( !TestDef( lFileKey, lPos, pExpDec->aRightExp.aExp.pDef ) )
1102             return sal_False;
1103
1104     return sal_True;
1105 }
1106
1107 /*************************************************************************
1108 |*
1109 |*    RscFileTab::NewDef()
1110 |*
1111 |*    Beschreibung
1112 |*    Ersterstellung    MM 04.11.91
1113 |*    Letzte Aenderung  MM 04.11.91
1114 |*
1115 *************************************************************************/
1116 RscDefine * RscFileTab::NewDef( sal_uLong lFileKey, const ByteString & rDefName,
1117                                 sal_Int32 lId, sal_uLong lPos )
1118 {
1119     RscDefine * pDef = FindDef( rDefName );
1120
1121     if( !pDef ){
1122         RscFile * pFile = GetFile( lFileKey );
1123
1124         if( pFile ){
1125             pDef = pFile->aDefLst.New( lFileKey, rDefName, lId, lPos );
1126             aDefTree.Insert( pDef );
1127         }
1128     }
1129     else
1130         pDef = NULL;
1131
1132     return( pDef );
1133 }
1134
1135 /*************************************************************************
1136 |*
1137 |*    RscFileTab::NewDef()
1138 |*
1139 |*    Beschreibung
1140 |*    Ersterstellung    MM 04.11.91
1141 |*    Letzte Aenderung  MM 04.11.91
1142 |*
1143 *************************************************************************/
1144 RscDefine * RscFileTab::NewDef( sal_uLong lFileKey, const ByteString & rDefName,
1145                                 RscExpression * pExp, sal_uLong lPos )
1146 {
1147     RscDefine * pDef = FindDef( rDefName );
1148
1149     if( !pDef ){
1150         //Macros in den Expressions sind definiert ?
1151         if( TestDef( lFileKey, lPos, pExp ) ){
1152             RscFile * pFile = GetFile( lFileKey );
1153
1154             if( pFile ){
1155                 pDef = pFile->aDefLst.New( lFileKey, rDefName, pExp, lPos );
1156                 aDefTree.Insert( pDef );
1157             }
1158         }
1159     }
1160     else
1161         pDef = NULL;
1162
1163     if( !pDef ){
1164         // pExp wird immer Eigentum und muss, wenn es nicht benoetigt wird
1165         // geloescht werden
1166         delete pExp;
1167     }
1168     return( pDef );
1169 }
1170
1171 /*************************************************************************
1172 |*
1173 |*    RscFileTab::IsDefUsed()
1174 |*
1175 |*    Beschreibung
1176 |*    Ersterstellung    MM 22.11.91
1177 |*    Letzte Aenderung  MM 22.11.91
1178 |*
1179 *************************************************************************/
1180 sal_Bool RscFileTab::IsDefUsed( const ByteString & rDefName )
1181 {
1182     RscDefine * pDef = FindDef( rDefName );
1183
1184     if( pDef )
1185         return( pDef->GetRefCount() != 2 );
1186
1187     return sal_False;
1188 }
1189
1190 /*************************************************************************
1191 |*
1192 |*    RscFileTab::DeleteDef()
1193 |*
1194 |*    Beschreibung
1195 |*    Ersterstellung    MM 11.11.91
1196 |*    Letzte Aenderung  MM 11.11.91
1197 |*
1198 *************************************************************************/
1199 void RscFileTab::DeleteDef( const ByteString & rDefName )
1200 {
1201     RscDefine * pDef = FindDef( rDefName );
1202     RscFile   * pFile;
1203
1204     if( pDef ){
1205         pFile = GetFile( pDef->GetFileKey() );
1206         if( pFile ){
1207             aDefTree.Remove( pDef );
1208             pFile->aDefLst.Remove( pDef );
1209         }
1210     };
1211 }
1212
1213 /*************************************************************************
1214 |*
1215 |*    RscFileTab::ChangeDef()
1216 |*
1217 |*    Beschreibung
1218 |*    Ersterstellung    MM 04.11.91
1219 |*    Letzte Aenderung  MM 11.11.91
1220 |*
1221 *************************************************************************/
1222 sal_Bool RscFileTab::ChangeDef( const ByteString & rDefName, sal_Int32 lId )
1223 {
1224     RscDefine * pDef = FindDef( rDefName );
1225
1226     if( pDef ){
1227         pDef->ChangeMacro( lId );
1228         //alle Macros neu bewerten
1229         return aDefTree.Evaluate();
1230     };
1231     return( sal_False );
1232 }
1233
1234 /*************************************************************************
1235 |*
1236 |*    RscFileTab::ChangeDef()
1237 |*
1238 |*    Beschreibung
1239 |*    Ersterstellung    MM 04.11.91
1240 |*    Letzte Aenderung  MM 11.11.91
1241 |*
1242 *************************************************************************/
1243 sal_Bool RscFileTab::ChangeDef( const ByteString & rDefName,
1244                             RscExpression * pExp )
1245 {
1246     RscDefine * pDef = FindDef( rDefName );
1247     RscFile   * pFile;
1248     sal_uLong       lPos = 0;
1249
1250     if( pDef ){
1251         pFile = GetFile( pDef->GetFileKey() );
1252         if( pFile )
1253             lPos = pFile->aDefLst.GetPos( pDef );
1254         //Macros in den Expressions sind definiert ?
1255         if( TestDef( pDef->GetFileKey(), lPos, pExp ) ){
1256             pDef->ChangeMacro( pExp );
1257             //alle Macros neu bewerten
1258             return aDefTree.Evaluate();
1259         }
1260     };
1261
1262     // pExp wird immer Eigentum und muss, wenn es nicht benoetigt wird
1263     // geloescht werden
1264     delete pExp;
1265
1266     return( sal_False );
1267 }
1268
1269 /*************************************************************************
1270 |*
1271 |*    RscFileTab::ChangeDefName()
1272 |*
1273 |*    Beschreibung
1274 |*    Ersterstellung    MM 04.11.91
1275 |*    Letzte Aenderung  MM 04.11.91
1276 |*
1277 *************************************************************************/
1278 sal_Bool RscFileTab::ChangeDefName( const ByteString & rDefName,
1279                                 const ByteString & rNewName )
1280 {
1281     RscDefine * pDef = FindDef( rDefName );
1282
1283     //Name gefunden ?
1284     if( pDef ){
1285         // und neuer Name noch nicht bekannt ?
1286         if( !FindDef( pDef->GetFileKey(), rNewName ) ){
1287             aDefTree.Remove( pDef );
1288             pDef->SetName( rNewName );
1289             aDefTree.Insert( pDef );
1290             return( sal_True );
1291         }
1292     };
1293
1294     return( sal_False );
1295 }
1296
1297 /*************************************************************************
1298 |*
1299 |*    RscFileTab::DeleteFileContext()
1300 |*
1301 |*    Beschreibung
1302 |*    Ersterstellung    MM 09.12.91
1303 |*    Letzte Aenderung  MM 09.12.91
1304 |*
1305 *************************************************************************/
1306 void RscFileTab :: DeleteFileContext( sal_uLong lFileKey ){
1307     RscFile     * pFName;
1308
1309     pFName = GetFile( lFileKey );
1310     if( pFName ){
1311         RscDefine * pDef;
1312
1313         pDef = pFName->aDefLst.First();
1314         while( pDef ){
1315             aDefTree.Remove( pDef );
1316             pDef = pFName->aDefLst.Next();
1317         };
1318         while( pFName->aDefLst.Remove( (sal_uLong)0 ) ) ;
1319     }
1320 }
1321
1322 /*************************************************************************
1323 |*
1324 |*    RscFileTab::DeleteFile()
1325 |*
1326 |*    Beschreibung
1327 |*    Ersterstellung    MM 16.05.91
1328 |*    Letzte Aenderung  MM 16.05.91
1329 |*
1330 *************************************************************************/
1331 void RscFileTab :: DeleteFile( sal_uLong lFileKey ){
1332     RscFile     * pFName;
1333
1334     //Defines freigeben
1335     DeleteFileContext( lFileKey );
1336
1337     //Schleife ueber alle Abhaengigkeiten
1338     pFName = First();
1339     while( pFName ){
1340         pFName->RemoveDependFile( lFileKey );
1341         pFName = Next();
1342     };
1343
1344     pFName = Remove( lFileKey );
1345     if( pFName )
1346         delete pFName;
1347 }
1348
1349 /*************************************************************************
1350 |*
1351 |*    RscFileTab::NewCodeFile()
1352 |*
1353 |*    Beschreibung
1354 |*    Ersterstellung    MM 16.05.91
1355 |*    Letzte Aenderung  MM 16.05.91
1356 |*
1357 *************************************************************************/
1358 sal_uLong  RscFileTab :: NewCodeFile( const ByteString & rName )
1359 {
1360     sal_uLong       lKey;
1361     RscFile *   pFName;
1362
1363     lKey = Find( rName );
1364     if( UNIQUEINDEX_ENTRY_NOTFOUND == lKey )
1365     {
1366         pFName = new RscFile();
1367         pFName->aFileName = rName;
1368         pFName->aPathName = rName;
1369         lKey = Insert( pFName );
1370         pFName->InsertDependFile( lKey, LIST_APPEND );
1371     }
1372     return lKey;
1373 }
1374
1375 /*************************************************************************
1376 |*
1377 |*    RscFileTab::NewIncFile()
1378 |*
1379 |*    Beschreibung
1380 |*    Ersterstellung    MM 16.05.91
1381 |*    Letzte Aenderung  MM 16.05.91
1382 |*
1383 *************************************************************************/
1384 sal_uLong  RscFileTab :: NewIncFile( const ByteString & rName,
1385                                  const ByteString & rPath )
1386 {
1387     sal_uLong         lKey;
1388     RscFile * pFName;
1389
1390     lKey = Find( rName );
1391     if( UNIQUEINDEX_ENTRY_NOTFOUND == lKey )
1392     {
1393         pFName = new RscFile();
1394         pFName->aFileName = rName;
1395         pFName->aPathName = rPath;
1396         pFName->SetIncFlag();
1397         lKey = Insert( pFName );
1398         pFName->InsertDependFile( lKey, LIST_APPEND );
1399     }
1400     return lKey;
1401 }