Source/cmExprLexer.cxx

   1 #include "cmStandardIncludes.h"
   2 #line 2 "/home/andy/vtk/CMake-bin/Source/cmExprLexer.cxx"
   3
   4 #line 4 "/home/andy/vtk/CMake-bin/Source/cmExprLexer.cxx"
   5
   6 #define  YY_INT_ALIGNED short int
   7
   8 /* A lexical scanner generated by flex */
   9
  10 #define FLEX_SCANNER
  11 #define YY_FLEX_MAJOR_VERSION 2
  12 #define YY_FLEX_MINOR_VERSION 5
  13 #define YY_FLEX_SUBMINOR_VERSION 31
  14 #if YY_FLEX_SUBMINOR_VERSION > 0
  15 #define FLEX_BETA
  16 #endif
  17
  18 /* First, we deal with  platform-specific or compiler-specific issues. */
  19
  20 /* begin standard C headers. */
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <errno.h>
  24 #include <stdlib.h>
  25
  26 /* end standard C headers. */
  27
  28 /* flex integer type definitions */
  29
  30 #ifndef FLEXINT_H
  31 #define FLEXINT_H
  32
  33 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
  34
  35 #if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
  36 #include <inttypes.h>
  37 typedef int8_t flex_int8_t;
  38 typedef uint8_t flex_uint8_t;
  39 typedef int16_t flex_int16_t;
  40 typedef uint16_t flex_uint16_t;
  41 typedef int32_t flex_int32_t;
  42 typedef uint32_t flex_uint32_t;
  43 #else
  44 typedef signed char flex_int8_t;
  45 typedef short int flex_int16_t;
  46 typedef int flex_int32_t;
  47 typedef unsigned char flex_uint8_t;
  48 typedef unsigned short int flex_uint16_t;
  49 typedef unsigned int flex_uint32_t;
  50 #endif /* ! C99 */
  51
  52 /* Limits of integral types. */
  53 #ifndef INT8_MIN
  54 #define INT8_MIN               (-128)
  55 #endif
  56 #ifndef INT16_MIN
  57 #define INT16_MIN              (-32767-1)
  58 #endif
  59 #ifndef INT32_MIN
  60 #define INT32_MIN              (-2147483647-1)
  61 #endif
  62 #ifndef INT8_MAX
  63 #define INT8_MAX               (127)
  64 #endif
  65 #ifndef INT16_MAX
  66 #define INT16_MAX              (32767)
  67 #endif
  68 #ifndef INT32_MAX
  69 #define INT32_MAX              (2147483647)
  70 #endif
  71 #ifndef UINT8_MAX
  72 #define UINT8_MAX              (255U)
  73 #endif
  74 #ifndef UINT16_MAX
  75 #define UINT16_MAX             (65535U)
  76 #endif
  77 #ifndef UINT32_MAX
  78 #define UINT32_MAX             (4294967295U)
  79 #endif
  80
  81 #endif /* ! FLEXINT_H */
  82
  83 #ifdef __cplusplus
  84
  85 /* The "const" storage-class-modifier is valid. */
  86 #define YY_USE_CONST
  87
  88 #else  /* ! __cplusplus */
  89
  90 #if __STDC__
  91
  92 #define YY_USE_CONST
  93
  94 #endif  /* __STDC__ */
  95 #endif  /* ! __cplusplus */
  96
  97 #ifdef YY_USE_CONST
  98 #define yyconst const
  99 #else
 100 #define yyconst
 101 #endif
 102
 103 /* Returned upon end-of-file. */
 104 #define YY_NULL 0
 105
 106 /* Promotes a possibly negative, possibly signed char to an unsigned
 107  * integer for use as an array index.  If the signed char is negative,
 108  * we want to instead treat it as an 8-bit unsigned char, hence the
 109  * double cast.
 110  */
 111 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
 112
 113 /* An opaque pointer. */
 114 #ifndef YY_TYPEDEF_YY_SCANNER_T
 115 #define YY_TYPEDEF_YY_SCANNER_T
 116 typedef void* yyscan_t;
 117 #endif
 118
 119 /* For convenience, these vars (plus the bison vars far below)
 120    are macros in the reentrant scanner. */
 121 #define yyin yyg->yyin_r
 122 #define yyout yyg->yyout_r
 123 #define yyextra yyg->yyextra_r
 124 #define yyleng yyg->yyleng_r
 125 #define yytext yyg->yytext_r
 126 #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
 127 #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
 128 #define yy_flex_debug yyg->yy_flex_debug_r
 129
 130 int cmExpr_yylex_init (yyscan_t* scanner);
 131
 132 /* Enter a start condition.  This macro really ought to take a parameter,
 133  * but we do it the disgusting crufty way forced on us by the ()-less
 134  * definition of BEGIN.
 135  */
 136 #define BEGIN yyg->yy_start = 1 + 2 *
 137
 138 /* Translate the current start state into a value that can be later handed
 139  * to BEGIN to return to the state.  The YYSTATE alias is for lex
 140  * compatibility.
 141  */
 142 #define YY_START ((yyg->yy_start - 1) / 2)
 143 #define YYSTATE YY_START
 144
 145 /* Action number for EOF rule of a given start state. */
 146 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 147
 148 /* Special action meaning "start processing a new file". */
 149 #define YY_NEW_FILE cmExpr_yyrestart(yyin ,yyscanner )
 150
 151 #define YY_END_OF_BUFFER_CHAR 0
 152
 153 /* Size of default input buffer. */
 154 #ifndef YY_BUF_SIZE
 155 #define YY_BUF_SIZE 16384
 156 #endif
 157
 158 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
 159 #define YY_TYPEDEF_YY_BUFFER_STATE
 160 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 161 #endif
 162
 163 #define EOB_ACT_CONTINUE_SCAN 0
 164 #define EOB_ACT_END_OF_FILE 1
 165 #define EOB_ACT_LAST_MATCH 2
 166
 167     #define YY_LESS_LINENO(n)
 168
 169 /* Return all but the first "n" matched characters back to the input
 170    stream. */
 171 #define yyless(n) \
 172   do \
 173     { \
 174     /* Undo effects of setting up yytext. */ \
 175         int yyless_macro_arg = (n); \
 176         YY_LESS_LINENO(yyless_macro_arg);\
 177     *yy_cp = yyg->yy_hold_char; \
 178     YY_RESTORE_YY_MORE_OFFSET \
 179     yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
 180     YY_DO_BEFORE_ACTION; /* set up yytext again */ \
 181     } \
 182   while ( 0 )
 183
 184 /* The following is because we cannot portably get our hands on size_t
 185  * (without autoconf's help, which isn't available because we want
 186  * flex-generated scanners to compile on their own).
 187  */
 188
 189 #ifndef YY_TYPEDEF_YY_SIZE_T
 190 #define YY_TYPEDEF_YY_SIZE_T
 191 typedef unsigned int yy_size_t;
 192 #endif
 193
 194 #ifndef YY_STRUCT_YY_BUFFER_STATE
 195 #define YY_STRUCT_YY_BUFFER_STATE
 196 struct yy_buffer_state
 197   {
 198   FILE *yy_input_file;
 199
 200   char *yy_ch_buf;    /* input buffer */
 201   char *yy_buf_pos;    /* current position in input buffer */
 202
 203   /* Size of input buffer in bytes, not including room for EOB
 204    * characters.
 205    */
 206   yy_size_t yy_buf_size;
 207
 208   /* Number of characters read into yy_ch_buf, not including EOB
 209    * characters.
 210    */
 211   int yy_n_chars;
 212
 213   /* Whether we "own" the buffer - i.e., we know we created it,
 214    * and can realloc() it to grow it, and should free() it to
 215    * delete it.
 216    */
 217   int yy_is_our_buffer;
 218
 219   /* Whether this is an "interactive" input source; if so, and
 220    * if we're using stdio for input, then we want to use getc()
 221    * instead of fread(), to make sure we stop fetching input after
 222    * each newline.
 223    */
 224   int yy_is_interactive;
 225
 226   /* Whether we're considered to be at the beginning of a line.
 227    * If so, '^' rules will be active on the next match, otherwise
 228    * not.
 229    */
 230   int yy_at_bol;
 231
 232     int yy_bs_lineno; /**< The line count. */
 233     int yy_bs_column; /**< The column count. */
 234
 235   /* Whether to try to fill the input buffer when we reach the
 236    * end of it.
 237    */
 238   int yy_fill_buffer;
 239
 240   int yy_buffer_status;
 241
 242 #define YY_BUFFER_NEW 0
 243 #define YY_BUFFER_NORMAL 1
 244   /* When an EOF's been seen but there's still some text to process
 245    * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 246    * shouldn't try reading from the input source any more.  We might
 247    * still have a bunch of tokens to match, though, because of
 248    * possible backing-up.
 249    *
 250    * When we actually see the EOF, we change the status to "new"
 251    * (via cmExpr_yyrestart()), so that the user can continue scanning by
 252    * just pointing yyin at a new input file.
 253    */
 254 #define YY_BUFFER_EOF_PENDING 2
 255
 256   };
 257 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
 258
 259 /* We provide macros for accessing buffer states in case in the
 260  * future we want to put the buffer states in a more general
 261  * "scanner state".
 262  *
 263  * Returns the top of the stack, or NULL.
 264  */
 265 #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
 266                           ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
 267                           : NULL)
 268
 269 /* Same as previous macro, but useful when we know that the buffer stack is
 270  * not NULL or when we need an lvalue. For internal use only.
 271  */
 272 #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
 273
 274 void cmExpr_yyrestart (FILE *input_file ,yyscan_t yyscanner );
 275 void cmExpr_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
 276 YY_BUFFER_STATE cmExpr_yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
 277 void cmExpr_yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
 278 void cmExpr_yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
 279 void cmExpr_yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
 280 void cmExpr_yypop_buffer_state (yyscan_t yyscanner );
 281
 282 static void cmExpr_yyensure_buffer_stack (yyscan_t yyscanner );
 283 static void cmExpr_yy_load_buffer_state (yyscan_t yyscanner );
 284 static void cmExpr_yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
 285
 286 #define YY_FLUSH_BUFFER cmExpr_yy_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
 287
 288 YY_BUFFER_STATE cmExpr_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
 289 YY_BUFFER_STATE cmExpr_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
 290 YY_BUFFER_STATE cmExpr_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
 291
 292 void *cmExpr_yyalloc (yy_size_t ,yyscan_t yyscanner );
 293 void *cmExpr_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
 294 void cmExpr_yyfree (void * ,yyscan_t yyscanner );
 295
 296 #define yy_new_buffer cmExpr_yy_create_buffer
 297
 298 #define yy_set_interactive(is_interactive) \
 299   { \
 300   if ( ! YY_CURRENT_BUFFER ){ \
 301         cmExpr_yyensure_buffer_stack (yyscanner); \
 302     YY_CURRENT_BUFFER_LVALUE =    \
 303             cmExpr_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
 304   } \
 305   YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
 306   }
 307
 308 #define yy_set_bol(at_bol) \
 309   { \
 310   if ( ! YY_CURRENT_BUFFER ){\
 311         cmExpr_yyensure_buffer_stack (yyscanner); \
 312     YY_CURRENT_BUFFER_LVALUE =    \
 313             cmExpr_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
 314   } \
 315   YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
 316   }
 317
 318 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 319
 320 /* Begin user sect3 */
 321
 322 #define cmExpr_yywrap(n) 1
 323 #define YY_SKIP_YYWRAP
 324
 325 typedef unsigned char YY_CHAR;
 326
 327 typedef int yy_state_type;
 328
 329 #define yytext_ptr yytext_r
 330
 331 static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
 332 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  ,
 333                                        yyscan_t yyscanner);
 334 static int yy_get_next_buffer (yyscan_t yyscanner );
 335 static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
 336
 337 /* Done after the current pattern has been matched and before the
 338  * corresponding action - sets up yytext.
 339  */
 340 #define YY_DO_BEFORE_ACTION \
 341   yyg->yytext_ptr = yy_bp; \
 342   yyleng = (size_t) (yy_cp - yy_bp); \
 343   yyg->yy_hold_char = *yy_cp; \
 344   *yy_cp = '\0'; \
 345   yyg->yy_c_buf_p = yy_cp;
 346
 347 #define YY_NUM_RULES 15
 348 #define YY_END_OF_BUFFER 16
 349 /* This struct is not used in this scanner,
 350    but its presence is necessary. */
 351 struct yy_trans_info
 352   {
 353   flex_int32_t yy_verify;
 354   flex_int32_t yy_nxt;
 355   };
 356 static yyconst flex_int16_t yy_accept[23] =
 357     {   0,
 358         0,    0,   16,   15,    6,    8,   13,   14,    4,    2,
 359         3,    5,    1,   15,   15,    9,    7,   10,    1,   11,
 360        12,    0
 361     } ;
 362
 363 static yyconst flex_int32_t yy_ec[256] =
 364     {   0,
 365         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 366         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 367         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 368         1,    1,    1,    1,    1,    1,    2,    3,    1,    4,
 369         5,    6,    7,    1,    8,    1,    9,   10,   10,   10,
 370        10,   10,   10,   10,   10,   10,   10,    1,    1,   11,
 371         1,   12,    1,    1,    1,    1,    1,    1,    1,    1,
 372         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 373         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 374         1,    1,    1,   13,    1,    1,    1,    1,    1,    1,
 375
 376         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 377         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 378         1,    1,    1,   14,    1,   15,    1,    1,    1,    1,
 379         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 380         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 381         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 382         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 383         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 384         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 385         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 386
 387         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 388         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 389         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 390         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 391         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 392         1,    1,    1,    1,    1
 393     } ;
 394
 395 static yyconst flex_int32_t yy_meta[16] =
 396     {   0,
 397         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 398         1,    1,    1,    1,    1
 399     } ;
 400
 401 static yyconst flex_int16_t yy_base[23] =
 402     {   0,
 403         0,    0,   20,   21,   21,   21,   21,   21,   21,   21,
 404        21,   21,    9,    7,    5,   21,   21,   21,    6,   21,
 405        21,   21
 406     } ;
 407
 408 static yyconst flex_int16_t yy_def[23] =
 409     {   0,
 410        22,    1,   22,   22,   22,   22,   22,   22,   22,   22,
 411        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
 412        22,    0
 413     } ;
 414
 415 static yyconst flex_int16_t yy_nxt[37] =
 416     {   0,
 417         4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
 418        14,   15,   16,   17,   18,   19,   21,   20,   19,   22,
 419         3,   22,   22,   22,   22,   22,   22,   22,   22,   22,
 420        22,   22,   22,   22,   22,   22
 421     } ;
 422
 423 static yyconst flex_int16_t yy_chk[37] =
 424     {   0,
 425         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 426         1,    1,    1,    1,    1,   19,   15,   14,   13,    3,
 427        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
 428        22,   22,   22,   22,   22,   22
 429     } ;
 430
 431 /* The intent behind this definition is that it'll catch
 432  * any uses of REJECT which flex missed.
 433  */
 434 #define REJECT reject_used_but_not_detected
 435 #define yymore() yymore_used_but_not_detected
 436 #define YY_MORE_ADJ 0
 437 #define YY_RESTORE_YY_MORE_OFFSET
 438 #line 1 "/home/andy/vtk/CMake/Source/cmExprLexer.in.l"
 439 #line 2 "/home/andy/vtk/CMake/Source/cmExprLexer.in.l"
 440 /*============================================================================
 441   CMake - Cross Platform Makefile Generator
 442   Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
 443
 444   Distributed under the OSI-approved BSD License (the "License");
 445   see accompanying file Copyright.txt for details.
 446
 447   This software is distributed WITHOUT ANY WARRANTY; without even the
 448   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 449   See the License for more information.
 450 ============================================================================*/
 451 /*
 452
 453 This file must be translated to C and modified to build everywhere.
 454
 455 Run flex like this:
 456
 457   flex --prefix=cmExpr_yy --header-file=cmExprLexer.h -ocmExprLexer.cxx cmExprLexer.in.l
 458
 459 Modify cmExprLexer.cxx:
 460   - remove TABs
 461   - remove "yyscanner" argument from these methods:
 462       yy_fatal_error, cmExpr_yyalloc, cmExpr_yyrealloc, cmExpr_yyfree
 463   - remove all YY_BREAK lines occurring right after return statements
 464   - change while ( 1 ) to for(;;)
 465
 466 Modify cmExprLexer.h:
 467   - remove TABs
 468   - remove the yy_init_globals function
 469   - remove the block that includes unistd.h
 470   - remove #line directives (avoids bogus warning on old Sun)
 471
 472 */
 473
 474 #include "cmStandardLexer.h"
 475
 476 #include "cmExprParserHelper.h"
 477
 478 /* Replace the lexer input function.  */
 479 #undef YY_INPUT
 480 #define YY_INPUT(buf, result, max_size) \
 481   { result = yyextra->LexInput(buf, max_size); }
 482
 483 /* Include the set of tokens from the parser.  */
 484 #include "cmExprParserTokens.h"
 485
 486 /*--------------------------------------------------------------------------*/
 487 #line 518 "/home/andy/vtk/CMake-bin/Source/cmExprLexer.cxx"
 488
 489 #define INITIAL 0
 490
 491 #ifndef YY_NO_UNISTD_H
 492 /* Special case for "unistd.h", since it is non-ANSI. We include it way
 493  * down here because we want the user's section 1 to have been scanned first.
 494  * The user has a chance to override it with an option.
 495  */
 496 #include <unistd.h>
 497 #endif
 498
 499 #ifndef YY_EXTRA_TYPE
 500 #define YY_EXTRA_TYPE void *
 501 #endif
 502
 503 /* Holds the entire state of the reentrant scanner. */
 504 struct yyguts_t
 505     {
 506
 507     /* User-defined. Not touched by flex. */
 508     YY_EXTRA_TYPE yyextra_r;
 509
 510     /* The rest are the same as the globals declared in the non-reentrant
 511        scanner. */
 512     FILE *yyin_r, *yyout_r;
 513     size_t yy_buffer_stack_top; /**< index of top of stack. */
 514     size_t yy_buffer_stack_max; /**< capacity of stack. */
 515     YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
 516     char yy_hold_char;
 517     int yy_n_chars;
 518     int yyleng_r;
 519     char *yy_c_buf_p;
 520     int yy_init;
 521     int yy_start;
 522     int yy_did_buffer_switch_on_eof;
 523     int yy_start_stack_ptr;
 524     int yy_start_stack_depth;
 525     int *yy_start_stack;
 526     yy_state_type yy_last_accepting_state;
 527     char* yy_last_accepting_cpos;
 528
 529     int yylineno_r;
 530     int yy_flex_debug_r;
 531
 532     char *yytext_r;
 533     int yy_more_flag;
 534     int yy_more_len;
 535
 536     }; /* end struct yyguts_t */
 537
 538 /* Accessor methods to globals.
 539    These are made visible to non-reentrant scanners for convenience. */
 540
 541 int cmExpr_yylex_destroy (yyscan_t yyscanner );
 542
 543 int cmExpr_yyget_debug (yyscan_t yyscanner );
 544
 545 void cmExpr_yyset_debug (int debug_flag ,yyscan_t yyscanner );
 546
 547 YY_EXTRA_TYPE cmExpr_yyget_extra (yyscan_t yyscanner );
 548
 549 void cmExpr_yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
 550
 551 FILE *cmExpr_yyget_in (yyscan_t yyscanner );
 552
 553 void cmExpr_yyset_in  (FILE * in_str ,yyscan_t yyscanner );
 554
 555 FILE *cmExpr_yyget_out (yyscan_t yyscanner );
 556
 557 void cmExpr_yyset_out  (FILE * out_str ,yyscan_t yyscanner );
 558
 559 int cmExpr_yyget_leng (yyscan_t yyscanner );
 560
 561 char *cmExpr_yyget_text (yyscan_t yyscanner );
 562
 563 int cmExpr_yyget_lineno (yyscan_t yyscanner );
 564
 565 void cmExpr_yyset_lineno (int line_number ,yyscan_t yyscanner );
 566
 567 /* Macros after this point can all be overridden by user definitions in
 568  * section 1.
 569  */
 570
 571 #ifndef YY_SKIP_YYWRAP
 572 #ifdef __cplusplus
 573 extern "C" int cmExpr_yywrap (yyscan_t yyscanner );
 574 #else
 575 extern int cmExpr_yywrap (yyscan_t yyscanner );
 576 #endif
 577 #endif
 578
 579 #ifndef yytext_ptr
 580 static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
 581 #endif
 582
 583 #ifdef YY_NEED_STRLEN
 584 static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
 585 #endif
 586
 587 #ifndef YY_NO_INPUT
 588
 589 #ifdef __cplusplus
 590 static int yyinput (yyscan_t yyscanner );
 591 #else
 592 static int input (yyscan_t yyscanner );
 593 #endif
 594
 595 #endif
 596
 597 /* Amount of stuff to slurp up with each read. */
 598 #ifndef YY_READ_BUF_SIZE
 599 #define YY_READ_BUF_SIZE 8192
 600 #endif
 601
 602 /* Copy whatever the last rule matched to the standard output. */
 603 #ifndef ECHO
 604 /* This used to be an fputs(), but since the string might contain NUL's,
 605  * we now use fwrite().
 606  */
 607 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
 608 #endif
 609
 610 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 611  * is returned in "result".
 612  */
 613 #ifndef YY_INPUT
 614 #define YY_INPUT(buf,result,max_size) \
 615   if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
 616     { \
 617     int c = '*'; \
 618     size_t n; \
 619     for ( n = 0; n < max_size && \
 620            (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
 621       buf[n] = (char) c; \
 622     if ( c == '\n' ) \
 623       buf[n++] = (char) c; \
 624     if ( c == EOF && ferror( yyin ) ) \
 625       YY_FATAL_ERROR( "input in flex scanner failed" ); \
 626     result = n; \
 627     } \
 628   else \
 629     { \
 630     errno=0; \
 631     while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
 632       { \
 633       if( errno != EINTR) \
 634         { \
 635         YY_FATAL_ERROR( "input in flex scanner failed" ); \
 636         break; \
 637         } \
 638       errno=0; \
 639       clearerr(yyin); \
 640       } \
 641     }\
 642 \
 643
 644 #endif
 645
 646 /* No semi-colon after return; correct usage is to write "yyterminate();" -
 647  * we don't want an extra ';' after the "return" because that will cause
 648  * some compilers to complain about unreachable statements.
 649  */
 650 #ifndef yyterminate
 651 #define yyterminate() return YY_NULL
 652 #endif
 653
 654 /* Number of entries by which start-condition stack grows. */
 655 #ifndef YY_START_STACK_INCR
 656 #define YY_START_STACK_INCR 25
 657 #endif
 658
 659 /* Report a fatal error. */
 660 #ifndef YY_FATAL_ERROR
 661 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
 662 #endif
 663
 664 /* end tables serialization structures and prototypes */
 665
 666 /* Default declaration of generated scanner - a define so the user can
 667  * easily add parameters.
 668  */
 669 #ifndef YY_DECL
 670 #define YY_DECL_IS_OURS 1
 671
 672 extern int cmExpr_yylex (yyscan_t yyscanner);
 673
 674 #define YY_DECL int cmExpr_yylex (yyscan_t yyscanner)
 675 #endif /* !YY_DECL */
 676
 677 /* Code executed at the beginning of each rule, after yytext and yyleng
 678  * have been set up.
 679  */
 680 #ifndef YY_USER_ACTION
 681 #define YY_USER_ACTION
 682 #endif
 683
 684 /* Code executed at the end of each rule. */
 685 #ifndef YY_BREAK
 686 #define YY_BREAK break;
 687 #endif
 688
 689 #define YY_RULE_SETUP \
 690   YY_USER_ACTION
 691
 692 /** The main scanner function which does all the work.
 693  */
 694 YY_DECL
 695 {
 696   yy_state_type yy_current_state;
 697   char *yy_cp, *yy_bp;
 698   int yy_act;
 699     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 700
 701 #line 86 "/home/andy/vtk/CMake/Source/cmExprLexer.in.l"
 702
 703
 704 #line 736 "/home/andy/vtk/CMake-bin/Source/cmExprLexer.cxx"
 705
 706   if ( yyg->yy_init )
 707     {
 708     yyg->yy_init = 0;
 709
 710 #ifdef YY_USER_INIT
 711     YY_USER_INIT;
 712 #endif
 713
 714     if ( ! yyg->yy_start )
 715       yyg->yy_start = 1;  /* first start state */
 716
 717     if ( ! yyin )
 718       yyin = stdin;
 719
 720     if ( ! yyout )
 721       yyout = stdout;
 722
 723     if ( ! YY_CURRENT_BUFFER ) {
 724       cmExpr_yyensure_buffer_stack (yyscanner);
 725       YY_CURRENT_BUFFER_LVALUE =
 726         cmExpr_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
 727     }
 728
 729     cmExpr_yy_load_buffer_state(yyscanner );
 730     }
 731
 732   for(;;)    /* loops until end-of-file is reached */
 733     {
 734     yy_cp = yyg->yy_c_buf_p;
 735
 736     /* Support of yytext. */
 737     *yy_cp = yyg->yy_hold_char;
 738
 739     /* yy_bp points to the position in yy_ch_buf of the start of
 740      * the current run.
 741      */
 742     yy_bp = yy_cp;
 743
 744     yy_current_state = yyg->yy_start;
 745 yy_match:
 746     do
 747       {
 748       YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
 749       if ( yy_accept[yy_current_state] )
 750         {
 751         yyg->yy_last_accepting_state = yy_current_state;
 752         yyg->yy_last_accepting_cpos = yy_cp;
 753         }
 754       while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 755         {
 756         yy_current_state = (int) yy_def[yy_current_state];
 757         if ( yy_current_state >= 23 )
 758           yy_c = yy_meta[(unsigned int) yy_c];
 759         }
 760       yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 761       ++yy_cp;
 762       }
 763     while ( yy_base[yy_current_state] != 21 );
 764
 765 yy_find_action:
 766     yy_act = yy_accept[yy_current_state];
 767     if ( yy_act == 0 )
 768       { /* have to back up */
 769       yy_cp = yyg->yy_last_accepting_cpos;
 770       yy_current_state = yyg->yy_last_accepting_state;
 771       yy_act = yy_accept[yy_current_state];
 772       }
 773
 774     YY_DO_BEFORE_ACTION;
 775
 776 do_action:  /* This label is used only to access EOF actions. */
 777
 778     switch ( yy_act )
 779   { /* beginning of action switch */
 780       case 0: /* must back up */
 781       /* undo the effects of YY_DO_BEFORE_ACTION */
 782       *yy_cp = yyg->yy_hold_char;
 783       yy_cp = yyg->yy_last_accepting_cpos;
 784       yy_current_state = yyg->yy_last_accepting_state;
 785       goto yy_find_action;
 786
 787 case 1:
 788 YY_RULE_SETUP
 789 #line 88 "/home/andy/vtk/CMake/Source/cmExprLexer.in.l"
 790 { yylvalp->Number = atoi(yytext); return exp_NUMBER; }
 791 case 2:
 792 YY_RULE_SETUP
 793 #line 90 "/home/andy/vtk/CMake/Source/cmExprLexer.in.l"
 794 { return exp_PLUS; }
 795 case 3:
 796 YY_RULE_SETUP
 797 #line 91 "/home/andy/vtk/CMake/Source/cmExprLexer.in.l"
 798 { return exp_MINUS; }
 799 case 4:
 800 YY_RULE_SETUP
 801 #line 92 "/home/andy/vtk/CMake/Source/cmExprLexer.in.l"
 802 { return exp_TIMES; }
 803 case 5:
 804 YY_RULE_SETUP
 805 #line 93 "/home/andy/vtk/CMake/Source/cmExprLexer.in.l"
 806 { return exp_DIVIDE; }
 807 case 6:
 808 YY_RULE_SETUP
 809 #line 94 "/home/andy/vtk/CMake/Source/cmExprLexer.in.l"
 810 { return exp_MOD; }
 811 case 7:
 812 YY_RULE_SETUP
 813 #line 95 "/home/andy/vtk/CMake/Source/cmExprLexer.in.l"
 814 { return exp_OR; }
 815 case 8:
 816 YY_RULE_SETUP
 817 #line 96 "/home/andy/vtk/CMake/Source/cmExprLexer.in.l"
 818 { return exp_AND; }
 819 case 9:
 820 YY_RULE_SETUP
 821 #line 97 "/home/andy/vtk/CMake/Source/cmExprLexer.in.l"
 822 { return exp_XOR; }
 823 case 10:
 824 YY_RULE_SETUP
 825 #line 98 "/home/andy/vtk/CMake/Source/cmExprLexer.in.l"
 826 { return exp_NOT; }
 827 case 11:
 828 YY_RULE_SETUP
 829 #line 99 "/home/andy/vtk/CMake/Source/cmExprLexer.in.l"
 830 { return exp_SHIFTLEFT; }
 831 case 12:
 832 YY_RULE_SETUP
 833 #line 100 "/home/andy/vtk/CMake/Source/cmExprLexer.in.l"
 834 { return exp_SHIFTRIGHT; }
 835 case 13:
 836 YY_RULE_SETUP
 837 #line 101 "/home/andy/vtk/CMake/Source/cmExprLexer.in.l"
 838 { return exp_OPENPARENT; }
 839 case 14:
 840 YY_RULE_SETUP
 841 #line 102 "/home/andy/vtk/CMake/Source/cmExprLexer.in.l"
 842 { return exp_CLOSEPARENT; }
 843 case 15:
 844 YY_RULE_SETUP
 845 #line 104 "/home/andy/vtk/CMake/Source/cmExprLexer.in.l"
 846 ECHO;
 847   YY_BREAK
 848 #line 894 "/home/andy/vtk/CMake-bin/Source/cmExprLexer.cxx"
 849 case YY_STATE_EOF(INITIAL):
 850   yyterminate();
 851
 852   case YY_END_OF_BUFFER:
 853     {
 854     /* Amount of text matched not including the EOB char. */
 855     int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
 856
 857     /* Undo the effects of YY_DO_BEFORE_ACTION. */
 858     *yy_cp = yyg->yy_hold_char;
 859     YY_RESTORE_YY_MORE_OFFSET
 860
 861     if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
 862       {
 863       /* We're scanning a new file or input source.  It's
 864        * possible that this happened because the user
 865        * just pointed yyin at a new source and called
 866        * cmExpr_yylex().  If so, then we have to assure
 867        * consistency between YY_CURRENT_BUFFER and our
 868        * globals.  Here is the right place to do so, because
 869        * this is the first action (other than possibly a
 870        * back-up) that will match for the new input source.
 871        */
 872       yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
 873       YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
 874       YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
 875       }
 876
 877     /* Note that here we test for yy_c_buf_p "<=" to the position
 878      * of the first EOB in the buffer, since yy_c_buf_p will
 879      * already have been incremented past the NUL character
 880      * (since all states make transitions on EOB to the
 881      * end-of-buffer state).  Contrast this with the test
 882      * in input().
 883      */
 884     if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
 885       { /* This was really a NUL. */
 886       yy_state_type yy_next_state;
 887
 888       yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
 889
 890       yy_current_state = yy_get_previous_state( yyscanner );
 891
 892       /* Okay, we're now positioned to make the NUL
 893        * transition.  We couldn't have
 894        * yy_get_previous_state() go ahead and do it
 895        * for us because it doesn't know how to deal
 896        * with the possibility of jamming (and we don't
 897        * want to build jamming into it because then it
 898        * will run more slowly).
 899        */
 900
 901       yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
 902
 903       yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
 904
 905       if ( yy_next_state )
 906         {
 907         /* Consume the NUL. */
 908         yy_cp = ++yyg->yy_c_buf_p;
 909         yy_current_state = yy_next_state;
 910         goto yy_match;
 911         }
 912
 913       else
 914         {
 915         yy_cp = yyg->yy_c_buf_p;
 916         goto yy_find_action;
 917         }
 918       }
 919
 920     else switch ( yy_get_next_buffer( yyscanner ) )
 921       {
 922       case EOB_ACT_END_OF_FILE:
 923         {
 924         yyg->yy_did_buffer_switch_on_eof = 0;
 925
 926         if ( cmExpr_yywrap(yyscanner ) )
 927           {
 928           /* Note: because we've taken care in
 929            * yy_get_next_buffer() to have set up
 930            * yytext, we can now set up
 931            * yy_c_buf_p so that if some total
 932            * hoser (like flex itself) wants to
 933            * call the scanner after we return the
 934            * YY_NULL, it'll still work - another
 935            * YY_NULL will get returned.
 936            */
 937           yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
 938
 939           yy_act = YY_STATE_EOF(YY_START);
 940           goto do_action;
 941           }
 942
 943         else
 944           {
 945           if ( ! yyg->yy_did_buffer_switch_on_eof )
 946             YY_NEW_FILE;
 947           }
 948         break;
 949         }
 950
 951       case EOB_ACT_CONTINUE_SCAN:
 952         yyg->yy_c_buf_p =
 953           yyg->yytext_ptr + yy_amount_of_matched_text;
 954
 955         yy_current_state = yy_get_previous_state( yyscanner );
 956
 957         yy_cp = yyg->yy_c_buf_p;
 958         yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
 959         goto yy_match;
 960
 961       case EOB_ACT_LAST_MATCH:
 962         yyg->yy_c_buf_p =
 963         &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
 964
 965         yy_current_state = yy_get_previous_state( yyscanner );
 966
 967         yy_cp = yyg->yy_c_buf_p;
 968         yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
 969         goto yy_find_action;
 970       }
 971     break;
 972     }
 973
 974   default:
 975     YY_FATAL_ERROR(
 976       "fatal flex scanner internal error--no action found" );
 977   } /* end of action switch */
 978     } /* end of scanning one token */
 979 return 0; /* this should not happen but it silences a warning*/
 980 } /* end of cmExpr_yylex */
 981
 982 /* yy_get_next_buffer - try to read in a new buffer
 983  *
 984  * Returns a code representing an action:
 985  *  EOB_ACT_LAST_MATCH -
 986  *  EOB_ACT_CONTINUE_SCAN - continue scanning from current position
 987  *  EOB_ACT_END_OF_FILE - end of file
 988  */
 989 static int yy_get_next_buffer (yyscan_t yyscanner)
 990 {
 991     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 992   char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
 993   char *source = yyg->yytext_ptr;
 994   int number_to_move, i;
 995   int ret_val;
 996
 997   if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
 998     YY_FATAL_ERROR(
 999     "fatal flex scanner internal error--end of buffer missed" );
1000
1001   if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1002     { /* Don't try to fill the buffer, so this is an EOF. */
1003     if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
1004       {
1005       /* We matched a single character, the EOB, so
1006        * treat this as a final EOF.
1007        */
1008       return EOB_ACT_END_OF_FILE;
1009       }
1010
1011     else
1012       {
1013       /* We matched some text prior to the EOB, first
1014        * process it.
1015        */
1016       return EOB_ACT_LAST_MATCH;
1017       }
1018     }
1019
1020   /* Try to read more data. */
1021
1022   /* First move last chars to start of buffer. */
1023   number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
1024
1025   for ( i = 0; i < number_to_move; ++i )
1026     *(dest++) = *(source++);
1027
1028   if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1029     /* don't do the read, it's not guaranteed to return an EOF,
1030      * just force an EOF
1031      */
1032     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
1033
1034   else
1035     {
1036       size_t nuto_read =
1037       YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1038
1039     while ( nuto_read <= 0 )
1040       { /* Not enough room in the buffer - grow it. */
1041
1042       /* just a shorter name for the current buffer */
1043       YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1044
1045       int yy_c_buf_p_offset =
1046         (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1047
1048       if ( b->yy_is_our_buffer )
1049         {
1050         int new_size = b->yy_buf_size * 2;
1051
1052         if ( new_size <= 0 )
1053           b->yy_buf_size += b->yy_buf_size / 8;
1054         else
1055           b->yy_buf_size *= 2;
1056
1057         b->yy_ch_buf = (char *)
1058           /* Include room in for 2 EOB chars. */
1059           cmExpr_yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
1060         }
1061       else
1062         /* Can't grow it, we don't own it. */
1063         b->yy_ch_buf = 0;
1064
1065       if ( ! b->yy_ch_buf )
1066         YY_FATAL_ERROR(
1067         "fatal error - scanner input buffer overflow" );
1068
1069       yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1070
1071       nuto_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1072             number_to_move - 1;
1073
1074       }
1075
1076     if ( nuto_read > YY_READ_BUF_SIZE )
1077       nuto_read = YY_READ_BUF_SIZE;
1078
1079     /* Read in more data. */
1080     YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1081       yyg->yy_n_chars, nuto_read );
1082
1083     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1084     }
1085
1086   if ( yyg->yy_n_chars == 0 )
1087     {
1088     if ( number_to_move == YY_MORE_ADJ )
1089       {
1090       ret_val = EOB_ACT_END_OF_FILE;
1091       cmExpr_yyrestart(yyin  ,yyscanner);
1092       }
1093
1094     else
1095       {
1096       ret_val = EOB_ACT_LAST_MATCH;
1097       YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1098         YY_BUFFER_EOF_PENDING;
1099       }
1100     }
1101
1102   else
1103     ret_val = EOB_ACT_CONTINUE_SCAN;
1104
1105   yyg->yy_n_chars += number_to_move;
1106   YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1107   YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1108
1109   yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1110
1111   return ret_val;
1112 }
1113
1114 /* yy_get_previous_state - get the state just before the EOB char was
1115    reached */
1116
1117     static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
1118 {
1119   yy_state_type yy_current_state;
1120   char *yy_cp;
1121     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1122
1123   yy_current_state = yyg->yy_start;
1124
1125   for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
1126     {
1127     YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1128     if ( yy_accept[yy_current_state] )
1129       {
1130       yyg->yy_last_accepting_state = yy_current_state;
1131       yyg->yy_last_accepting_cpos = yy_cp;
1132       }
1133     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1134       {
1135       yy_current_state = (int) yy_def[yy_current_state];
1136       if ( yy_current_state >= 23 )
1137         yy_c = yy_meta[(unsigned int) yy_c];
1138       }
1139     yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1140     }
1141
1142   return yy_current_state;
1143 }
1144
1145 /* yy_try_NUL_trans - try to make a transition on the NUL character
1146  *
1147  * synopsis
1148  *  next_state = yy_try_NUL_trans( current_state );
1149  */
1150     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
1151 {
1152   int yy_is_jam;
1153     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1154   char *yy_cp = yyg->yy_c_buf_p;
1155
1156   YY_CHAR yy_c = 1;
1157   if ( yy_accept[yy_current_state] )
1158     {
1159     yyg->yy_last_accepting_state = yy_current_state;
1160     yyg->yy_last_accepting_cpos = yy_cp;
1161     }
1162   while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1163     {
1164     yy_current_state = (int) yy_def[yy_current_state];
1165     if ( yy_current_state >= 23 )
1166       yy_c = yy_meta[(unsigned int) yy_c];
1167     }
1168   yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1169   yy_is_jam = (yy_current_state == 22);
1170
1171   return yy_is_jam ? 0 : yy_current_state;
1172 }
1173
1174 #ifndef YY_NO_INPUT
1175 #ifdef __cplusplus
1176     static int yyinput (yyscan_t yyscanner)
1177 #else
1178     static int input  (yyscan_t yyscanner)
1179 #endif
1180
1181 {
1182   int c;
1183     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1184
1185   *yyg->yy_c_buf_p = yyg->yy_hold_char;
1186
1187   if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1188     {
1189     /* yy_c_buf_p now points to the character we want to return.
1190      * If this occurs *before* the EOB characters, then it's a
1191      * valid NUL; if not, then we've hit the end of the buffer.
1192      */
1193     if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1194       /* This was really a NUL. */
1195       *yyg->yy_c_buf_p = '\0';
1196
1197     else
1198       { /* need more input */
1199       int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
1200       ++yyg->yy_c_buf_p;
1201
1202       switch ( yy_get_next_buffer( yyscanner ) )
1203         {
1204         case EOB_ACT_LAST_MATCH:
1205           /* This happens because yy_g_n_b()
1206            * sees that we've accumulated a
1207            * token and flags that we need to
1208            * try matching the token before
1209            * proceeding.  But for input(),
1210            * there's no matching to consider.
1211            * So convert the EOB_ACT_LAST_MATCH
1212            * to EOB_ACT_END_OF_FILE.
1213            */
1214
1215           /* Reset buffer status. */
1216           cmExpr_yyrestart(yyin ,yyscanner);
1217
1218           /*FALLTHROUGH*/
1219
1220         case EOB_ACT_END_OF_FILE:
1221           {
1222           if ( cmExpr_yywrap(yyscanner ) )
1223             return EOF;
1224
1225           if ( ! yyg->yy_did_buffer_switch_on_eof )
1226             YY_NEW_FILE;
1227 #ifdef __cplusplus
1228           return yyinput(yyscanner);
1229 #else
1230           return input(yyscanner);
1231 #endif
1232           }
1233
1234         case EOB_ACT_CONTINUE_SCAN:
1235           yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
1236           break;
1237         }
1238       }
1239     }
1240
1241   c = *(unsigned char *) yyg->yy_c_buf_p;  /* cast for 8-bit char's */
1242   *yyg->yy_c_buf_p = '\0';  /* preserve yytext */
1243   yyg->yy_hold_char = *++yyg->yy_c_buf_p;
1244
1245   return c;
1246 }
1247 #endif  /* ifndef YY_NO_INPUT */
1248
1249 /** Immediately switch to a different input stream.
1250  * @param input_file A readable stream.
1251  * @param yyscanner The scanner object.
1252  * @note This function does not reset the start condition to @c INITIAL .
1253  */
1254     void cmExpr_yyrestart  (FILE * input_file , yyscan_t yyscanner)
1255 {
1256     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1257
1258   if ( ! YY_CURRENT_BUFFER ){
1259         cmExpr_yyensure_buffer_stack (yyscanner);
1260     YY_CURRENT_BUFFER_LVALUE =
1261             cmExpr_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
1262   }
1263
1264   cmExpr_yy_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
1265   cmExpr_yy_load_buffer_state(yyscanner );
1266 }
1267
1268 /** Switch to a different input buffer.
1269  * @param new_buffer The new input buffer.
1270  * @param yyscanner The scanner object.
1271  */
1272     void cmExpr_yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
1273 {
1274     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1275
1276   /* TODO. We should be able to replace this entire function body
1277    * with
1278    *    cmExpr_yypop_buffer_state();
1279    *    cmExpr_yypush_buffer_state(new_buffer);
1280      */
1281   cmExpr_yyensure_buffer_stack (yyscanner);
1282   if ( YY_CURRENT_BUFFER == new_buffer )
1283     return;
1284
1285   if ( YY_CURRENT_BUFFER )
1286     {
1287     /* Flush out information for old buffer. */
1288     *yyg->yy_c_buf_p = yyg->yy_hold_char;
1289     YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1290     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1291     }
1292
1293   YY_CURRENT_BUFFER_LVALUE = new_buffer;
1294   cmExpr_yy_load_buffer_state(yyscanner );
1295
1296   /* We don't actually know whether we did this switch during
1297    * EOF (cmExpr_yywrap()) processing, but the only time this flag
1298    * is looked at is after cmExpr_yywrap() is called, so it's safe
1299    * to go ahead and always set it.
1300    */
1301   yyg->yy_did_buffer_switch_on_eof = 1;
1302 }
1303
1304 static void cmExpr_yy_load_buffer_state  (yyscan_t yyscanner)
1305 {
1306     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1307   yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1308   yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1309   yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1310   yyg->yy_hold_char = *yyg->yy_c_buf_p;
1311 }
1312
1313 /** Allocate and initialize an input buffer state.
1314  * @param file A readable stream.
1315  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1316  * @param yyscanner The scanner object.
1317  * @return the allocated buffer state.
1318  */
1319     YY_BUFFER_STATE cmExpr_yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
1320 {
1321   YY_BUFFER_STATE b;
1322
1323   b = (YY_BUFFER_STATE) cmExpr_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
1324   if ( ! b )
1325     YY_FATAL_ERROR( "out of dynamic memory in cmExpr_yy_create_buffer()" );
1326
1327   b->yy_buf_size = size;
1328
1329   /* yy_ch_buf has to be 2 characters longer than the size given because
1330    * we need to put in 2 end-of-buffer characters.
1331    */
1332   b->yy_ch_buf = (char *) cmExpr_yyalloc(b->yy_buf_size + 2 ,yyscanner );
1333   if ( ! b->yy_ch_buf )
1334     YY_FATAL_ERROR( "out of dynamic memory in cmExpr_yy_create_buffer()" );
1335
1336   b->yy_is_our_buffer = 1;
1337
1338   cmExpr_yy_init_buffer(b,file ,yyscanner);
1339
1340   return b;
1341 }
1342
1343 /** Destroy the buffer.
1344  * @param b a buffer created with cmExpr_yy_create_buffer()
1345  * @param yyscanner The scanner object.
1346  */
1347     void cmExpr_yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
1348 {
1349     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1350
1351   if ( ! b )
1352     return;
1353
1354   if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1355     YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1356
1357   if ( b->yy_is_our_buffer )
1358     cmExpr_yyfree((void *) b->yy_ch_buf ,yyscanner );
1359
1360   cmExpr_yyfree((void *) b ,yyscanner );
1361 }
1362
1363 #ifndef __cplusplus
1364 extern int isatty (int );
1365 #endif /* __cplusplus */
1366
1367 /* Initializes or reinitializes a buffer.
1368  * This function is sometimes called more than once on the same buffer,
1369  * such as during a cmExpr_yyrestart() or at EOF.
1370  */
1371     static void cmExpr_yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)
1372
1373 {
1374   int oerrno = errno;
1375     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1376
1377   cmExpr_yy_flush_buffer(b ,yyscanner);
1378
1379   b->yy_input_file = file;
1380   b->yy_fill_buffer = 1;
1381
1382     /* If b is the current buffer, then cmExpr_yy_init_buffer was _probably_
1383      * called from cmExpr_yyrestart() or through yy_get_next_buffer.
1384      * In that case, we don't want to reset the lineno or column.
1385      */
1386     if (b != YY_CURRENT_BUFFER){
1387         b->yy_bs_lineno = 1;
1388         b->yy_bs_column = 0;
1389     }
1390
1391         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1392
1393   errno = oerrno;
1394 }
1395
1396 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1397  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1398  * @param yyscanner The scanner object.
1399  */
1400     void cmExpr_yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
1401 {
1402     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1403   if ( ! b )
1404     return;
1405
1406   b->yy_n_chars = 0;
1407
1408   /* We always need two end-of-buffer characters.  The first causes
1409    * a transition to the end-of-buffer state.  The second causes
1410    * a jam in that state.
1411    */
1412   b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1413   b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1414
1415   b->yy_buf_pos = &b->yy_ch_buf[0];
1416
1417   b->yy_at_bol = 1;
1418   b->yy_buffer_status = YY_BUFFER_NEW;
1419
1420   if ( b == YY_CURRENT_BUFFER )
1421     cmExpr_yy_load_buffer_state(yyscanner );
1422 }
1423
1424 /** Pushes the new state onto the stack. The new state becomes
1425  *  the current state. This function will allocate the stack
1426  *  if necessary.
1427  *  @param new_buffer The new state.
1428  *  @param yyscanner The scanner object.
1429  */
1430 void cmExpr_yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1431 {
1432     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1433   if (new_buffer == NULL)
1434     return;
1435
1436   cmExpr_yyensure_buffer_stack(yyscanner);
1437
1438   /* This block is copied from cmExpr_yy_switch_to_buffer. */
1439   if ( YY_CURRENT_BUFFER )
1440     {
1441     /* Flush out information for old buffer. */
1442     *yyg->yy_c_buf_p = yyg->yy_hold_char;
1443     YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1444     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1445     }
1446
1447   /* Only push if top exists. Otherwise, replace top. */
1448   if (YY_CURRENT_BUFFER)
1449     yyg->yy_buffer_stack_top++;
1450   YY_CURRENT_BUFFER_LVALUE = new_buffer;
1451
1452   /* copied from cmExpr_yy_switch_to_buffer. */
1453   cmExpr_yy_load_buffer_state(yyscanner );
1454   yyg->yy_did_buffer_switch_on_eof = 1;
1455 }
1456
1457 /** Removes and deletes the top of the stack, if present.
1458  *  The next element becomes the new top.
1459  *  @param yyscanner The scanner object.
1460  */
1461 void cmExpr_yypop_buffer_state (yyscan_t yyscanner)
1462 {
1463     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1464   if (!YY_CURRENT_BUFFER)
1465     return;
1466
1467   cmExpr_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
1468   YY_CURRENT_BUFFER_LVALUE = NULL;
1469   if (yyg->yy_buffer_stack_top > 0)
1470     --yyg->yy_buffer_stack_top;
1471
1472   if (YY_CURRENT_BUFFER) {
1473     cmExpr_yy_load_buffer_state(yyscanner );
1474     yyg->yy_did_buffer_switch_on_eof = 1;
1475   }
1476 }
1477
1478 /* Allocates the stack if it does not exist.
1479  *  Guarantees space for at least one push.
1480  */
1481 static void cmExpr_yyensure_buffer_stack (yyscan_t yyscanner)
1482 {
1483   int nuto_alloc;
1484     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1485
1486   if (!yyg->yy_buffer_stack) {
1487
1488     /* First allocation is just for 2 elements, since we don't know if this
1489      * scanner will even need a stack. We use 2 instead of 1 to avoid an
1490      * immediate realloc on the next call.
1491          */
1492     nuto_alloc = 1;
1493     yyg->yy_buffer_stack = (struct yy_buffer_state**)cmExpr_yyalloc
1494                 (nuto_alloc * sizeof(struct yy_buffer_state*)
1495                 , yyscanner);
1496
1497     memset(yyg->yy_buffer_stack, 0, nuto_alloc * sizeof(struct yy_buffer_state*));
1498
1499     yyg->yy_buffer_stack_max = nuto_alloc;
1500     yyg->yy_buffer_stack_top = 0;
1501     return;
1502   }
1503
1504   if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
1505
1506     /* Increase the buffer to prepare for a possible push. */
1507     int grow_size = 8 /* arbitrary grow size */;
1508
1509     nuto_alloc = yyg->yy_buffer_stack_max + grow_size;
1510     yyg->yy_buffer_stack = (struct yy_buffer_state**)cmExpr_yyrealloc
1511                 (yyg->yy_buffer_stack,
1512                 nuto_alloc * sizeof(struct yy_buffer_state*)
1513                 , yyscanner);
1514
1515     /* zero only the new slots.*/
1516     memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
1517     yyg->yy_buffer_stack_max = nuto_alloc;
1518   }
1519 }
1520
1521 /** Setup the input buffer state to scan directly from a user-specified character buffer.
1522  * @param base the character buffer
1523  * @param size the size in bytes of the character buffer
1524  * @param yyscanner The scanner object.
1525  * @return the newly allocated buffer state object.
1526  */
1527 YY_BUFFER_STATE cmExpr_yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
1528 {
1529   YY_BUFFER_STATE b;
1530
1531   if ( size < 2 ||
1532        base[size-2] != YY_END_OF_BUFFER_CHAR ||
1533        base[size-1] != YY_END_OF_BUFFER_CHAR )
1534     /* They forgot to leave room for the EOB's. */
1535     return 0;
1536
1537   b = (YY_BUFFER_STATE) cmExpr_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
1538   if ( ! b )
1539     YY_FATAL_ERROR( "out of dynamic memory in cmExpr_yy_scan_buffer()" );
1540
1541   b->yy_buf_size = size - 2;  /* "- 2" to take care of EOB's */
1542   b->yy_buf_pos = b->yy_ch_buf = base;
1543   b->yy_is_our_buffer = 0;
1544   b->yy_input_file = 0;
1545   b->yy_n_chars = b->yy_buf_size;
1546   b->yy_is_interactive = 0;
1547   b->yy_at_bol = 1;
1548   b->yy_fill_buffer = 0;
1549   b->yy_buffer_status = YY_BUFFER_NEW;
1550
1551   cmExpr_yy_switch_to_buffer(b ,yyscanner );
1552
1553   return b;
1554 }
1555
1556 /** Setup the input buffer state to scan a string. The next call to cmExpr_yylex() will
1557  * scan from a @e copy of @a yy_str.
1558  * @param yy_str a NUL-terminated string to scan
1559  * @param yyscanner The scanner object.
1560  * @return the newly allocated buffer state object.
1561  * @note If you want to scan bytes that may contain NUL values, then use
1562  *       cmExpr_yy_scan_bytes() instead.
1563  */
1564 YY_BUFFER_STATE cmExpr_yy_scan_string (yyconst char * yy_str , yyscan_t yyscanner)
1565 {
1566
1567   return cmExpr_yy_scan_bytes(yy_str,strlen(yy_str) ,yyscanner);
1568 }
1569
1570 /** Setup the input buffer state to scan the given bytes. The next call to cmExpr_yylex() will
1571  * scan from a @e copy of @a bytes.
1572  * @param bytes the byte buffer to scan
1573  * @param len the number of bytes in the buffer pointed to by @a bytes.
1574  * @param yyscanner The scanner object.
1575  * @return the newly allocated buffer state object.
1576  */
1577 YY_BUFFER_STATE cmExpr_yy_scan_bytes  (yyconst char * bytes, int  len , yyscan_t yyscanner)
1578 {
1579   YY_BUFFER_STATE b;
1580   char *buf;
1581   yy_size_t n;
1582   int i;
1583
1584   /* Get memory for full buffer, including space for trailing EOB's. */
1585   n = len + 2;
1586   buf = (char *) cmExpr_yyalloc(n ,yyscanner );
1587   if ( ! buf )
1588     YY_FATAL_ERROR( "out of dynamic memory in cmExpr_yy_scan_bytes()" );
1589
1590   for ( i = 0; i < len; ++i )
1591     buf[i] = bytes[i];
1592
1593   buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1594
1595   b = cmExpr_yy_scan_buffer(buf,n ,yyscanner);
1596   if ( ! b )
1597     YY_FATAL_ERROR( "bad buffer in cmExpr_yy_scan_bytes()" );
1598
1599   /* It's okay to grow etc. this buffer, and we should throw it
1600    * away when we're done.
1601    */
1602   b->yy_is_our_buffer = 1;
1603
1604   return b;
1605 }
1606
1607 #ifndef YY_EXIT_FAILURE
1608 #define YY_EXIT_FAILURE 2
1609 #endif
1610
1611 static void yy_fatal_error (yyconst char* msg , yyscan_t)
1612 {
1613       (void) fprintf( stderr, "%s\n", msg );
1614   exit( YY_EXIT_FAILURE );
1615 }
1616
1617 /* Redefine yyless() so it works in section 3 code. */
1618
1619 #undef yyless
1620 #define yyless(n) \
1621   do \
1622     { \
1623     /* Undo effects of setting up yytext. */ \
1624         int yyless_macro_arg = (n); \
1625         YY_LESS_LINENO(yyless_macro_arg);\
1626     yytext[yyleng] = yyg->yy_hold_char; \
1627     yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
1628     yyg->yy_hold_char = *yyg->yy_c_buf_p; \
1629     *yyg->yy_c_buf_p = '\0'; \
1630     yyleng = yyless_macro_arg; \
1631     } \
1632   while ( 0 )
1633
1634 /* Accessor  methods (get/set functions) to struct members. */
1635
1636 /** Get the user-defined data for this scanner.
1637  * @param yyscanner The scanner object.
1638  */
1639 YY_EXTRA_TYPE cmExpr_yyget_extra  (yyscan_t yyscanner)
1640 {
1641     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1642     return yyextra;
1643 }
1644
1645 /** Get the current line number.
1646  * @param yyscanner The scanner object.
1647  */
1648 int cmExpr_yyget_lineno  (yyscan_t yyscanner)
1649 {
1650     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1651
1652         if (! YY_CURRENT_BUFFER)
1653             return 0;
1654
1655     return yylineno;
1656 }
1657
1658 /** Get the current column number.
1659  * @param yyscanner The scanner object.
1660  */
1661 int cmExpr_yyget_column  (yyscan_t yyscanner)
1662 {
1663     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1664
1665         if (! YY_CURRENT_BUFFER)
1666             return 0;
1667
1668     return yycolumn;
1669 }
1670
1671 /** Get the input stream.
1672  * @param yyscanner The scanner object.
1673  */
1674 FILE *cmExpr_yyget_in  (yyscan_t yyscanner)
1675 {
1676     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1677     return yyin;
1678 }
1679
1680 /** Get the output stream.
1681  * @param yyscanner The scanner object.
1682  */
1683 FILE *cmExpr_yyget_out  (yyscan_t yyscanner)
1684 {
1685     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1686     return yyout;
1687 }
1688
1689 /** Get the length of the current token.
1690  * @param yyscanner The scanner object.
1691  */
1692 int cmExpr_yyget_leng  (yyscan_t yyscanner)
1693 {
1694     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1695     return yyleng;
1696 }
1697
1698 /** Get the current token.
1699  * @param yyscanner The scanner object.
1700  */
1701
1702 char *cmExpr_yyget_text  (yyscan_t yyscanner)
1703 {
1704     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1705     return yytext;
1706 }
1707
1708 /** Set the user-defined data. This data is never touched by the scanner.
1709  * @param user_defined The data to be associated with this scanner.
1710  * @param yyscanner The scanner object.
1711  */
1712 void cmExpr_yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
1713 {
1714     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1715     yyextra = user_defined ;
1716 }
1717
1718 /** Set the current line number.
1719  * @param line_number
1720  * @param yyscanner The scanner object.
1721  */
1722 void cmExpr_yyset_lineno (int  line_number , yyscan_t yyscanner)
1723 {
1724     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1725
1726         /* lineno is only valid if an input buffer exists. */
1727         if (! YY_CURRENT_BUFFER )
1728            yy_fatal_error( "cmExpr_yyset_lineno called with no buffer" , yyscanner);
1729
1730     yylineno = line_number;
1731 }
1732
1733 /** Set the current column.
1734  * @param column_no
1735  * @param yyscanner The scanner object.
1736  */
1737 void cmExpr_yyset_column (int  column_no , yyscan_t yyscanner)
1738 {
1739     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1740
1741         /* column is only valid if an input buffer exists. */
1742         if (! YY_CURRENT_BUFFER )
1743            yy_fatal_error( "cmExpr_yyset_column called with no buffer" , yyscanner);
1744
1745     yycolumn = column_no;
1746 }
1747
1748 /** Set the input stream. This does not discard the current
1749  * input buffer.
1750  * @param in_str A readable stream.
1751  * @param yyscanner The scanner object.
1752  * @see cmExpr_yy_switch_to_buffer
1753  */
1754 void cmExpr_yyset_in (FILE *  in_str , yyscan_t yyscanner)
1755 {
1756     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1757     yyin = in_str ;
1758 }
1759
1760 void cmExpr_yyset_out (FILE *  out_str , yyscan_t yyscanner)
1761 {
1762     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1763     yyout = out_str ;
1764 }
1765
1766 int cmExpr_yyget_debug  (yyscan_t yyscanner)
1767 {
1768     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1769     return yy_flex_debug;
1770 }
1771
1772 void cmExpr_yyset_debug (int  bdebug , yyscan_t yyscanner)
1773 {
1774     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1775     yy_flex_debug = bdebug ;
1776 }
1777
1778 /* Accessor methods for yylval and yylloc */
1779
1780 static int yy_init_globals (yyscan_t yyscanner)
1781 {
1782     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1783     /* Initialization is the same as for the non-reentrant scanner.
1784        This function is called once per scanner lifetime. */
1785
1786     yyg->yy_buffer_stack = 0;
1787     yyg->yy_buffer_stack_top = 0;
1788     yyg->yy_buffer_stack_max = 0;
1789     yyg->yy_c_buf_p = (char *) 0;
1790     yyg->yy_init = 1;
1791     yyg->yy_start = 0;
1792     yyg->yy_start_stack_ptr = 0;
1793     yyg->yy_start_stack_depth = 0;
1794     yyg->yy_start_stack = (int *) 0;
1795
1796 /* Defined in main.c */
1797 #ifdef YY_STDINIT
1798     yyin = stdin;
1799     yyout = stdout;
1800 #else
1801     yyin = (FILE *) 0;
1802     yyout = (FILE *) 0;
1803 #endif
1804
1805     /* For future reference: Set errno on error, since we are called by
1806      * cmExpr_yylex_init()
1807      */
1808     return 0;
1809 }
1810
1811 /* User-visible API */
1812
1813 /* cmExpr_yylex_init is special because it creates the scanner itself, so it is
1814  * the ONLY reentrant function that doesn't take the scanner as the last argument.
1815  * That's why we explicitly handle the declaration, instead of using our macros.
1816  */
1817
1818 int cmExpr_yylex_init(yyscan_t* ptr_yy_globals)
1819
1820 {
1821     if (ptr_yy_globals == NULL){
1822         errno = EINVAL;
1823         return 1;
1824     }
1825
1826     *ptr_yy_globals = (yyscan_t) cmExpr_yyalloc ( sizeof( struct yyguts_t ), NULL );
1827
1828     if (*ptr_yy_globals == NULL){
1829         errno = ENOMEM;
1830         return 1;
1831     }
1832
1833     memset(*ptr_yy_globals,0,sizeof(struct yyguts_t));
1834
1835     return yy_init_globals ( *ptr_yy_globals );
1836 }
1837
1838 /* cmExpr_yylex_destroy is for both reentrant and non-reentrant scanners. */
1839 int cmExpr_yylex_destroy  (yyscan_t yyscanner)
1840 {
1841     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1842
1843     /* Pop the buffer stack, destroying each element. */
1844   while(YY_CURRENT_BUFFER){
1845     cmExpr_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
1846     YY_CURRENT_BUFFER_LVALUE = NULL;
1847     cmExpr_yypop_buffer_state(yyscanner);
1848   }
1849
1850   /* Destroy the stack itself. */
1851   cmExpr_yyfree(yyg->yy_buffer_stack ,yyscanner);
1852   yyg->yy_buffer_stack = NULL;
1853
1854     /* Destroy the start condition stack. */
1855         cmExpr_yyfree(yyg->yy_start_stack ,yyscanner );
1856         yyg->yy_start_stack = NULL;
1857
1858     /* Destroy the main struct (reentrant only). */
1859     cmExpr_yyfree ( yyscanner , yyscanner );
1860     return 0;
1861 }
1862
1863 /*
1864  * Internal utility routines.
1865  */
1866
1867 #ifndef yytext_ptr
1868 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
1869 {
1870   int i;
1871     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1872   for ( i = 0; i < n; ++i )
1873     s1[i] = s2[i];
1874 }
1875 #endif
1876
1877 #ifdef YY_NEED_STRLEN
1878 static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
1879 {
1880   int n;
1881     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1882   for ( n = 0; s[n]; ++n )
1883     ;
1884
1885   return n;
1886 }
1887 #endif
1888
1889 void *cmExpr_yyalloc (yy_size_t  size , yyscan_t)
1890 {
1891   return (void *) malloc( size );
1892 }
1893
1894 void *cmExpr_yyrealloc  (void * ptr, yy_size_t  size , yyscan_t)
1895 {
1896   /* The cast to (char *) in the following accommodates both
1897    * implementations that use char* generic pointers, and those
1898    * that use void* generic pointers.  It works with the latter
1899    * because both ANSI C and C++ allow castless assignment from
1900    * any pointer type to void*, and deal with argument conversions
1901    * as though doing an assignment.
1902    */
1903   return (void *) realloc( (char *) ptr, size );
1904 }
1905
1906 void cmExpr_yyfree (void * ptr , yyscan_t)
1907 {
1908   free( (char *) ptr );  /* see cmExpr_yyrealloc() for (char *) cast */
1909 }
1910
1911 #define YYTABLES_NAME "yytables"
1912
1913 #undef YY_NEW_FILE
1914 #undef YY_FLUSH_BUFFER
1915 #undef yy_set_bol
1916 #undef yy_new_buffer
1917 #undef yy_set_interactive
1918 #undef yytext_ptr
1919 #undef YY_DO_BEFORE_ACTION
1920
1921 #ifdef YY_DECL_IS_OURS
1922 #undef YY_DECL_IS_OURS
1923 #undef YY_DECL
1924 #endif
1925 #line 104 "/home/andy/vtk/CMake/Source/cmExprLexer.in.l"
1926
1927
1928