Source/cmCommandArgumentParserHelper.cxx

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmCommandArgumentParserHelper.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2009-03-25 14:36:57 $
   7   Version:   $Revision: 1.23 $
   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 "cmCommandArgumentParserHelper.h"
  18
  19 #include "cmSystemTools.h"
  20 #include "cmCommandArgumentLexer.h"
  21
  22 #include "cmMakefile.h"
  23
  24 int cmCommandArgument_yyparse( yyscan_t yyscanner );
  25 //
  26 cmCommandArgumentParserHelper::cmCommandArgumentParserHelper()
  27 {
  28   this->FileLine = -1;
  29   this->FileName = 0;
  30   this->RemoveEmpty = true;
  31   this->EmptyVariable[0] = 0;
  32   strcpy(this->DCURLYVariable, "${");
  33   strcpy(this->RCURLYVariable, "}");
  34   strcpy(this->ATVariable,     "@");
  35   strcpy(this->DOLLARVariable, "$");
  36   strcpy(this->LCURLYVariable, "{");
  37   strcpy(this->BSLASHVariable, "\\");
  38
  39   this->NoEscapeMode = false;
  40   this->ReplaceAtSyntax = false;
  41 }
  42
  43
  44 cmCommandArgumentParserHelper::~cmCommandArgumentParserHelper()
  45 {
  46   this->CleanupParser();
  47 }
  48
  49 void cmCommandArgumentParserHelper::SetLineFile(long line, const char* file)
  50 {
  51   this->FileLine = line;
  52   this->FileName = file;
  53 }
  54
  55 char* cmCommandArgumentParserHelper::AddString(const char* str)
  56 {
  57   if ( !str || !*str )
  58     {
  59     return this->EmptyVariable;
  60     }
  61   char* stVal = new char[strlen(str)+1];
  62   strcpy(stVal, str);
  63   this->Variables.push_back(stVal);
  64   return stVal;
  65 }
  66
  67 char* cmCommandArgumentParserHelper::ExpandSpecialVariable(const char* key,
  68                                                            const char* var)
  69 {
  70   if ( !key )
  71     {
  72     return this->ExpandVariable(var);
  73     }
  74   if ( strcmp(key, "ENV") == 0 )
  75     {
  76     char *ptr = getenv(var);
  77     if (ptr)
  78       {
  79       if (this->EscapeQuotes)
  80         {
  81         return this->AddString(cmSystemTools::EscapeQuotes(ptr).c_str());
  82         }
  83       else
  84         {
  85         return ptr;
  86         }
  87       }
  88     return this->EmptyVariable;
  89     }
  90   if ( strcmp(key, "CACHE") == 0 )
  91     {
  92     if(const char* c = this->Makefile->GetCacheManager()->GetCacheValue(var))
  93       {
  94       if(this->EscapeQuotes)
  95         {
  96         return this->AddString(cmSystemTools::EscapeQuotes(c).c_str());
  97         }
  98       else
  99         {
 100         return this->AddString(c);
 101         }
 102       }
 103     return this->EmptyVariable;
 104     }
 105   cmOStringStream e;
 106   e << "Syntax $" << key << "{} is not supported.  "
 107     << "Only ${}, $ENV{}, and $CACHE{} are allowed.";
 108   this->SetError(e.str());
 109   return 0;
 110 }
 111
 112 char* cmCommandArgumentParserHelper::ExpandVariable(const char* var)
 113 {
 114   if(!var)
 115     {
 116     return 0;
 117     }
 118   if(this->FileLine >= 0 && strcmp(var, "CMAKE_CURRENT_LIST_LINE") == 0)
 119     {
 120     cmOStringStream ostr;
 121     ostr << this->FileLine;
 122     return this->AddString(ostr.str().c_str());
 123     }
 124   const char* value = this->Makefile->GetDefinition(var);
 125   if(!value && !this->RemoveEmpty)
 126     {
 127     return 0;
 128     }
 129   if (this->EscapeQuotes && value)
 130     {
 131     return this->AddString(cmSystemTools::EscapeQuotes(value).c_str());
 132     }
 133   return this->AddString(value);
 134 }
 135
 136 char* cmCommandArgumentParserHelper::ExpandVariableForAt(const char* var)
 137 {
 138   if(this->ReplaceAtSyntax)
 139     {
 140     // try to expand the variable
 141     char* ret = this->ExpandVariable(var);
 142     // if the return was 0 and we want to replace empty strings
 143     // then return an empty string
 144     if(!ret && this->RemoveEmpty)
 145       {
 146       return this->AddString(ret);
 147       }
 148     // if the ret was not 0, then return it
 149     if(ret)
 150       {
 151       return ret;
 152       }
 153     }
 154   // at this point we want to put it back because of one of these cases:
 155   // - this->ReplaceAtSyntax is false
 156   // - this->ReplaceAtSyntax is true, but this->RemoveEmpty is false,
 157   //   and the variable was not defined
 158   std::string ref = "@";
 159   ref += var;
 160   ref += "@";
 161   return this->AddString(ref.c_str());
 162 }
 163
 164 char* cmCommandArgumentParserHelper::CombineUnions(char* in1, char* in2)
 165 {
 166   if ( !in1 )
 167     {
 168     return in2;
 169     }
 170   else if ( !in2 )
 171     {
 172     return in1;
 173     }
 174   size_t len = strlen(in1) + strlen(in2) + 1;
 175   char* out = new char [ len ];
 176   strcpy(out, in1);
 177   strcat(out, in2);
 178   this->Variables.push_back(out);
 179   return out;
 180 }
 181
 182 void cmCommandArgumentParserHelper::AllocateParserType
 183 (cmCommandArgumentParserHelper::ParserType* pt,const char* str, int len)
 184 {
 185   pt->str = 0;
 186   if ( len == 0 )
 187     {
 188     len = static_cast<int>(strlen(str));
 189     }
 190   if ( len == 0 )
 191     {
 192     return;
 193     }
 194   pt->str = new char[ len + 1 ];
 195   strncpy(pt->str, str, len);
 196   pt->str[len] = 0;
 197   this->Variables.push_back(pt->str);
 198 }
 199
 200 bool cmCommandArgumentParserHelper::HandleEscapeSymbol
 201 (cmCommandArgumentParserHelper::ParserType* pt, char symbol)
 202 {
 203   switch ( symbol )
 204     {
 205   case '\\':
 206   case '"':
 207   case ' ':
 208   case '#':
 209   case '(':
 210   case ')':
 211   case '$':
 212   case '@':
 213   case '^':
 214     this->AllocateParserType(pt, &symbol, 1);
 215     break;
 216   case ';':
 217     this->AllocateParserType(pt, "\\;", 2);
 218     break;
 219   case 't':
 220     this->AllocateParserType(pt, "\t", 1);
 221     break;
 222   case 'n':
 223     this->AllocateParserType(pt, "\n", 1);
 224     break;
 225   case 'r':
 226     this->AllocateParserType(pt, "\r", 1);
 227     break;
 228   case '0':
 229     this->AllocateParserType(pt, "\0", 1);
 230     break;
 231   default:
 232     {
 233     cmOStringStream e;
 234     e << "Invalid escape sequence \\" << symbol;
 235     this->SetError(e.str());
 236     }
 237     return false;
 238     }
 239   return true;
 240 }
 241
 242 void cmCommandArgument_SetupEscapes(yyscan_t yyscanner, bool noEscapes);
 243
 244 int cmCommandArgumentParserHelper::ParseString(const char* str, int verb)
 245 {
 246   if ( !str)
 247     {
 248     return 0;
 249     }
 250   this->Verbose = verb;
 251   this->InputBuffer = str;
 252   this->InputBufferPos = 0;
 253   this->CurrentLine = 0;
 254
 255   this->Result = "";
 256
 257   yyscan_t yyscanner;
 258   cmCommandArgument_yylex_init(&yyscanner);
 259   cmCommandArgument_yyset_extra(this, yyscanner);
 260   cmCommandArgument_SetupEscapes(yyscanner, this->NoEscapeMode);
 261   int res = cmCommandArgument_yyparse(yyscanner);
 262   cmCommandArgument_yylex_destroy(yyscanner);
 263   if ( res != 0 )
 264     {
 265     return 0;
 266     }
 267
 268   this->CleanupParser();
 269
 270   if ( Verbose )
 271     {
 272     std::cerr << "Expanding [" << str << "] produced: ["
 273               << this->Result.c_str() << "]" << std::endl;
 274     }
 275   return 1;
 276 }
 277
 278 void cmCommandArgumentParserHelper::CleanupParser()
 279 {
 280   std::vector<char*>::iterator sit;
 281   for ( sit = this->Variables.begin();
 282     sit != this->Variables.end();
 283     ++ sit )
 284     {
 285     delete [] *sit;
 286     }
 287   this->Variables.erase(this->Variables.begin(), this->Variables.end());
 288 }
 289
 290 int cmCommandArgumentParserHelper::LexInput(char* buf, int maxlen)
 291 {
 292   if ( maxlen < 1 )
 293     {
 294     return 0;
 295     }
 296   if ( this->InputBufferPos < this->InputBuffer.size() )
 297     {
 298     buf[0] = this->InputBuffer[ this->InputBufferPos++ ];
 299     if ( buf[0] == '\n' )
 300       {
 301       this->CurrentLine ++;
 302       }
 303     return(1);
 304     }
 305   else
 306     {
 307     buf[0] = '\n';
 308     return( 0 );
 309     }
 310 }
 311
 312 void cmCommandArgumentParserHelper::Error(const char* str)
 313 {
 314   unsigned long pos = static_cast<unsigned long>(this->InputBufferPos);
 315   cmOStringStream ostr;
 316   ostr << str << " (" << pos << ")";
 317   this->SetError(ostr.str());
 318 }
 319
 320 void cmCommandArgumentParserHelper::SetMakefile(const cmMakefile* mf)
 321 {
 322   this->Makefile = mf;
 323 }
 324
 325 void cmCommandArgumentParserHelper::SetResult(const char* value)
 326 {
 327   if ( !value )
 328     {
 329     this->Result = "";
 330     return;
 331     }
 332   this->Result = value;
 333 }
 334
 335 void cmCommandArgumentParserHelper::SetError(std::string const& msg)
 336 {
 337   // Keep only the first error.
 338   if(this->ErrorString.empty())
 339     {
 340     this->ErrorString = msg;
 341     }
 342 }