src/common__object_levels.cpp

   1 /*
   2  * common__object_levels.cpp
   3  *
   4  *  Created on: 24 avr. 2009
   5  *      Author: pat
   6  */
   7
   8 #include "common__tools.h"
   9 #include "common__object_stage.h"
  10
  11
  12 /*\internal*********************************************
  13 ********        OBJECT RELATED TO THE LEVELS.TXT FILE
  14 ******************************************************/
  15
  16
  17
  18 //**********************************************
  19 //**********************************************
  20 //**********************************************
  21 /**
  22  * The object which hold the datas about a game (mod)
  23  */
  24
  25
  26 //**********************************************
  27 ob_object*
  28 ob_levels::Guess_and_ConstructNewObject(MyLine* line, const int _num_line )
  29 {
  30         // if Empty Line
  31         if( line->GetTokensCount() <= 0 )
  32                 return new ob_object(line, _num_line);
  33
  34         wxString _name = *(line->GetToken(0)->data);
  35         ob_object *temp;
  36         if( _name.Upper() == wxT("SET") )
  37                 temp = new ob_StagesSet(line,_num_line);
  38         else
  39                 temp = new ob_object( line, _num_line);
  40
  41 //      wxLogInfo( "At line " + IntToStr( _num_line +1) + ", object build :" + temp->name );
  42
  43         return temp;
  44 }
  45
  46
  47 //**********************************************
  48 ob_levels::ob_levels()
  49 : ob_object_container()
  50 {
  51         SetType( OB_TYPE_LEVELS );
  52 }
  53
  54
  55 //-----------------------------------------------------------------
  56 void
  57 ob_levels::pClone(ob_object*& res )
  58 {
  59         if( res == NULL )
  60                 res = new ob_levels();
  61         ob_object_container::pClone( res );
  62 }
  63
  64 //**********************************************
  65 ob_levels::~ob_levels()
  66 {
  67 }
  68
  69
  70 //**********************************************
  71
  72 ob_StagesSet**   ob_levels::GetSets( size_t& _nb_set)
  73 {
  74         return ((ob_StagesSet**) GetSubObjectS_ofType( OB_TYPE_STAGES_SET, _nb_set ));
  75 }
  76
  77
  78 //**********************************************
  79
  80 bool ob_levels::Set_Insert( ob_StagesSet* ta, int ind )
  81 {
  82         size_t _nb_set;
  83         ob_StagesSet**  t = ob_levels::GetSets( _nb_set);
  84
  85         // No set
  86         if( t == NULL )
  87         {
  88                 return Add_SubObj( ta );
  89         }
  90
  91         bool res;
  92         if( ind == -1 || ind == (int)_nb_set )
  93         {
  94                 res = t[_nb_set-1]->InsertObject_After( ta );
  95         }
  96         else if( ind >= 0 && ind < (int) _nb_set )
  97         {
  98                 res = t[ind]->InsertObject_Before( ta );
  99         }
 100         else
 101                 res = false;
 102
 103         delete[] t;
 104         return res;
 105 }
 106
 107
 108 //**********************************************
 109
 110 bool ob_levels::Set_Tag(const wxString& _tag, const wxString& _token )
 111 {
 112         wxArrayString t;
 113         t.Add( _token );
 114         return Set_Tag( _tag, t );
 115 }
 116
 117 //**********************************************
 118
 119 bool ob_levels::Set_Tag(const wxString& _tag, wxArrayString _tokens )
 120 {
 121         // If the tag is already here
 122         ob_object* temp = GetSubObject( _tag );
 123         if( temp != NULL )
 124         {
 125                 temp->SetProperty( _tag, _tokens );
 126                 return true;
 127         }
 128
 129         //-----------------
 130         ob_object* t = new ob_object( _tag, _tokens );
 131
 132         // Get the first set object
 133         temp = first_subobj;
 134         while( temp != NULL )
 135         {
 136                 if( temp->type == OB_TYPE_STAGES_SET)
 137                         break;
 138         }
 139
 140         // No Set -> Append the new tag at the end
 141         if( temp == NULL )
 142                 return Add_SubObj( t );
 143
 144         // Insert the new tag just before the first set
 145         else
 146                 return temp->InsertObject_Before( t );
 147 }
 148
 149
 150 //**********************************************
 151 //**********************************************
 152 //**********************************************
 153 /**
 154  * The object which hold the datas about a game (mod)
 155  */
 156
 157 wxString stagedeclaration_tag[] = { wxT("Z"), wxT("FILE"), wxT("BRANCH"),  };
 158
 159 bool IsStageDeclarationTag( wxString& t )
 160 {
 161         for( size_t i =0; i< t_size_of(stagedeclaration_tag); i++ )
 162                 if( stagedeclaration_tag[i].Upper() == t.Upper() )
 163                         return true;
 164         return false;
 165 }
 166
 167 //**********************************************
 168 ob_StagesSet::ob_StagesSet( MyLine* line, const int _num_line )
 169 : ob_object( line, _num_line )
 170 {
 171         SetType( OB_TYPE_STAGES_SET );
 172         ungry = true;
 173 }
 174
 175
 176 //-----------------------------------------------------------------
 177 void
 178 ob_StagesSet::pClone(ob_object*& res )
 179 {
 180         if( res == NULL )
 181                 res = new ob_StagesSet();
 182         ob_object::pClone( res );
 183         res->ungry = ungry;
 184 }
 185
 186 //**********************************************
 187
 188 bool ob_StagesSet::Eat(  MyLine* line, const int _num_line )
 189 {
 190         if( ! ungry )
 191                 return false;
 192
 193         // If new set
 194         if( ! line->IsComment() && ! line->IsEmpty()  )
 195                 if( line->GetToken(0)->data->Upper() == wxT("SET")  )
 196                 {
 197                         if(     last_subobj->type == OB_TYPE_STAGE_DECLARATION
 198                                 &&  ! ((ob_StageDeclaration*) last_subobj )->b_completed )
 199                         {
 200                                 wxString __t;
 201                                 if( line->GetToken(1) != NULL && line->GetToken(1)->data != NULL )
 202                                         __t =  *(line->GetToken(1)->data);
 203                                 ObjectsLog( MYLOG_WARNING, 1 + _num_line,
 204                                             wxT("new SET of Stage <") + __t + wxT("> declared although a stage declaration is still uncomplete.") );
 205                         }
 206                         ungry = false;
 207                         return false;
 208                 }
 209
 210         // A stage declaration is in progress
 211         if( last_subobj != NULL && last_subobj->type == OB_TYPE_STAGE_DECLARATION && last_subobj->ungry )
 212         {
 213                 ob_StageDeclaration* st = (ob_StageDeclaration*) last_subobj;
 214                 bool res = st->Eat( line, _num_line );
 215
 216                 // ERROR CASE : Stage declaration don't eat the line BUT it had to (cause declaration are close with explicit tag "file" )
 217                 if( !res )
 218                 {
 219                         wxString __t;
 220                         if( line->GetToken(1) != NULL && line->GetToken(1)->data != NULL )
 221                                 __t ==  *(line->GetToken(1)->data);
 222                         ObjectsLog( MYLOG_WARNING, _num_line + 1,
 223                                     wxT("Tag <") + __t + wxT("> pop in a middle of a stage declaration !!") );
 224                 }
 225                 else
 226                         return true;
 227         }
 228
 229         // comment line
 230         if( line->IsComment() || line->IsEmpty() )
 231         {
 232                 ob_object* temp = new ob_object( line, _num_line );
 233                 Add_SubObj( temp );
 234                 // Still hungry
 235                 return true;
 236         }
 237
 238         //*************************
 239         // Valid line
 240         wxString _name = *(line->GetToken(0)->data);
 241
 242
 243         //-------------------------
 244         // Annoying "next" tag case :(
 245         if( _name.Upper() == wxT("NEXT") )
 246         {
 247                 // Gotta merge all from here up to the previous stage_declaration
 248                 ob_object* obj_next = new ob_object( line, _num_line );
 249                 ob_object* temp = last_subobj;
 250                 while( temp != NULL && temp->type != OB_TYPE_STAGE_DECLARATION && temp->type != OB_TYPE_STAGES_SET )
 251                         temp = temp->prev;
 252
 253                 // Problem, having a "next" tag without previous Stage declaration ...
 254                 // No merging will be done
 255                 if( temp == NULL || temp->type != OB_TYPE_STAGE_DECLARATION )
 256                 {
 257                         ObjectsLog( MYLOG_WARNING, _num_line + 1,wxT("Tag <NEXT> found without previous stage declaration !!!") );
 258                         Add_SubObj( obj_next );
 259                 }
 260
 261                 // Normal case, do the merging
 262                 else
 263                 {
 264                         ob_StageDeclaration* sd = (ob_StageDeclaration*) temp;
 265                         temp = sd->next;
 266                         while( temp != NULL )
 267                         {
 268                                 sd->Add_SubObj( temp );
 269                                 temp = sd->next;
 270                         }
 271
 272                         // Append also the "NEXT" tag
 273                         sd->Add_SubObj( obj_next  );
 274                         return true;
 275                 }
 276         }
 277
 278         //-------------------------
 279         // Stage declaration start here
 280         if( IsStageDeclarationTag( _name ) )
 281         {
 282                 Add_SubObj( new ob_StageDeclaration( line, _num_line ) );
 283                 return true;
 284         }
 285
 286         // Basic object here
 287         else
 288         {
 289                 Add_SubObj( new ob_object( line, _num_line ) );
 290                 return true;
 291         }
 292 }
 293
 294
 295 //**********************************************
 296
 297 ob_StagesSet::~ob_StagesSet()
 298 {
 299 }
 300
 301
 302 //**********************************************
 303
 304 void ob_StagesSet::Validate()
 305 {
 306 }
 307
 308
 309 //**********************************************
 310
 311 bool ob_StagesSet::Add_SubObj( ob_object* _obj )
 312 {
 313         // Add the next at the end
 314         if( _obj->type == OB_TYPE_STAGE_DECLARATION )
 315         {
 316                 return Append_SubObj( _obj );
 317         }
 318
 319         // Add the obj just before the first stage declaration
 320         else if( ! _obj->Is_EmptyOrComment() )
 321         {
 322                 size_t dummy;
 323                 ob_object** arr_o = GetSubObjectS_ofType( OB_TYPE_STAGE_DECLARATION, dummy );
 324                 if( arr_o == NULL )
 325                         return Append_SubObj( _obj );
 326                 else
 327                 {
 328                         bool res = arr_o[0]->InsertObject_Before( _obj );
 329                         delete[] arr_o;
 330                         return res;
 331                 }
 332         }
 333         else
 334                 return Append_SubObj( _obj );
 335 }
 336
 337 //**********************************************
 338 bool ob_StagesSet::SetSetName(const wxString& _sn)
 339 {
 340         return SetToken( 0, _sn );
 341 }
 342
 343
 344 //**********************************************
 345
 346 wxString ob_StagesSet::GetSetName()
 347 {
 348         return GetToken( 0 );
 349 }
 350
 351
 352 //**********************************************
 353
 354 ob_StageDeclaration**    ob_StagesSet::GetStages( size_t& _nb_stages)
 355 {
 356         return (ob_StageDeclaration**) GetSubObjectS_ofType( OB_TYPE_STAGE_DECLARATION, _nb_stages );
 357 }
 358
 359
 360 //**********************************************
 361
 362 bool ob_StagesSet::Stage_Insert( ob_StageDeclaration* t, int ind )
 363 {
 364         size_t nb_stages;
 365         bool res = false;
 366         ob_StageDeclaration**   arr_stages = GetStages( nb_stages );
 367
 368         // case : there's already some stages in
 369         if( arr_stages != NULL )
 370         {
 371                 // Append case
 372                 if( ind == -1 || ind == (int) nb_stages )
 373                 {
 374                         res = arr_stages[nb_stages-1]->InsertObject_After( t );
 375                 }
 376
 377                 // Valid indice case
 378                 else if( ind >= 0 && ind < (int) nb_stages )
 379                 {
 380                         res = arr_stages[ind]->InsertObject_Before( t );
 381                 }
 382
 383                 // INValid indice case
 384                 else
 385                 {
 386                         res = false;
 387                 }
 388                 // Cleaning
 389                 delete[] arr_stages;
 390         }
 391
 392         // First stage to add -> Juste append it at the end of the object
 393         else
 394         {
 395                 res = Add_SubObj( t );
 396         }
 397         return res;
 398 }
 399
 400
 401 //**********************************************
 402
 403 bool ob_StagesSet::Set_Tag(const wxString& _tag, const wxString& _token )
 404 {
 405         wxArrayString t;
 406         t.Add( _token );
 407         return Set_Tag( _tag, t );
 408 }
 409
 410 //**********************************************
 411
 412 bool ob_StagesSet::Set_Tag(const wxString& _tag, wxArrayString _tokens )
 413 {
 414         // If the tag is already here
 415         ob_object* temp = GetSubObject( _tag );
 416         if( temp != NULL )
 417         {
 418                 temp->SetProperty( _tag, _tokens );
 419                 return true;
 420         }
 421
 422         //-----------------
 423         ob_object* t = new ob_object( _tag, _tokens );
 424
 425         // Get the first stage object
 426         temp = first_subobj;
 427         while( temp != NULL )
 428         {
 429                 if( temp->type == OB_TYPE_STAGE_DECLARATION)
 430                         break;
 431         }
 432
 433         // No Stage -> Append the new tag at the end
 434         if( temp == NULL )
 435                 return Add_SubObj( t );
 436
 437         // Insert the new tag just before the first stage
 438         else
 439                 return temp->InsertObject_Before( t );
 440 }
 441
 442
 443 //**********************************************
 444
 445 void ob_StagesSet::SetToDefault()
 446 {
 447         name = wxT("SET");
 448         SetToken( 0, wxT("UNAMED" ));
 449         Add_SubObj( new ob_object(wxT("nosame"), wxT("1" )) );
 450         Add_SubObj( new ob_object(wxT("noshare"), wxT("0" )) );
 451         Add_SubObj( new ob_object(wxT("ifcomplete"), wxT("0") ) );
 452         Add_SubObj( new ob_object(wxT("lives"), wxT("3") ) );
 453         Add_SubObj( new ob_object(wxT("credits"), wxT("3") ) );
 454         Add_SubObj( new ob_object(wxT("maxplayers"), wxT("2") ) );
 455         Add_SubObj( new ob_object(wxT("typemp"), wxT("0") ) );
 456         Add_SubObj( new ob_object(wxT("cansave"), wxT("0") ) );
 457 }
 458
 459
 460 //**********************************************
 461 //**********************************************
 462 //**********************************************
 463 /**
 464  * The object which hold the datas about a game (mod)
 465  */
 466
 467 //**********************************************
 468 ob_StageDeclaration::ob_StageDeclaration( MyLine* line, const int _num_line )
 469 : ob_object()
 470 {
 471         SetType( OB_TYPE_STAGE_DECLARATION );
 472         b_completed = false;
 473         stage = NULL;
 474
 475         // if default constructor => Nothing more
 476         if( line == NULL )
 477                 return;
 478
 479         Eat( line, _num_line );
 480 }
 481
 482
 483 //**********************************************
 484
 485 ob_StageDeclaration::ob_StageDeclaration( const wxString& _name, wxArrayString& _tokens)
 486 : ob_object()
 487 {
 488         SetType( OB_TYPE_STAGE_DECLARATION );
 489         b_completed = false;
 490         stage = NULL;
 491         if( _name.Upper() == wxT("FILE") )
 492                 b_completed = true;
 493
 494         ob_object* temp = new ob_object( _name, _tokens );
 495         Add_SubObj( temp );
 496 }
 497
 498 //-----------------------------------------------------------------
 499 void
 500 ob_StageDeclaration::pClone(ob_object*& res )
 501 {
 502         if( res == NULL )
 503                 res = new ob_StageDeclaration();
 504         ob_object::pClone( res );
 505         ((ob_StageDeclaration*)res)->stage = NULL;
 506         ((ob_StageDeclaration*)res)->b_completed = b_completed;
 507 }
 508
 509 //**********************************************
 510
 511 ob_StageDeclaration::~ob_StageDeclaration()
 512 {
 513         UnLoadStage();
 514 }
 515
 516
 517 //**********************************************
 518
 519 bool ob_StageDeclaration::Eat(  MyLine* line, const int _num_line )
 520 {
 521         if( ! ungry )
 522                 return false;
 523
 524         // comment line
 525         if( line->IsComment() || line->IsEmpty() )
 526         {
 527                 ob_object* temp = new ob_object( line, _num_line );
 528                 Add_SubObj( temp );
 529                 return true;
 530         }
 531
 532
 533         wxString _name = *(line->GetToken(0)->data);
 534         if( _name.Upper() == wxT("FILE") )
 535         {
 536                 b_completed = true;
 537                 ungry = false;
 538         }
 539
 540         ob_object* temp = new ob_object( line, _num_line );
 541         Add_SubObj( temp );
 542         return true;
 543 }
 544
 545 //**********************************************
 546
 547 bool ob_StageDeclaration::Add_SubObj( ob_object* _obj )
 548 {
 549         // Add the next at the end
 550         if( _obj->name.Upper() == wxT("NEXT") )
 551         {
 552                 return Append_SubObj( _obj );
 553         }
 554         // Add the branch just after "FILE"
 555         else if( _obj->name.Upper() == wxT("BRANCH") )
 556         {
 557                 ob_object * t = GetSubObject( wxT("BRANCH") );
 558                 if( t == NULL )
 559                         return Append_SubObj( _obj );
 560                 else
 561                         return t->InsertObject_After( _obj );
 562         }
 563         else
 564         {
 565                 return Append_SubObj( _obj );
 566         }
 567 }
 568
 569
 570 //**********************************************
 571
 572 wxString ob_StageDeclaration::ToStr()const
 573 {
 574         wxString res;
 575
 576         // Print prefixes
 577         ob_object *temp = first_prefix;
 578         while( temp != NULL )
 579         {
 580                 res += temp->ToStr();
 581                 temp = temp->next;
 582         }
 583
 584         temp = first_subobj;
 585         while( temp != NULL )
 586         {
 587                 res += temp->ToStr();
 588                 temp = temp->next;
 589         }
 590
 591         return res;
 592 }
 593
 594 //**********************************************
 595
 596 void ob_StageDeclaration::Validate()
 597 {
 598 }
 599
 600
 601 //**********************************************
 602
 603 void ob_StageDeclaration::SetStageName(const wxString& _sn)
 604 {
 605         // Branch Name
 606         ob_object* temp = GetSubObject( wxT("BRANCH") );
 607         if( temp != NULL)
 608                 temp->SetToken( 0, _sn );
 609
 610         // Else, the name is set in the prefixs comments
 611         ob_object* t = first_prefix;
 612         while( t != NULL )
 613         {
 614                 wxString c = t->GetComment();
 615                 int _ind = c.Find( wxT("# STAGENAME : ") );
 616                 if( _ind != wxNOT_FOUND )
 617                 {
 618                         _ind += wxString::FromAscii("# STAGENAME : ").Len();
 619                         wxString _pref = c.Mid(0, _ind);
 620                         t->SetComment( _pref + wxT(" ") + _sn);
 621                         return;
 622                 }
 623                 t = t->next;
 624         }
 625
 626         // Have to add a prefix
 627         PrependCommentLine( wxT("\t# STAGENAME : ") + _sn );
 628 }
 629
 630
 631 //**********************************************
 632
 633 wxString ob_StageDeclaration::GetStageName()
 634 {
 635         // Branch Name is mandatory
 636         ob_object* temp = GetSubObject( wxT("BRANCH"));
 637         if( temp != NULL)
 638                 return temp->GetToken( 0 );
 639
 640         // Else, the name is set in the prefixs comments
 641         ob_object* t = first_prefix;
 642         while( t != NULL )
 643         {
 644                 wxString c = t->GetComment();
 645                 int _ind = c.Find( wxT("# STAGENAME : ") );
 646                 if( _ind != wxNOT_FOUND )
 647                 {
 648                         _ind += wxString::FromAscii("# STAGENAME : ").Len();
 649                         wxString res = c.Mid( _ind, c.Len() - _ind);
 650                         res.Trim().Trim(false );
 651                         return res;
 652                 }
 653                 t = t->next;
 654         }
 655
 656         wxString res = wxFileName(GetFileName()).GetFullName();
 657         if( res == wxString() )
 658                 res = wxT("UNNAMED");
 659         return res;
 660 }
 661
 662
 663 //**********************************************
 664
 665 bool ob_StageDeclaration::SetFileName(const wxString& _fn)
 666 {
 667         ob_object* temp = GetSubObject( wxT("FILE") );
 668         if( temp != NULL)
 669                 return temp->SetToken( 0, _fn );
 670
 671         temp = new ob_object( wxT("FILE"), _fn );
 672         return Add_SubObj( temp );
 673 }
 674
 675
 676 //**********************************************
 677
 678 wxString ob_StageDeclaration::GetFileName()
 679 {
 680         return GetObFile( GetSubObject_Token( wxT("FILE"), 0 )).GetFullPath();
 681 }
 682
 683
 684 //**********************************************
 685
 686 // bool ob_StageDeclaration::Set_NextTag_State(bool b_next)
 687 // {
 688 //      // If a "NEXT" tag is already setted
 689 //      ob_object* temp = GetSubObject( "NEXT" );
 690 //      if( temp != NULL )
 691 //      {
 692 //              // Already setted as wanted
 693 //              if( b_next == true )
 694 //                      return true;
 695 //
 696 //              // Remove the next TAG
 697 //              delete temp;
 698 //              return true;
 699 //      }
 700 //
 701 //      // No Next Tag and want to be none ? -> Everythings fine
 702 //      if( b_next == false )
 703 //              return true;
 704 //
 705 //      //try to find the FILE tag
 706 //      temp = GetSubObject( "FILE" );
 707 //
 708 //      // No FILE Elt -> Cancel the operation
 709 //      if( temp != NULL)
 710 //              return false;
 711 //
 712 //      // Ok File Elt is here, so just add the tag after it
 713 //      ob_object* _next = new ob_object( "next" );
 714 //      temp->InsertObject_After( _next );
 715 //
 716 //      return true;
 717 // }
 718
 719 //**********************************************
 720
 721 bool ob_StageDeclaration::Set_BranchTag( const wxString& _bn)
 722 {
 723         // If a "Branch" tag is already setted
 724         ob_object* temp = GetSubObject(wxT("BRANCH") );
 725         if( temp != NULL )
 726         {
 727                 // Just Change the name
 728                 SetStageName( _bn );
 729                 return true;
 730         }
 731
 732         // No branch tag ? -> Create one at the start of the stage declaration
 733         ob_object* _branch = new ob_object( wxT("BRANCH"), _bn );
 734         Prepend_SubObj( _branch );
 735         SetStageName( _bn );
 736         return true;
 737 }
 738
 739
 740 //**********************************************
 741
 742 bool ob_StageDeclaration::Set_Tag(const wxString& _tag, const wxString& _token )
 743 {
 744         wxArrayString t;
 745         t.Add( _token );
 746         return Set_Tag( _tag, t );
 747 }
 748
 749 //**********************************************
 750
 751 bool ob_StageDeclaration::Set_Tag(const wxString& _tag, wxArrayString _tokens )
 752 {
 753         // If the tag is already here
 754         ob_object* temp = GetSubObject( _tag );
 755         if( temp != NULL )
 756         {
 757                 temp->SetProperty( _tag, _tokens );
 758                 return true;
 759         }
 760
 761         //try to find the FILE tag
 762         temp = GetSubObject( wxT("FILE") );
 763
 764         // No FILE Elt -> Cancel the operation
 765         if( temp != NULL)
 766                 return false;
 767
 768         // Ok File Elt is here, so just add the tag before it
 769         ob_object* _new = new ob_object( _tag, _tokens );
 770         temp->InsertObject_Before( _new );
 771
 772         return true;
 773 }
 774
 775 //---------------------------------------------------------------------
 776 wxSize
 777 ob_StageDeclaration::GetDefScrollzBounds()
 778 {
 779         ob_object* subobj = GetSubObject( wxT("Z") );
 780         if( subobj == NULL )
 781                 return wxSize(160,232);
 782         return wxSize( StrToInt(subobj->GetToken(0)), StrToInt(subobj->GetToken(1)) );
 783 }
 784
 785
 786
 787 //**********************************************
 788
 789 void ob_StageDeclaration::UnLoadStage()
 790 {
 791         if( stage != NULL )
 792         {
 793                 delete stage;
 794                 stage = NULL;
 795         }
 796 }
 797
 798 //**********************************************
 799
 800 bool ob_StageDeclaration::LoadStage(bool b_reload)
 801 {
 802         if( ! b_reload && stage != NULL )
 803                 return true;
 804
 805         UnLoadStage();
 806
 807         wxFileName fn = GetFileName();
 808         if( ! fn.FileExists() )
 809                 return false;
 810
 811         stage = new obFileStage( fn );
 812         if( stage->textFile == NULL )
 813         {
 814                 delete stage;
 815                 stage = NULL;
 816                 return false;
 817         }
 818         return true;
 819 }
 820
 821
 822 //**********************************************
 823
 824 bool ob_StageDeclaration::Is_EmptyOrComment()const
 825 {
 826         return false;
 827 }
 828