Source/cmListFileLexer.in.l

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