Source/cmIfCommand.cxx

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmIfCommand.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2009-01-21 14:49:00 $
   7   Version:   $Revision: 1.94 $
   8
   9   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
  10   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
  11
  12      This software is distributed WITHOUT ANY WARRANTY; without even
  13      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14      PURPOSE.  See the above copyright notices for more information.
  15
  16 =========================================================================*/
  17 #include "cmIfCommand.h"
  18 #include "cmStringCommand.h"
  19
  20 #include <stdlib.h> // required for atof
  21 #include <list>
  22 #include <cmsys/RegularExpression.hxx>
  23
  24 //=========================================================================
  25 bool cmIfFunctionBlocker::
  26 IsFunctionBlocked(const cmListFileFunction& lff,
  27                   cmMakefile &mf,
  28                   cmExecutionStatus &inStatus)
  29 {
  30   // we start by recording all the functions
  31   if (!cmSystemTools::Strucmp(lff.Name.c_str(),"if"))
  32     {
  33     this->ScopeDepth++;
  34     }
  35   if (!cmSystemTools::Strucmp(lff.Name.c_str(),"endif"))
  36     {
  37     this->ScopeDepth--;
  38     // if this is the endif for this if statement, then start executing
  39     if (!this->ScopeDepth)
  40       {
  41       // Remove the function blocker for this scope or bail.
  42       cmsys::auto_ptr<cmFunctionBlocker>
  43         fb(mf.RemoveFunctionBlocker(this, lff));
  44       if(!fb.get()) { return false; }
  45
  46       // execute the functions for the true parts of the if statement
  47       cmExecutionStatus status;
  48       int scopeDepth = 0;
  49       for(unsigned int c = 0; c < this->Functions.size(); ++c)
  50         {
  51         // keep track of scope depth
  52         if (!cmSystemTools::Strucmp(this->Functions[c].Name.c_str(),"if"))
  53           {
  54           scopeDepth++;
  55           }
  56         if (!cmSystemTools::Strucmp(this->Functions[c].Name.c_str(),"endif"))
  57           {
  58           scopeDepth--;
  59           }
  60         // watch for our state change
  61         if (scopeDepth == 0 &&
  62             !cmSystemTools::Strucmp(this->Functions[c].Name.c_str(),"else"))
  63           {
  64           this->IsBlocking = this->HasRun;
  65           this->HasRun = true;
  66           }
  67         else if (scopeDepth == 0 && !cmSystemTools::Strucmp
  68                  (this->Functions[c].Name.c_str(),"elseif"))
  69           {
  70           if (this->HasRun)
  71             {
  72             this->IsBlocking = true;
  73             }
  74           else
  75             {
  76             // Place this call on the call stack.
  77             cmMakefileCall stack_manager(&mf, this->Functions[c], status);
  78             static_cast<void>(stack_manager);
  79
  80             std::string errorString;
  81
  82             std::vector<std::string> expandedArguments;
  83             mf.ExpandArguments(this->Functions[c].Arguments,
  84                                expandedArguments);
  85             bool isTrue =
  86               cmIfCommand::IsTrue(expandedArguments,errorString,&mf);
  87
  88             if (errorString.size())
  89               {
  90               std::string err = "had incorrect arguments: ";
  91               unsigned int i;
  92               for(i =0; i < this->Functions[c].Arguments.size(); ++i)
  93                 {
  94                 err += (this->Functions[c].Arguments[i].Quoted?"\"":"");
  95                 err += this->Functions[c].Arguments[i].Value;
  96                 err += (this->Functions[c].Arguments[i].Quoted?"\"":"");
  97                 err += " ";
  98                 }
  99               err += "(";
 100               err += errorString;
 101               err += ").";
 102               mf.IssueMessage(cmake::FATAL_ERROR, err);
 103               cmSystemTools::SetFatalErrorOccured();
 104               return true;
 105               }
 106
 107             if (isTrue)
 108               {
 109               this->IsBlocking = false;
 110               this->HasRun = true;
 111               }
 112             }
 113           }
 114
 115         // should we execute?
 116         else if (!this->IsBlocking)
 117           {
 118           status.Clear();
 119           mf.ExecuteCommand(this->Functions[c],status);
 120           if (status.GetReturnInvoked())
 121             {
 122             inStatus.SetReturnInvoked(true);
 123             return true;
 124             }
 125           if (status.GetBreakInvoked())
 126             {
 127             inStatus.SetBreakInvoked(true);
 128             return true;
 129             }
 130           }
 131         }
 132       return true;
 133       }
 134     }
 135
 136   // record the command
 137   this->Functions.push_back(lff);
 138
 139   // always return true
 140   return true;
 141 }
 142
 143 //=========================================================================
 144 bool cmIfFunctionBlocker::ShouldRemove(const cmListFileFunction& lff,
 145                                        cmMakefile&)
 146 {
 147   if (!cmSystemTools::Strucmp(lff.Name.c_str(),"endif"))
 148     {
 149     // if the endif has arguments, then make sure
 150     // they match the arguments of the matching if
 151     if (lff.Arguments.size() == 0 ||
 152         lff.Arguments == this->Args)
 153       {
 154       return true;
 155       }
 156     }
 157
 158   return false;
 159 }
 160
 161 //=========================================================================
 162 bool cmIfCommand
 163 ::InvokeInitialPass(const std::vector<cmListFileArgument>& args,
 164                     cmExecutionStatus &)
 165 {
 166   std::string errorString;
 167
 168   std::vector<std::string> expandedArguments;
 169   this->Makefile->ExpandArguments(args, expandedArguments);
 170   bool isTrue =
 171     cmIfCommand::IsTrue(expandedArguments,errorString,this->Makefile);
 172
 173   if (errorString.size())
 174     {
 175     std::string err = "had incorrect arguments: ";
 176     unsigned int i;
 177     for(i =0; i < args.size(); ++i)
 178       {
 179       err += (args[i].Quoted?"\"":"");
 180       err += args[i].Value;
 181       err += (args[i].Quoted?"\"":"");
 182       err += " ";
 183       }
 184     err += "(";
 185     err += errorString;
 186     err += ").";
 187     this->SetError(err.c_str());
 188     cmSystemTools::SetFatalErrorOccured();
 189     return false;
 190     }
 191
 192   cmIfFunctionBlocker *f = new cmIfFunctionBlocker();
 193   // if is isn't true block the commands
 194   f->ScopeDepth = 1;
 195   f->IsBlocking = !isTrue;
 196   if (isTrue)
 197     {
 198     f->HasRun = true;
 199     }
 200   f->Args = args;
 201   this->Makefile->AddFunctionBlocker(f);
 202
 203   return true;
 204 }
 205
 206 namespace
 207 {
 208 //=========================================================================
 209   void IncrementArguments(std::list<std::string> &newArgs,
 210                           std::list<std::string>::iterator &argP1,
 211                           std::list<std::string>::iterator &argP2)
 212   {
 213     if (argP1  != newArgs.end())
 214       {
 215       argP1++;
 216       argP2 = argP1;
 217       if (argP1  != newArgs.end())
 218         {
 219         argP2++;
 220         }
 221       }
 222   }
 223
 224   //=========================================================================
 225   // helper function to reduce code duplication
 226   void HandlePredicate(bool value, int &reducible,
 227                        std::list<std::string>::iterator &arg,
 228                        std::list<std::string> &newArgs,
 229                        std::list<std::string>::iterator &argP1,
 230                        std::list<std::string>::iterator &argP2)
 231   {
 232     if(value)
 233       {
 234       *arg = "1";
 235       }
 236     else
 237       {
 238       *arg = "0";
 239       }
 240     newArgs.erase(argP1);
 241     argP1 = arg;
 242     IncrementArguments(newArgs,argP1,argP2);
 243     reducible = 1;
 244   }
 245
 246   //=========================================================================
 247   // helper function to reduce code duplication
 248   void HandleBinaryOp(bool value, int &reducible,
 249                        std::list<std::string>::iterator &arg,
 250                        std::list<std::string> &newArgs,
 251                        std::list<std::string>::iterator &argP1,
 252                        std::list<std::string>::iterator &argP2)
 253   {
 254     if(value)
 255       {
 256       *arg = "1";
 257       }
 258     else
 259       {
 260       *arg = "0";
 261       }
 262     newArgs.erase(argP2);
 263     newArgs.erase(argP1);
 264     argP1 = arg;
 265     IncrementArguments(newArgs,argP1,argP2);
 266     reducible = 1;
 267   }
 268
 269   //=========================================================================
 270   enum Op { OpLess, OpEqual, OpGreater };
 271   bool HandleVersionCompare(Op op, const char* lhs_str, const char* rhs_str)
 272   {
 273   // Parse out up to 4 components.
 274   unsigned int lhs[4] = {0,0,0,0};
 275   unsigned int rhs[4] = {0,0,0,0};
 276   sscanf(lhs_str, "%u.%u.%u.%u", &lhs[0], &lhs[1], &lhs[2], &lhs[3]);
 277   sscanf(rhs_str, "%u.%u.%u.%u", &rhs[0], &rhs[1], &rhs[2], &rhs[3]);
 278
 279   // Do component-wise comparison.
 280   for(unsigned int i=0; i < 4; ++i)
 281     {
 282     if(lhs[i] < rhs[i])
 283       {
 284       // lhs < rhs, so true if operation is LESS
 285       return op == OpLess;
 286       }
 287     else if(lhs[i] > rhs[i])
 288       {
 289       // lhs > rhs, so true if operation is GREATER
 290       return op == OpGreater;
 291       }
 292     }
 293   // lhs == rhs, so true if operation is EQUAL
 294   return op == OpEqual;
 295   }
 296
 297   //=========================================================================
 298   // level 0 processes parenthetical expressions
 299   bool HandleLevel0(std::list<std::string> &newArgs,
 300                     cmMakefile *makefile,
 301                     std::string &errorString)
 302   {
 303   int reducible;
 304   do
 305     {
 306     reducible = 0;
 307     std::list<std::string>::iterator arg = newArgs.begin();
 308     while (arg != newArgs.end())
 309       {
 310       if (*arg == "(")
 311         {
 312         // search for the closing paren for this opening one
 313         std::list<std::string>::iterator argClose;
 314         argClose = arg;
 315         argClose++;
 316         unsigned int depth = 1;
 317         while (argClose != newArgs.end() && depth)
 318           {
 319           if (*argClose == "(")
 320             {
 321               depth++;
 322             }
 323           if (*argClose == ")")
 324             {
 325               depth--;
 326             }
 327           argClose++;
 328           }
 329         if (depth)
 330           {
 331           errorString = "mismatched parenthesis in condition";
 332           return false;
 333           }
 334         // store the reduced args in this vector
 335         std::vector<std::string> newArgs2;
 336
 337         // copy to the list structure
 338         std::list<std::string>::iterator argP1 = arg;
 339         argP1++;
 340         for(; argP1 != argClose; argP1++)
 341           {
 342           newArgs2.push_back(*argP1);
 343           }
 344         newArgs2.pop_back();
 345         // now recursively invoke IsTrue to handle the values inside the
 346         // parenthetical expression
 347         bool value =
 348           cmIfCommand::IsTrue(newArgs2, errorString, makefile);
 349         if(value)
 350           {
 351           *arg = "1";
 352           }
 353         else
 354           {
 355           *arg = "0";
 356           }
 357         argP1 = arg;
 358         argP1++;
 359         // remove the now evaluated parenthetical expression
 360         newArgs.erase(argP1,argClose);
 361         }
 362       ++arg;
 363       }
 364     }
 365   while (reducible);
 366   return true;
 367   }
 368
 369   //=========================================================================
 370   // level one handles most predicates except for NOT
 371   bool HandleLevel1(std::list<std::string> &newArgs,
 372                     cmMakefile *makefile,
 373                     std::string &)
 374   {
 375   int reducible;
 376   do
 377     {
 378     reducible = 0;
 379     std::list<std::string>::iterator arg = newArgs.begin();
 380     std::list<std::string>::iterator argP1;
 381     std::list<std::string>::iterator argP2;
 382     while (arg != newArgs.end())
 383       {
 384       argP1 = arg;
 385       IncrementArguments(newArgs,argP1,argP2);
 386       // does a file exist
 387       if (*arg == "EXISTS" && argP1  != newArgs.end())
 388         {
 389         HandlePredicate(
 390           cmSystemTools::FileExists((argP1)->c_str()),
 391           reducible, arg, newArgs, argP1, argP2);
 392         }
 393       // does a directory with this name exist
 394       if (*arg == "IS_DIRECTORY" && argP1  != newArgs.end())
 395         {
 396         HandlePredicate(
 397           cmSystemTools::FileIsDirectory((argP1)->c_str()),
 398           reducible, arg, newArgs, argP1, argP2);
 399         }
 400       // is the given path an absolute path ?
 401       if (*arg == "IS_ABSOLUTE" && argP1  != newArgs.end())
 402         {
 403         HandlePredicate(
 404           cmSystemTools::FileIsFullPath((argP1)->c_str()),
 405           reducible, arg, newArgs, argP1, argP2);
 406         }
 407       // does a command exist
 408       if (*arg == "COMMAND" && argP1  != newArgs.end())
 409         {
 410         HandlePredicate(
 411           makefile->CommandExists((argP1)->c_str()),
 412           reducible, arg, newArgs, argP1, argP2);
 413         }
 414       // does a policy exist
 415       if (*arg == "POLICY" && argP1 != newArgs.end())
 416         {
 417         cmPolicies::PolicyID pid;
 418         HandlePredicate(
 419           makefile->GetPolicies()->GetPolicyID((argP1)->c_str(), pid),
 420           reducible, arg, newArgs, argP1, argP2);
 421         }
 422       // does a target exist
 423       if (*arg == "TARGET" && argP1 != newArgs.end())
 424         {
 425         HandlePredicate(
 426           makefile->FindTargetToUse((argP1)->c_str())? true:false,
 427           reducible, arg, newArgs, argP1, argP2);
 428         }
 429       // is a variable defined
 430       if (*arg == "DEFINED" && argP1  != newArgs.end())
 431         {
 432         size_t argP1len = argP1->size();
 433         bool bdef = false;
 434         if(argP1len > 4 && argP1->substr(0, 4) == "ENV{" &&
 435            argP1->operator[](argP1len-1) == '}')
 436           {
 437           std::string env = argP1->substr(4, argP1len-5);
 438           bdef = cmSystemTools::GetEnv(env.c_str())?true:false;
 439           }
 440         else
 441           {
 442           bdef = makefile->IsDefinitionSet((argP1)->c_str());
 443           }
 444         HandlePredicate(bdef, reducible, arg, newArgs, argP1, argP2);
 445         }
 446       ++arg;
 447       }
 448     }
 449   while (reducible);
 450   return true;
 451   }
 452
 453   //=========================================================================
 454   // level two handles most binary operations except for AND  OR
 455   bool HandleLevel2(std::list<std::string> &newArgs,
 456                     cmMakefile *makefile,
 457                     std::string &errorString)
 458   {
 459   int reducible;
 460   const char *def;
 461   const char *def2;
 462   do
 463     {
 464     reducible = 0;
 465     std::list<std::string>::iterator arg = newArgs.begin();
 466     std::list<std::string>::iterator argP1;
 467     std::list<std::string>::iterator argP2;
 468     while (arg != newArgs.end())
 469       {
 470       argP1 = arg;
 471       IncrementArguments(newArgs,argP1,argP2);
 472       if (argP1 != newArgs.end() && argP2 != newArgs.end() &&
 473         *(argP1) == "MATCHES")
 474         {
 475         def = cmIfCommand::GetVariableOrString(arg->c_str(), makefile);
 476         const char* rex = (argP2)->c_str();
 477         cmStringCommand::ClearMatches(makefile);
 478         cmsys::RegularExpression regEntry;
 479         if ( !regEntry.compile(rex) )
 480           {
 481           cmOStringStream error;
 482           error << "Regular expression \"" << rex << "\" cannot compile";
 483           errorString = error.str();
 484           return false;
 485           }
 486         if (regEntry.find(def))
 487           {
 488           cmStringCommand::StoreMatches(makefile, regEntry);
 489           *arg = "1";
 490           }
 491         else
 492           {
 493           *arg = "0";
 494           }
 495         newArgs.erase(argP2);
 496         newArgs.erase(argP1);
 497         argP1 = arg;
 498         IncrementArguments(newArgs,argP1,argP2);
 499         reducible = 1;
 500         }
 501
 502       if (argP1 != newArgs.end() && *arg == "MATCHES")
 503         {
 504         *arg = "0";
 505         newArgs.erase(argP1);
 506         argP1 = arg;
 507         IncrementArguments(newArgs,argP1,argP2);
 508         reducible = 1;
 509         }
 510
 511       if (argP1 != newArgs.end() && argP2 != newArgs.end() &&
 512         (*(argP1) == "LESS" || *(argP1) == "GREATER" ||
 513          *(argP1) == "EQUAL"))
 514         {
 515         def = cmIfCommand::GetVariableOrString(arg->c_str(), makefile);
 516         def2 = cmIfCommand::GetVariableOrString((argP2)->c_str(), makefile);
 517         double lhs;
 518         double rhs;
 519         bool result;
 520         if(sscanf(def, "%lg", &lhs) != 1 ||
 521            sscanf(def2, "%lg", &rhs) != 1)
 522           {
 523           result = false;
 524           }
 525         else if (*(argP1) == "LESS")
 526           {
 527           result = (lhs < rhs);
 528           }
 529         else if (*(argP1) == "GREATER")
 530           {
 531           result = (lhs > rhs);
 532           }
 533         else
 534           {
 535           result = (lhs == rhs);
 536           }
 537         HandleBinaryOp(result,
 538           reducible, arg, newArgs, argP1, argP2);
 539         }
 540
 541       if (argP1 != newArgs.end() && argP2 != newArgs.end() &&
 542         (*(argP1) == "STRLESS" ||
 543          *(argP1) == "STREQUAL" ||
 544          *(argP1) == "STRGREATER"))
 545         {
 546         def = cmIfCommand::GetVariableOrString(arg->c_str(), makefile);
 547         def2 = cmIfCommand::GetVariableOrString((argP2)->c_str(), makefile);
 548         int val = strcmp(def,def2);
 549         bool result;
 550         if (*(argP1) == "STRLESS")
 551           {
 552           result = (val < 0);
 553           }
 554         else if (*(argP1) == "STRGREATER")
 555           {
 556           result = (val > 0);
 557           }
 558         else // strequal
 559           {
 560           result = (val == 0);
 561           }
 562         HandleBinaryOp(result,
 563           reducible, arg, newArgs, argP1, argP2);
 564         }
 565
 566       if (argP1 != newArgs.end() && argP2 != newArgs.end() &&
 567         (*(argP1) == "VERSION_LESS" || *(argP1) == "VERSION_GREATER" ||
 568          *(argP1) == "VERSION_EQUAL"))
 569         {
 570         def = cmIfCommand::GetVariableOrString(arg->c_str(), makefile);
 571         def2 = cmIfCommand::GetVariableOrString((argP2)->c_str(), makefile);
 572         Op op = OpEqual;
 573         if(*argP1 == "VERSION_LESS")
 574           {
 575           op = OpLess;
 576           }
 577         else if(*argP1 == "VERSION_GREATER")
 578           {
 579           op = OpGreater;
 580           }
 581         bool result = HandleVersionCompare(op, def, def2);
 582         HandleBinaryOp(result,
 583           reducible, arg, newArgs, argP1, argP2);
 584         }
 585
 586       // is file A newer than file B
 587       if (argP1 != newArgs.end() && argP2 != newArgs.end() &&
 588           *(argP1) == "IS_NEWER_THAN")
 589         {
 590         int fileIsNewer=0;
 591         bool success=cmSystemTools::FileTimeCompare(arg->c_str(),
 592             (argP2)->c_str(),
 593             &fileIsNewer);
 594         HandleBinaryOp(
 595           (success==false || fileIsNewer==1 || fileIsNewer==0),
 596           reducible, arg, newArgs, argP1, argP2);
 597         }
 598
 599       ++arg;
 600       }
 601     }
 602   while (reducible);
 603   return true;
 604   }
 605
 606   //=========================================================================
 607   // level 3 handles NOT
 608   bool HandleLevel3(std::list<std::string> &newArgs,
 609                     cmMakefile *makefile,
 610                     std::string &)
 611   {
 612   int reducible;
 613   const char *def;
 614   do
 615     {
 616     reducible = 0;
 617     std::list<std::string>::iterator arg = newArgs.begin();
 618     std::list<std::string>::iterator argP1;
 619     std::list<std::string>::iterator argP2;
 620     while (arg != newArgs.end())
 621       {
 622       argP1 = arg;
 623       IncrementArguments(newArgs,argP1,argP2);
 624       if (argP1 != newArgs.end() && *arg == "NOT")
 625         {
 626         def = cmIfCommand::GetVariableOrNumber((argP1)->c_str(), makefile);
 627         HandlePredicate(cmSystemTools::IsOff(def),
 628           reducible, arg, newArgs, argP1, argP2);
 629         }
 630       ++arg;
 631       }
 632     }
 633   while (reducible);
 634   return true;
 635   }
 636
 637   //=========================================================================
 638   // level 4 handles AND OR
 639   bool HandleLevel4(std::list<std::string> &newArgs,
 640                     cmMakefile *makefile,
 641                     std::string &)
 642   {
 643   int reducible;
 644   const char *def;
 645   const char *def2;
 646   do
 647     {
 648     reducible = 0;
 649     std::list<std::string>::iterator arg = newArgs.begin();
 650     std::list<std::string>::iterator argP1;
 651     std::list<std::string>::iterator argP2;
 652     while (arg != newArgs.end())
 653       {
 654       argP1 = arg;
 655       IncrementArguments(newArgs,argP1,argP2);
 656       if (argP1 != newArgs.end() && *(argP1) == "AND" &&
 657         argP2 != newArgs.end())
 658         {
 659         def = cmIfCommand::GetVariableOrNumber(arg->c_str(), makefile);
 660         def2 = cmIfCommand::GetVariableOrNumber((argP2)->c_str(), makefile);
 661         HandleBinaryOp(
 662           !(cmSystemTools::IsOff(def) || cmSystemTools::IsOff(def2)),
 663           reducible, arg, newArgs, argP1, argP2);
 664         }
 665
 666       if (argP1 != newArgs.end() && *(argP1) == "OR" &&
 667         argP2 != newArgs.end())
 668         {
 669         def = cmIfCommand::GetVariableOrNumber(arg->c_str(), makefile);
 670         def2 = cmIfCommand::GetVariableOrNumber((argP2)->c_str(), makefile);
 671         HandleBinaryOp(
 672           !(cmSystemTools::IsOff(def) && cmSystemTools::IsOff(def2)),
 673           reducible, arg, newArgs, argP1, argP2);
 674         }
 675       ++arg;
 676       }
 677     }
 678   while (reducible);
 679   return true;
 680   }
 681 }
 682
 683
 684 //=========================================================================
 685 // order of operations,
 686 // 1.   ( )   -- parenthetical groups
 687 // 2.  IS_DIRECTORY EXISTS COMMAND DEFINED etc predicates
 688 // 3. MATCHES LESS GREATER EQUAL STRLESS STRGREATER STREQUAL etc binary ops
 689 // 4. NOT
 690 // 5. AND OR
 691 //
 692 // There is an issue on whether the arguments should be values of references,
 693 // for example IF (FOO AND BAR) should that compare the strings FOO and BAR
 694 // or should it really do IF (${FOO} AND ${BAR}) Currently IS_DIRECTORY
 695 // EXISTS COMMAND and DEFINED all take values. EQUAL, LESS and GREATER can
 696 // take numeric values or variable names. STRLESS and STRGREATER take
 697 // variable names but if the variable name is not found it will use the name
 698 // directly. AND OR take variables or the values 0 or 1.
 699
 700
 701 bool cmIfCommand::IsTrue(const std::vector<std::string> &args,
 702                          std::string &errorString, cmMakefile *makefile)
 703 {
 704   const char *def;
 705   errorString = "";
 706
 707   // handle empty invocation
 708   if (args.size() < 1)
 709     {
 710     return false;
 711     }
 712
 713   // store the reduced args in this vector
 714   std::list<std::string> newArgs;
 715
 716   // copy to the list structure
 717   for(unsigned int i = 0; i < args.size(); ++i)
 718     {
 719     newArgs.push_back(args[i]);
 720     }
 721
 722   // now loop through the arguments and see if we can reduce any of them
 723   // we do this multiple times. Once for each level of precedence
 724   if (!HandleLevel0(newArgs, makefile, errorString)) // parens
 725     {
 726     return false;
 727     }
 728   if (!HandleLevel1(newArgs, makefile, errorString)) //predicates
 729     {
 730     return false;
 731     }
 732   if (!HandleLevel2(newArgs, makefile, errorString)) // binary ops
 733     {
 734     return false;
 735     }
 736   if (!HandleLevel3(newArgs, makefile, errorString)) // NOT
 737     {
 738     return false;
 739     }
 740   if (!HandleLevel4(newArgs, makefile, errorString)) // AND OR
 741     {
 742     return false;
 743     }
 744
 745   // now at the end there should only be one argument left
 746   if (newArgs.size() == 1)
 747     {
 748     if (*newArgs.begin() == "0")
 749       {
 750       return false;
 751       }
 752     if (*newArgs.begin() == "1")
 753       {
 754       return true;
 755       }
 756     def = makefile->GetDefinition(args[0].c_str());
 757     if(cmSystemTools::IsOff(def))
 758       {
 759       return false;
 760       }
 761     }
 762   else
 763     {
 764     errorString = "Unknown arguments specified";
 765     return false;
 766     }
 767
 768   return true;
 769 }
 770
 771 //=========================================================================
 772 const char* cmIfCommand::GetVariableOrString(const char* str,
 773                                              const cmMakefile* mf)
 774 {
 775   const char* def = mf->GetDefinition(str);
 776   if(!def)
 777     {
 778     def = str;
 779     }
 780   return def;
 781 }
 782
 783 //=========================================================================
 784 const char* cmIfCommand::GetVariableOrNumber(const char* str,
 785                                              const cmMakefile* mf)
 786 {
 787   const char* def = mf->GetDefinition(str);
 788   if(!def)
 789     {
 790     if (atoi(str))
 791       {
 792       def = str;
 793       }
 794     }
 795   return def;
 796 }