Source/cmListFileLexer.in.l

   1 %{
   2 /*============================================================================
   3   CMake - Cross Platform Makefile Generator
   4   Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
   5
   6   Distributed under the OSI-approved BSD License (the "License");
   7   see accompanying file Copyright.txt for details.
   8
   9   This software is distributed WITHOUT ANY WARRANTY; without even the
  10   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  11   See the License for more information.
  12 ============================================================================*/
  13 /*
  14
  15 This file must be translated to C and modified to build everywhere.
  16
  17 Run flex like this:
  18
  19   flex --prefix=cmListFileLexer_yy -ocmListFileLexer.c cmListFileLexer.in.l
  20
  21 Modify cmListFileLexer.c:
  22   - remove TABs
  23   - remove use of the 'register' storage class specifier
  24   - remove the yyunput function
  25   - add a statement "(void)yyscanner;" to the top of these methods:
  26       yy_fatal_error, cmListFileLexer_yyalloc, cmListFileLexer_yyrealloc, cmListFileLexer_yyfree
  27   - remove statement "yyscanner = NULL;" from cmListFileLexer_yylex_destroy
  28   - remove all YY_BREAK lines occurring right after return statements
  29   - remove the isatty forward declaration
  30
  31 */
  32
  33 #include "cmStandardLexer.h"
  34
  35 /* Setup the proper cmListFileLexer_yylex declaration.  */
  36 #define YY_EXTRA_TYPE cmListFileLexer*
  37 #define YY_DECL int cmListFileLexer_yylex (yyscan_t yyscanner, cmListFileLexer* lexer)
  38
  39 #include "cmListFileLexer.h"
  40
  41 /*--------------------------------------------------------------------------*/
  42 struct cmListFileLexer_s
  43 {
  44   cmListFileLexer_Token token;
  45   int line;
  46   int column;
  47   int size;
  48   FILE* file;
  49   char* string_buffer;
  50   char* string_position;
  51   int string_left;
  52   yyscan_t scanner;
  53 };
  54
  55 static void cmListFileLexerSetToken(cmListFileLexer* lexer, const char* text,
  56                                     int length);
  57 static void cmListFileLexerAppend(cmListFileLexer* lexer, const char* text,
  58                                   int length);
  59 static int cmListFileLexerInput(cmListFileLexer* lexer, char* buffer,
  60                                 size_t bufferSize);
  61 static void cmListFileLexerInit(cmListFileLexer* lexer);
  62 static void cmListFileLexerDestroy(cmListFileLexer* lexer);
  63
  64 /* Replace the lexer input function.  */
  65 #undef YY_INPUT
  66 #define YY_INPUT(buf, result, max_size) \
  67   { result = cmListFileLexerInput(cmListFileLexer_yyget_extra(yyscanner), buf, max_size); }
  68
  69 /*--------------------------------------------------------------------------*/
  70 %}
  71
  72 %option reentrant
  73 %option yylineno
  74 %option noyywrap
  75 %pointer
  76 %x STRING
  77
  78 MAKEVAR \$\([A-Za-z0-9_]*\)
  79 UNQUOTED ([^ \t\r\n\(\)#\\\"]|\\.)
  80 LEGACY {MAKEVAR}|{UNQUOTED}|\"({MAKEVAR}|{UNQUOTED}|[ \t])*\"
  81
  82 %%
  83
  84 \n {
  85   lexer->token.type = cmListFileLexer_Token_Newline;
  86   cmListFileLexerSetToken(lexer, yytext, yyleng);
  87   ++lexer->line;
  88   lexer->column = 1;
  89   return 1;
  90 }
  91
  92 #.* {
  93   lexer->column += yyleng;
  94 }
  95
  96 \( {
  97   lexer->token.type = cmListFileLexer_Token_ParenLeft;
  98   cmListFileLexerSetToken(lexer, yytext, yyleng);
  99   lexer->column += yyleng;
 100   return 1;
 101 }
 102
 103 \) {
 104   lexer->token.type = cmListFileLexer_Token_ParenRight;
 105   cmListFileLexerSetToken(lexer, yytext, yyleng);
 106   lexer->column += yyleng;
 107   return 1;
 108 }
 109
 110 [A-Za-z_][A-Za-z0-9_]+ {
 111   lexer->token.type = cmListFileLexer_Token_Identifier;
 112   cmListFileLexerSetToken(lexer, yytext, yyleng);
 113   lexer->column += yyleng;
 114   return 1;
 115 }
 116
 117 ({UNQUOTED})({UNQUOTED})* {
 118   lexer->token.type = cmListFileLexer_Token_ArgumentUnquoted;
 119   cmListFileLexerSetToken(lexer, yytext, yyleng);
 120   lexer->column += yyleng;
 121   return 1;
 122 }
 123
 124 ({MAKEVAR}|{UNQUOTED})({LEGACY})* {
 125   lexer->token.type = cmListFileLexer_Token_ArgumentUnquoted;
 126   cmListFileLexerSetToken(lexer, yytext, yyleng);
 127   lexer->column += yyleng;
 128   return 1;
 129 }
 130
 131 \" {
 132   lexer->token.type = cmListFileLexer_Token_ArgumentQuoted;
 133   cmListFileLexerSetToken(lexer, "", 0);
 134   lexer->column += yyleng;
 135   BEGIN(STRING);
 136 }
 137
 138 <STRING>([^\\\n\"]|\\.)+ {
 139   cmListFileLexerAppend(lexer, yytext, yyleng);
 140   lexer->column += yyleng;
 141 }
 142
 143 <STRING>\\\n {
 144   cmListFileLexerAppend(lexer, yytext, yyleng);
 145   ++lexer->line;
 146   lexer->column = 1;
 147 }
 148
 149 <STRING>\n {
 150   cmListFileLexerAppend(lexer, yytext, yyleng);
 151   ++lexer->line;
 152   lexer->column = 1;
 153 }
 154
 155 <STRING>\" {
 156   lexer->column += yyleng;
 157   BEGIN(INITIAL);
 158   return 1;
 159 }
 160
 161 <STRING>. {
 162   cmListFileLexerAppend(lexer, yytext, yyleng);
 163   lexer->column += yyleng;
 164 }
 165
 166 <STRING><<EOF>> {
 167   lexer->token.type = cmListFileLexer_Token_BadString;
 168   BEGIN(INITIAL);
 169   return 1;
 170 }
 171
 172 [ \t\r]+ {
 173   lexer->token.type = cmListFileLexer_Token_Space;
 174   cmListFileLexerSetToken(lexer, yytext, yyleng);
 175   lexer->column += yyleng;
 176   return 1;
 177 }
 178
 179 . {
 180   lexer->token.type = cmListFileLexer_Token_BadCharacter;
 181   cmListFileLexerSetToken(lexer, yytext, yyleng);
 182   lexer->column += yyleng;
 183   return 1;
 184 }
 185
 186 <<EOF>> {
 187   lexer->token.type = cmListFileLexer_Token_None;
 188   cmListFileLexerSetToken(lexer, 0, 0);
 189   return 0;
 190 }
 191
 192 %%
 193
 194 /*--------------------------------------------------------------------------*/
 195 static void cmListFileLexerSetToken(cmListFileLexer* lexer, const char* text,
 196                                     int length)
 197 {
 198   /* Set the token line and column number.  */
 199   lexer->token.line = lexer->line;
 200   lexer->token.column = lexer->column;
 201
 202   /* Use the same buffer if possible.  */
 203   if(lexer->token.text)
 204     {
 205     if(text && length < lexer->size)
 206       {
 207       strcpy(lexer->token.text, text);
 208       lexer->token.length = length;
 209       return;
 210       }
 211     free(lexer->token.text);
 212     lexer->token.text = 0;
 213     lexer->size = 0;
 214     }
 215
 216   /* Need to extend the buffer.  */
 217   if(text)
 218     {
 219     lexer->token.text = strdup(text);
 220     lexer->token.length = length;
 221     lexer->size = length+1;
 222     }
 223   else
 224     {
 225     lexer->token.length = 0;
 226     }
 227 }
 228
 229 /*--------------------------------------------------------------------------*/
 230 static void cmListFileLexerAppend(cmListFileLexer* lexer, const char* text,
 231                                   int length)
 232 {
 233   char* temp;
 234   int newSize;
 235
 236   /* If the appended text will fit in the buffer, do not reallocate.  */
 237   newSize = lexer->token.length + length + 1;
 238   if(lexer->token.text && newSize <= lexer->size)
 239     {
 240     strcpy(lexer->token.text+lexer->token.length, text);
 241     lexer->token.length += length;
 242     return;
 243     }
 244
 245   /* We need to extend the buffer.  */
 246   temp = malloc(newSize);
 247   if(lexer->token.text)
 248     {
 249     memcpy(temp, lexer->token.text, lexer->token.length);
 250     free(lexer->token.text);
 251     }
 252   memcpy(temp+lexer->token.length, text, length);
 253   temp[lexer->token.length+length] = 0;
 254   lexer->token.text = temp;
 255   lexer->token.length += length;
 256   lexer->size = newSize;
 257 }
 258
 259 /*--------------------------------------------------------------------------*/
 260 static int cmListFileLexerInput(cmListFileLexer* lexer, char* buffer,
 261                                 size_t bufferSize)
 262 {
 263   if(lexer)
 264     {
 265     if(lexer->file)
 266       {
 267       return (int)fread(buffer, 1, bufferSize, lexer->file);
 268       }
 269     else if(lexer->string_left)
 270       {
 271       int length = lexer->string_left;
 272       if((int)bufferSize < length) { length = (int)bufferSize; }
 273       memcpy(buffer, lexer->string_position, length);
 274       lexer->string_position += length;
 275       lexer->string_left -= length;
 276       return length;
 277       }
 278     }
 279   return 0;
 280 }
 281
 282 /*--------------------------------------------------------------------------*/
 283 static void cmListFileLexerInit(cmListFileLexer* lexer)
 284 {
 285   if(lexer->file || lexer->string_buffer)
 286     {
 287     cmListFileLexer_yylex_init(&lexer->scanner);
 288     cmListFileLexer_yyset_extra(lexer, lexer->scanner);
 289     }
 290 }
 291
 292 /*--------------------------------------------------------------------------*/
 293 static void cmListFileLexerDestroy(cmListFileLexer* lexer)
 294 {
 295   if(lexer->file || lexer->string_buffer)
 296     {
 297     cmListFileLexer_yylex_destroy(lexer->scanner);
 298     if(lexer->file)
 299       {
 300       fclose(lexer->file);
 301       lexer->file = 0;
 302       }
 303     if(lexer->string_buffer)
 304       {
 305       free(lexer->string_buffer);
 306       lexer->string_buffer = 0;
 307       lexer->string_left = 0;
 308       lexer->string_position = 0;
 309       }
 310     }
 311 }
 312
 313 /*--------------------------------------------------------------------------*/
 314 cmListFileLexer* cmListFileLexer_New()
 315 {
 316   cmListFileLexer* lexer = (cmListFileLexer*)malloc(sizeof(cmListFileLexer));
 317   if(!lexer)
 318     {
 319     return 0;
 320     }
 321   memset(lexer, 0, sizeof(*lexer));
 322   lexer->line = 1;
 323   lexer->column = 1;
 324   return lexer;
 325 }
 326
 327 /*--------------------------------------------------------------------------*/
 328 void cmListFileLexer_Delete(cmListFileLexer* lexer)
 329 {
 330   cmListFileLexer_SetFileName(lexer, 0);
 331   free(lexer);
 332 }
 333
 334 /*--------------------------------------------------------------------------*/
 335 int cmListFileLexer_SetFileName(cmListFileLexer* lexer, const char* name)
 336 {
 337   int result = 1;
 338   cmListFileLexerDestroy(lexer);
 339   if(name)
 340     {
 341     lexer->file = fopen(name, "r");
 342     if(!lexer->file)
 343       {
 344       result = 0;
 345       }
 346     }
 347   cmListFileLexerInit(lexer);
 348   return result;
 349 }
 350
 351 /*--------------------------------------------------------------------------*/
 352 int cmListFileLexer_SetString(cmListFileLexer* lexer, const char* text)
 353 {
 354   int result = 1;
 355   cmListFileLexerDestroy(lexer);
 356   if(text)
 357     {
 358     int length = (int)strlen(text);
 359     lexer->string_buffer = (char*)malloc(length+1);
 360     if(lexer->string_buffer)
 361       {
 362       strcpy(lexer->string_buffer, text);
 363       lexer->string_position = lexer->string_buffer;
 364       lexer->string_left = length;
 365       }
 366     else
 367       {
 368       result = 0;
 369       }
 370     }
 371   cmListFileLexerInit(lexer);
 372   return result;
 373 }
 374
 375 /*--------------------------------------------------------------------------*/
 376 cmListFileLexer_Token* cmListFileLexer_Scan(cmListFileLexer* lexer)
 377 {
 378   if(!lexer->file)
 379     {
 380     return 0;
 381     }
 382   if(cmListFileLexer_yylex(lexer->scanner, lexer))
 383     {
 384     return &lexer->token;
 385     }
 386   else
 387     {
 388     cmListFileLexer_SetFileName(lexer, 0);
 389     return 0;
 390     }
 391 }
 392
 393 /*--------------------------------------------------------------------------*/
 394 long cmListFileLexer_GetCurrentLine(cmListFileLexer* lexer)
 395 {
 396   if(lexer->file)
 397     {
 398     return lexer->line;
 399     }
 400   else
 401     {
 402     return 0;
 403     }
 404 }
 405
 406 /*--------------------------------------------------------------------------*/
 407 long cmListFileLexer_GetCurrentColumn(cmListFileLexer* lexer)
 408 {
 409   if(lexer->file)
 410     {
 411     return lexer->column;
 412     }
 413   else
 414     {
 415     return 0;
 416     }
 417 }
 418
 419 /*--------------------------------------------------------------------------*/
 420 const char* cmListFileLexer_GetTypeAsString(cmListFileLexer* lexer,
 421                                             cmListFileLexer_Type type)
 422 {
 423   (void)lexer;
 424   switch(type)
 425     {
 426     case cmListFileLexer_Token_None: return "nothing";
 427     case cmListFileLexer_Token_Space: return "space";
 428     case cmListFileLexer_Token_Newline: return "newline";
 429     case cmListFileLexer_Token_Identifier: return "identifier";
 430     case cmListFileLexer_Token_ParenLeft: return "left paren";
 431     case cmListFileLexer_Token_ParenRight: return "right paren";
 432     case cmListFileLexer_Token_ArgumentUnquoted: return "unquoted argument";
 433     case cmListFileLexer_Token_ArgumentQuoted: return "quoted argument";
 434     case cmListFileLexer_Token_BadCharacter: return "bad character";
 435     case cmListFileLexer_Token_BadString: return "unterminated string";
 436     }
 437   return "unknown token";
 438 }