rsc/source/tools/rscdef.cxx

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