src/ParaView/lex.yy.c

   1
   2 #line 3 "lex.yy.c"
   3
   4 #define  YY_INT_ALIGNED short int
   5
   6 /* A lexical scanner generated by flex */
   7
   8 #define FLEX_SCANNER
   9 #define YY_FLEX_MAJOR_VERSION 2
  10 #define YY_FLEX_MINOR_VERSION 5
  11 #define YY_FLEX_SUBMINOR_VERSION 35
  12 #if YY_FLEX_SUBMINOR_VERSION > 0
  13 #define FLEX_BETA
  14 #endif
  15
  16 /* First, we deal with  platform-specific or compiler-specific issues. */
  17
  18 /* begin standard C headers. */
  19 #include <stdio.h>
  20 #include <string.h>
  21 #include <errno.h>
  22 #include <stdlib.h>
  23
  24 /* end standard C headers. */
  25
  26 /* flex integer type definitions */
  27
  28 #ifndef FLEXINT_H
  29 #define FLEXINT_H
  30
  31 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
  32
  33 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
  34
  35 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
  36  * if you want the limit (max/min) macros for int types.
  37  */
  38 #ifndef __STDC_LIMIT_MACROS
  39 #define __STDC_LIMIT_MACROS 1
  40 #endif
  41
  42 #include <inttypes.h>
  43 typedef int8_t flex_int8_t;
  44 typedef uint8_t flex_uint8_t;
  45 typedef int16_t flex_int16_t;
  46 typedef uint16_t flex_uint16_t;
  47 typedef int32_t flex_int32_t;
  48 typedef uint32_t flex_uint32_t;
  49 #else
  50 typedef signed char flex_int8_t;
  51 typedef short int flex_int16_t;
  52 typedef int flex_int32_t;
  53 typedef unsigned char flex_uint8_t;
  54 typedef unsigned short int flex_uint16_t;
  55 typedef unsigned int flex_uint32_t;
  56
  57 /* Limits of integral types. */
  58 #ifndef INT8_MIN
  59 #define INT8_MIN               (-128)
  60 #endif
  61 #ifndef INT16_MIN
  62 #define INT16_MIN              (-32767-1)
  63 #endif
  64 #ifndef INT32_MIN
  65 #define INT32_MIN              (-2147483647-1)
  66 #endif
  67 #ifndef INT8_MAX
  68 #define INT8_MAX               (127)
  69 #endif
  70 #ifndef INT16_MAX
  71 #define INT16_MAX              (32767)
  72 #endif
  73 #ifndef INT32_MAX
  74 #define INT32_MAX              (2147483647)
  75 #endif
  76 #ifndef UINT8_MAX
  77 #define UINT8_MAX              (255U)
  78 #endif
  79 #ifndef UINT16_MAX
  80 #define UINT16_MAX             (65535U)
  81 #endif
  82 #ifndef UINT32_MAX
  83 #define UINT32_MAX             (4294967295U)
  84 #endif
  85
  86 #endif /* ! C99 */
  87
  88 #endif /* ! FLEXINT_H */
  89
  90 #ifdef __cplusplus
  91
  92 /* The "const" storage-class-modifier is valid. */
  93 #define YY_USE_CONST
  94
  95 #else  /* ! __cplusplus */
  96
  97 /* C99 requires __STDC__ to be defined as 1. */
  98 #if defined (__STDC__)
  99
 100 #define YY_USE_CONST
 101
 102 #endif  /* defined (__STDC__) */
 103 #endif  /* ! __cplusplus */
 104
 105 #ifdef YY_USE_CONST
 106 #define yyconst const
 107 #else
 108 #define yyconst
 109 #endif
 110
 111 /* Returned upon end-of-file. */
 112 #define YY_NULL 0
 113
 114 /* Promotes a possibly negative, possibly signed char to an unsigned
 115  * integer for use as an array index.  If the signed char is negative,
 116  * we want to instead treat it as an 8-bit unsigned char, hence the
 117  * double cast.
 118  */
 119 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
 120
 121 /* Enter a start condition.  This macro really ought to take a parameter,
 122  * but we do it the disgusting crufty way forced on us by the ()-less
 123  * definition of BEGIN.
 124  */
 125 #define BEGIN (yy_start) = 1 + 2 *
 126
 127 /* Translate the current start state into a value that can be later handed
 128  * to BEGIN to return to the state.  The YYSTATE alias is for lex
 129  * compatibility.
 130  */
 131 #define YY_START (((yy_start) - 1) / 2)
 132 #define YYSTATE YY_START
 133
 134 /* Action number for EOF rule of a given start state. */
 135 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 136
 137 /* Special action meaning "start processing a new file". */
 138 #define YY_NEW_FILE yyrestart(yyin  )
 139
 140 #define YY_END_OF_BUFFER_CHAR 0
 141
 142 /* Size of default input buffer. */
 143 #ifndef YY_BUF_SIZE
 144 #ifdef __ia64__
 145 /* On IA-64, the buffer size is 16k, not 8k.
 146  * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
 147  * Ditto for the __ia64__ case accordingly.
 148  */
 149 #define YY_BUF_SIZE 32768
 150 #else
 151 #define YY_BUF_SIZE 16384
 152 #endif /* __ia64__ */
 153 #endif
 154
 155 /* The state buf must be large enough to hold one state per character in the main buffer.
 156  */
 157 #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
 158
 159 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
 160 #define YY_TYPEDEF_YY_BUFFER_STATE
 161 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 162 #endif
 163
 164 extern int yyleng;
 165
 166 extern FILE *yyin, *yyout;
 167
 168 #define EOB_ACT_CONTINUE_SCAN 0
 169 #define EOB_ACT_END_OF_FILE 1
 170 #define EOB_ACT_LAST_MATCH 2
 171
 172     /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
 173      *       access to the local variable yy_act. Since yyless() is a macro, it would break
 174      *       existing scanners that call yyless() from OUTSIDE yylex.
 175      *       One obvious solution it to make yy_act a global. I tried that, and saw
 176      *       a 5% performance hit in a non-yylineno scanner, because yy_act is
 177      *       normally declared as a register variable-- so it is not worth it.
 178      */
 179     #define  YY_LESS_LINENO(n) \
 180             do { \
 181                 int yyl;\
 182                 for ( yyl = n; yyl < yyleng; ++yyl )\
 183                     if ( yytext[yyl] == '\n' )\
 184                         --yylineno;\
 185             }while(0)
 186
 187 /* Return all but the first "n" matched characters back to the input stream. */
 188 #define yyless(n) \
 189   do \
 190     { \
 191     /* Undo effects of setting up yytext. */ \
 192         int yyless_macro_arg = (n); \
 193         YY_LESS_LINENO(yyless_macro_arg);\
 194     *yy_cp = (yy_hold_char); \
 195     YY_RESTORE_YY_MORE_OFFSET \
 196     (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
 197     YY_DO_BEFORE_ACTION; /* set up yytext again */ \
 198     } \
 199   while ( 0 )
 200
 201 #ifndef YY_TYPEDEF_YY_SIZE_T
 202 #define YY_TYPEDEF_YY_SIZE_T
 203 typedef size_t yy_size_t;
 204 #endif
 205
 206 #ifndef YY_STRUCT_YY_BUFFER_STATE
 207 #define YY_STRUCT_YY_BUFFER_STATE
 208 struct yy_buffer_state
 209   {
 210   FILE *yy_input_file;
 211
 212   char *yy_ch_buf;    /* input buffer */
 213   char *yy_buf_pos;    /* current position in input buffer */
 214
 215   /* Size of input buffer in bytes, not including room for EOB
 216    * characters.
 217    */
 218   yy_size_t yy_buf_size;
 219
 220   /* Number of characters read into yy_ch_buf, not including EOB
 221    * characters.
 222    */
 223   size_t yy_n_chars;
 224
 225   /* Whether we "own" the buffer - i.e., we know we created it,
 226    * and can realloc() it to grow it, and should free() it to
 227    * delete it.
 228    */
 229   int yy_is_our_buffer;
 230
 231   /* Whether this is an "interactive" input source; if so, and
 232    * if we're using stdio for input, then we want to use getc()
 233    * instead of fread(), to make sure we stop fetching input after
 234    * each newline.
 235    */
 236   int yy_is_interactive;
 237
 238   /* Whether we're considered to be at the beginning of a line.
 239    * If so, '^' rules will be active on the next match, otherwise
 240    * not.
 241    */
 242   int yy_at_bol;
 243
 244     int yy_bs_lineno; /**< The line count. */
 245     int yy_bs_column; /**< The column count. */
 246
 247   /* Whether to try to fill the input buffer when we reach the
 248    * end of it.
 249    */
 250   int yy_fill_buffer;
 251
 252   int yy_buffer_status;
 253
 254 #define YY_BUFFER_NEW 0
 255 #define YY_BUFFER_NORMAL 1
 256   /* When an EOF's been seen but there's still some text to process
 257    * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 258    * shouldn't try reading from the input source any more.  We might
 259    * still have a bunch of tokens to match, though, because of
 260    * possible backing-up.
 261    *
 262    * When we actually see the EOF, we change the status to "new"
 263    * (via yyrestart()), so that the user can continue scanning by
 264    * just pointing yyin at a new input file.
 265    */
 266 #define YY_BUFFER_EOF_PENDING 2
 267
 268   };
 269 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
 270
 271 /* Stack of input buffers. */
 272 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
 273 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
 274 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
 275
 276 /* We provide macros for accessing buffer states in case in the
 277  * future we want to put the buffer states in a more general
 278  * "scanner state".
 279  *
 280  * Returns the top of the stack, or NULL.
 281  */
 282 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
 283                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
 284                           : NULL)
 285
 286 /* Same as previous macro, but useful when we know that the buffer stack is not
 287  * NULL or when we need an lvalue. For internal use only.
 288  */
 289 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
 290
 291 /* yy_hold_char holds the character lost when yytext is formed. */
 292 static char yy_hold_char;
 293 static size_t yy_n_chars;    /* number of characters read into yy_ch_buf */
 294 int yyleng;
 295
 296 /* Points to current character in buffer. */
 297 static char *yy_c_buf_p = (char *) 0;
 298 static int yy_init = 0;    /* whether we need to initialize */
 299 static int yy_start = 0;  /* start state number */
 300
 301 /* Flag which is used to allow yywrap()'s to do buffer switches
 302  * instead of setting up a fresh yyin.  A bit of a hack ...
 303  */
 304 static int yy_did_buffer_switch_on_eof;
 305
 306 void yyrestart (FILE *input_file  );
 307 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
 308 YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
 309 void yy_delete_buffer (YY_BUFFER_STATE b  );
 310 void yy_flush_buffer (YY_BUFFER_STATE b  );
 311 void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
 312 void yypop_buffer_state (void );
 313
 314 static void yyensure_buffer_stack (void );
 315 static void yy_load_buffer_state (void );
 316 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
 317
 318 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
 319
 320 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
 321 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
 322 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );
 323
 324 void *yyalloc (yy_size_t  );
 325 void *yyrealloc (void *,yy_size_t  );
 326 void yyfree (void *  );
 327
 328 #define yy_new_buffer yy_create_buffer
 329
 330 #define yy_set_interactive(is_interactive) \
 331   { \
 332   if ( ! YY_CURRENT_BUFFER ){ \
 333         yyensure_buffer_stack (); \
 334     YY_CURRENT_BUFFER_LVALUE =    \
 335             yy_create_buffer(yyin,YY_BUF_SIZE ); \
 336   } \
 337   YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
 338   }
 339
 340 #define yy_set_bol(at_bol) \
 341   { \
 342   if ( ! YY_CURRENT_BUFFER ){\
 343         yyensure_buffer_stack (); \
 344     YY_CURRENT_BUFFER_LVALUE =    \
 345             yy_create_buffer(yyin,YY_BUF_SIZE ); \
 346   } \
 347   YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
 348   }
 349
 350 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 351
 352 /* Begin user sect3 */
 353
 354 typedef unsigned char YY_CHAR;
 355
 356 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
 357
 358 typedef int yy_state_type;
 359
 360 extern int yylineno;
 361
 362 int yylineno = 1;
 363
 364 extern char *yytext;
 365 #define yytext_ptr yytext
 366
 367 static yy_state_type yy_get_previous_state (void );
 368 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
 369 static int yy_get_next_buffer (void );
 370 static void yy_fatal_error (yyconst char msg[]  );
 371
 372 /* Done after the current pattern has been matched and before the
 373  * corresponding action - sets up yytext.
 374  */
 375 #define YY_DO_BEFORE_ACTION \
 376   (yytext_ptr) = yy_bp; \
 377   yyleng = (size_t) (yy_cp - yy_bp); \
 378   (yy_hold_char) = *yy_cp; \
 379   *yy_cp = '\0'; \
 380   (yy_c_buf_p) = yy_cp;
 381
 382 #define YY_NUM_RULES 94
 383 #define YY_END_OF_BUFFER 95
 384 /* This struct is not used in this scanner,
 385    but its presence is necessary. */
 386 struct yy_trans_info
 387   {
 388   flex_int32_t yy_verify;
 389   flex_int32_t yy_nxt;
 390   };
 391 static yyconst flex_int16_t yy_accept[772] =
 392     {   0,
 393         0,    0,   95,   93,   89,   89,   93,   92,   93,   84,
 394        88,   88,   90,   91,   88,   88,   88,   88,   88,   88,
 395        88,   88,   88,   88,   88,   88,   89,    9,    9,   93,
 396        93,    0,    1,   11,   84,    0,    0,   88,   88,   88,
 397         0,    0,   88,   88,   88,   88,   88,   88,   88,   88,
 398        88,   88,   88,   88,   88,   88,   88,   88,   88,   88,
 399        88,   88,   88,    0,    9,    0,    0,   86,   10,   85,
 400        11,    0,   88,    0,    0,   14,   88,   88,   88,   88,
 401        88,   88,   88,   88,   88,   30,   88,   88,   88,   88,
 402        88,   88,   88,   88,   88,   88,   88,   87,   10,   10,
 403
 404        10,   10,    0,   88,   88,   88,   37,   36,   88,   88,
 405        88,   88,   88,    0,   88,   88,   33,   88,   88,   88,
 406        88,   88,   88,   88,   88,   88,   35,   87,   87,   87,
 407        87,   87,   87,   87,   87,   87,   87,   87,   87,   10,
 408        10,   10,   10,   10,   10,    0,   88,   88,   88,   88,
 409        26,   39,   88,   31,   88,    0,    0,   88,   88,    0,
 410        88,   88,   88,   88,   88,   88,   32,   88,   88,   88,
 411        88,    0,    0,   87,   87,   87,   87,   87,   87,   87,
 412        87,   87,   87,   87,   87,   10,   10,   10,   10,   10,
 413        10,   10,    0,   88,   88,   88,   88,    0,   34,   42,
 414
 415         0,    0,   88,   88,    0,    0,   88,   88,   88,   88,
 416        88,   27,    0,   88,   88,   43,   88,   88,    0,    0,
 417        87,   87,   87,   87,   87,   87,   87,   87,   87,   87,
 418        87,   87,   10,   10,   10,   10,   10,   10,   10,   10,
 419         2,    0,   88,   88,   12,   24,    0,    0,    0,    0,
 420        20,   88,    0,    0,   18,   88,   88,   28,   88,    0,
 421        88,    0,   88,   88,   38,    0,    0,    0,   87,   87,
 422        87,   87,   87,   87,   87,   87,   87,   87,   87,   87,
 423        87,   87,   87,   87,   87,   87,   87,   87,   10,   10,
 424        10,   10,   10,   10,   10,   12,   88,   88,    0,   20,
 425
 426         0,    0,   88,   19,   18,    0,   21,   40,   88,    0,
 427        17,    0,   88,   41,    0,    0,   87,   87,   87,   87,
 428        87,   87,   87,   87,   87,   87,   87,   87,   87,   87,
 429        87,   87,   87,   87,   87,   87,   87,   87,   87,   87,
 430        10,   10,   10,    3,   10,   10,   88,   88,    0,    0,
 431        19,   88,   21,    0,   88,   29,   17,    0,   88,    0,
 432         0,   87,   87,   87,   87,   87,   87,   87,   45,   87,
 433        87,   87,   87,   87,   87,   87,   87,   87,   87,   87,
 434        87,   87,   87,   87,   87,    3,   10,   10,    3,   10,
 435        10,   72,   88,    0,    0,   15,    0,   88,    0,   88,
 436
 437         0,   25,    0,   87,   87,   87,   87,   87,   87,   87,
 438        87,   87,   87,   87,   87,   87,   87,   87,   87,   87,
 439        87,   87,   87,   87,   87,   12,    3,   10,   10,   10,
 440        10,   88,    0,   22,    0,   23,   25,    0,   87,   87,
 441        87,   48,   87,   87,   87,    0,    0,   87,   47,   87,
 442        87,   87,   87,   87,   87,   87,   87,   87,   74,   87,
 443        87,   87,   87,   87,   10,   10,   10,   10,   88,   22,
 444        23,    0,   87,   87,   87,   87,   87,   87,    0,   13,
 445        87,   87,   87,   87,   87,   46,   87,   76,   78,   80,
 446        70,   87,   87,   87,   87,   75,   87,   87,   10,   10,
 447
 448        10,   10,   88,    0,    0,   87,   87,   87,   87,   87,
 449        87,   87,   87,   87,   87,   87,   87,   87,   87,   87,
 450        87,   87,   87,   87,   87,   87,   87,   77,   79,   81,
 451        87,   87,   10,   10,   10,   10,   10,   10,   10,   88,
 452         0,   16,   87,   87,   87,   87,   87,   87,   87,   87,
 453        87,   87,   87,   87,   87,   87,   87,   87,   87,   87,
 454        87,   82,   83,   87,   87,   87,   10,   10,   10,   10,
 455        10,   10,   10,   10,   10,   10,   73,   55,   87,   87,
 456        87,   87,   87,   87,   87,   87,   87,   87,   87,   87,
 457        87,   87,   87,   87,   87,   87,   87,   87,   87,   10,
 458
 459        10,   10,   10,   10,   10,   10,   10,   10,    8,   87,
 460        87,   87,   87,   87,   87,   87,   87,   87,   87,   51,
 461        87,   87,   87,   87,   87,   87,   87,   87,   87,   87,
 462        87,   10,   10,   10,   10,    8,   10,   10,   10,   10,
 463         8,   87,   87,   87,   54,   50,   87,   87,   87,   87,
 464        65,   52,   87,   49,   87,   87,   87,   87,   64,   87,
 465        87,   87,   10,   10,   10,   10,    8,   10,   10,   10,
 466        10,   87,   87,   87,   60,   61,   62,   63,   87,   56,
 467        57,   58,   59,   87,   87,   87,   10,   10,   10,   10,
 468        10,   10,   10,   10,   87,   87,   87,   87,   87,   87,
 469
 470        87,   10,   10,   10,   10,    7,   10,   10,   10,   68,
 471        87,   44,   87,   71,   87,   87,    7,   10,   10,   10,
 472         7,   10,    5,    6,   87,   87,   87,   87,    7,   10,
 473         5,    6,   10,    5,    6,   87,   87,   87,   87,   10,
 474         5,    6,   10,   87,   87,   87,   67,   10,    4,   87,
 475        87,   87,    4,    4,   87,   87,   87,    4,   87,   87,
 476        66,   87,   87,   69,   87,   87,   87,   87,   87,   53,
 477         0
 478     } ;
 479
 480 static yyconst flex_int32_t yy_ec[256] =
 481     {   0,
 482         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 483         1,    1,    4,    1,    1,    1,    1,    1,    1,    1,
 484         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 485         1,    5,    1,    6,    7,    1,    1,    8,    1,    9,
 486        10,   11,    1,    8,    8,   12,   13,   14,   15,   16,
 487        17,   18,   19,   20,   19,   21,   19,   22,   23,    1,
 488         8,    1,    1,    1,   24,   25,   26,   27,   28,   29,
 489        30,   31,   32,   31,   33,   34,   35,   36,   37,   38,
 490        31,   39,   40,   41,   42,   43,   44,   45,   46,   31,
 491        47,    1,   48,    1,   49,    1,   50,   51,   52,   53,
 492
 493        54,   55,   56,   57,   58,   59,   60,   61,   62,   63,
 494        64,   65,   31,   66,   67,   68,   69,   70,   71,   72,
 495        73,   31,    8,    1,    8,    8,    1,    1,    1,    1,
 496         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 497         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 498         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 499         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 500         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 501         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 502         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 503
 504         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 505         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 506         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 507         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 508         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 509         1,    1,    1,    1,    1
 510     } ;
 511
 512 static yyconst flex_int32_t yy_meta[74] =
 513     {   0,
 514         1,    2,    3,    2,    2,    4,    1,    1,    1,    5,
 515         1,    1,    1,    6,    7,    7,    7,    7,    7,    7,
 516         7,    1,    8,    9,    9,    9,    9,    9,    9,    9,
 517         9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
 518         9,    9,    9,    9,    9,    9,    1,   10,    9,    9,
 519         9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
 520         9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
 521         9,    9,    9
 522     } ;
 523
 524 static yyconst flex_int16_t yy_base[799] =
 525     {   0,
 526         0,   72, 1713, 1714, 1714, 1714,    0, 1714,   67,   72,
 527      1663,   53,   79, 1714,   67,   47,   48,   49,   54,   51,
 528        55,   52,   57,   50,   61,   73,  125, 1714, 1714, 1708,
 529       121, 1704, 1714,    0,  128, 1660,  105, 1659,  107,  103,
 530       155,  159,  106,  122,   76,  116,  118,   90,  120,  121,
 531       123,  124,  125,  129,  126,  142,  130,  146,  137,  133,
 532       147,  148,  149,  212, 1714, 1694, 1703, 1714,  194, 1714,
 533         0,  156, 1656,  218,  224, 1714,  186,  155,  181,  182,
 534       183,  184,  159,  162,  185,  241,  191,  187,  188,  189,
 535       200,  203,  192,  205,  207,  210,  211,  284,  257,    0,
 536
 537       256, 1663,  225,  242,  230,  226, 1654, 1653,  222,  228,
 538       231,  232,  235,  301,  246,  236,  327,  238,  268,  272,
 539       285,  270,  286,  287,  266,  288,  344, 1652,  290,  292,
 540       250,  301,  248,  295,  302,  293,  303,  309,  332,    0,
 541       351, 1659,  329, 1645, 1653,  330,  343,  333,  335,  355,
 542       372, 1648,  337, 1647,  334, 1631, 1637,  331,  341,  393,
 543       340,  350,  351,  352,  357,  358,  413,  359,  373,  364,
 544       374,  426,  434,  362,  258,  383,  384,  393,  391,  392,
 545       395,  400,  401,  397,  408,  428, 1639, 1647, 1667, 1662,
 546      1622, 1685,  417,  428,  437,  426,  425,  476, 1638, 1637,
 547
 548      1622, 1620,  420,  421, 1620, 1618,  423,  433,  424,  435,
 549       434, 1632,  490,  436,  501, 1631,  458,  448,  511,  515,
 550       449,  459,  451,  489,  462,  479,  517,  487,  485,  484,
 551       481,  502, 1655, 1650, 1610, 1673, 1640, 1648, 1621, 1669,
 552      1714,  496,  520,  509, 1622, 1621,  559, 1601, 1612, 1601,
 553       569,  500, 1598, 1602, 1615,  521,  510, 1614,  526, 1599,
 554       516,  583,  532,  529, 1612,  588,  592,  600,  557,  534,
 555       558,  559,  563,  564,  566,  568,  567,  518,  572,  574,
 556       570,  578,  582,  579,  609,  588,  590,  603, 1625, 1633,
 557      1606, 1654, 1628, 1614, 1588, 1604,  616, 1603, 1591,  652,
 558
 559      1582,  657,  600, 1600, 1714, 1592,  665, 1598,  622, 1578,
 560      1596, 1587,  623, 1594,  674,  682,  631,  614,  639,  640,
 561       482,  625,  641,  596,  645,  646,  649,  651,  653,  654,
 562       655,  656,  660,  662,  666,  663,  687,  675,  680,  688,
 563      1614, 1600, 1574,    0, 1607, 1580,  682,  698,  730, 1573,
 564      1714,  681,  738,  746,  696, 1587, 1714, 1585,  689,  758,
 565      1570,  705,  715,  707,  708,  717,  709,  697, 1584,  723,
 566       724,  726,  728,  729,  730,  731,  732,  736,  735,  742,
 567       738,  744,  740,  746,  756,    0, 1600, 1573,    0, 1593,
 568      1564, 1579,  753,  809,  813, 1714, 1564,  770, 1563,  752,
 569
 570      1559, 1575, 1565,  774,  772,  773,  775,  778,  782,  784,
 571       829,  786,  788,  791,  792,  793,  795,  797,  800,  846,
 572       798,  804,  805,  806,  808, 1573,    0, 1584, 1555, 1583,
 573      1550,  827, 1561, 1567, 1547, 1565, 1714, 1560,  820,  830,
 574       837, 1563,  828,  831,  832,  879, 1601,  848, 1561,  833,
 575       836,  843,  840,  844,  842,  874,  886,  885, 1560,  855,
 576       858,  894,  879,  863, 1572, 1539, 1601, 1547,  888, 1714,
 577      1714,  928,  868,  869,  872,  873,  878,  928, 1594, 1714,
 578       891,  889,  898,  915,  935, 1554,  937, 1553, 1552, 1551,
 579      1550,  900,  936,  910,  942, 1549,  916,  913, 1592, 1538,
 580
 581       941, 1531,  930,  971,  985,  923,  929,  934,  947,  949,
 582       958,  965,  966,  967,  954,  957,  961,  968,  963,  970,
 583       983,  986,  987,  974, 1009, 1008,  978, 1545, 1544, 1543,
 584       979,  980, 1004, 1527, 1540, 1535, 1534, 1533, 1523,  997,
 585      1045, 1714,  985,  991,  988, 1004, 1010, 1011, 1014, 1016,
 586      1018, 1020, 1021, 1024, 1025, 1026, 1031, 1033, 1035, 1039,
 587      1041, 1536, 1535, 1028, 1037, 1043, 1533, 1528, 1527, 1526,
 588      1516, 1508, 1510, 1522, 1521, 1552, 1524, 1523, 1059, 1046,
 589      1047, 1050, 1048, 1052, 1053, 1058, 1060,  990, 1062, 1086,
 590      1066, 1068, 1069, 1070, 1075, 1074, 1090, 1080, 1081, 1501,
 591
 592      1503, 1515, 1514, 1545, 1512, 1513, 1559, 1558,    0, 1087,
 593      1089, 1093, 1092, 1095, 1096, 1097, 1098, 1099, 1102, 1513,
 594      1103, 1104, 1105, 1106, 1108, 1109, 1111, 1112, 1100, 1121,
 595      1122, 1507, 1508, 1554, 1553,    0, 1507, 1490, 1531, 1504,
 596         0, 1129, 1124, 1131, 1497, 1487, 1133, 1134, 1135, 1136,
 597      1477, 1467, 1137, 1457, 1138, 1139, 1143, 1144, 1447, 1160,
 598      1142, 1147, 1436, 1410, 1442, 1406,    0, 1368, 1371, 1367,
 599      1357, 1161, 1162, 1164, 1355, 1351, 1331, 1327, 1165, 1317,
 600      1313, 1312, 1309, 1166, 1167, 1184, 1289, 1289, 1272, 1271,
 601      1264, 1262, 1256, 1247, 1172, 1173, 1169, 1175, 1177, 1176,
 602
 603      1181, 1242, 1243, 1239, 1238,    0, 1235, 1238, 1236, 1249,
 604      1188, 1248, 1185, 1247, 1193, 1186,    0, 1224, 1198, 1131,
 605         0, 1131,    0,    0, 1196, 1199, 1214, 1201,    0,  994,
 606         0,    0,  977,    0,    0, 1202, 1217, 1206, 1204,  907,
 607         0,    0,  603, 1222, 1210, 1220,  550,  427,    0, 1224,
 608      1221, 1209,    0,    0, 1227, 1228, 1229,    0, 1215, 1234,
 609       353, 1235, 1236,  154, 1252, 1239, 1242, 1241, 1246,  127,
 610      1714, 1310, 1315, 1319, 1327, 1334, 1344, 1353, 1363, 1368,
 611      1377, 1387, 1396, 1405, 1415, 1424, 1433, 1443, 1453, 1463,
 612      1473, 1483, 1493, 1503, 1513, 1523, 1533, 1543
 613
 614     } ;
 615
 616 static yyconst flex_int16_t yy_def[799] =
 617     {   0,
 618       771,    1,  771,  771,  771,  771,  772,  771,  771,  773,
 619       774,  774,  775,  771,  774,  774,  774,  774,  774,  774,
 620       774,  774,  774,  774,  774,  774,  771,  771,  771,  776,
 621       771,  772,  771,  777,  773,  773,  773,  774,  774,  774,
 622       775,  778,  774,  774,  774,  774,  774,  774,  774,  774,
 623       774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
 624       774,  774,  774,  771,  771,  771,  776,  771,  779,  771,
 625       777,  773,  774,  771,  778,  771,  774,  774,  774,  774,
 626       774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
 627       774,  774,  774,  774,  774,  774,  774,  780,  781,  779,
 628
 629       779,  779,  773,  774,  774,  774,  774,  774,  774,  774,
 630       774,  774,  774,  771,  774,  774,  774,  774,  774,  774,
 631       774,  774,  774,  774,  774,  774,  774,  780,  780,  780,
 632       780,  780,  780,  780,  780,  780,  780,  780,  780,  781,
 633       781,  781,  779,  779,  779,  773,  774,  774,  774,  774,
 634       774,  774,  774,  774,  774,  771,  771,  774,  774,  771,
 635       774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
 636       774,  771,  771,  780,  780,  780,  780,  780,  780,  780,
 637       780,  780,  780,  780,  780,  781,  781,  781,  779,  779,
 638       779,  782,  773,  774,  774,  774,  774,  771,  774,  774,
 639
 640       771,  771,  774,  774,  771,  771,  774,  774,  774,  774,
 641       774,  774,  771,  774,  774,  774,  774,  774,  771,  783,
 642       780,  780,  780,  780,  780,  780,  780,  780,  780,  780,
 643       780,  780,  781,  781,  781,  784,  779,  779,  779,  782,
 644       771,  773,  774,  774,  774,  774,  771,  771,  771,  771,
 645       774,  774,  771,  771,  774,  774,  774,  774,  774,  771,
 646       774,  771,  774,  774,  774,  771,  771,  783,  780,  780,
 647       780,  780,  780,  780,  780,  780,  780,  780,  780,  780,
 648       780,  780,  780,  780,  780,  780,  780,  780,  781,  781,
 649       781,  784,  779,  779,  779,  773,  774,  774,  771,  771,
 650
 651       771,  771,  774,  774,  771,  771,  774,  774,  774,  771,
 652       774,  771,  774,  774,  771,  771,  780,  780,  780,  780,
 653       780,  780,  780,  780,  780,  780,  780,  780,  780,  780,
 654       780,  780,  780,  780,  780,  780,  780,  780,  780,  780,
 655       781,  781,  781,  785,  779,  779,  774,  774,  786,  771,
 656       771,  774,  771,  771,  774,  774,  771,  771,  774,  771,
 657       771,  780,  780,  780,  780,  780,  780,  780,  780,  780,
 658       780,  780,  780,  780,  780,  780,  780,  780,  780,  780,
 659       780,  780,  780,  780,  780,  787,  781,  781,  785,  779,
 660       779,  774,  774,  771,  786,  771,  771,  774,  771,  774,
 661
 662       771,  774,  771,  780,  780,  780,  780,  780,  780,  780,
 663       780,  780,  780,  780,  780,  780,  780,  780,  780,  780,
 664       780,  780,  780,  780,  780,  780,  787,  781,  781,  779,
 665       779,  774,  771,  774,  771,  774,  771,  771,  780,  780,
 666       780,  780,  780,  780,  780,  771,  788,  780,  780,  780,
 667       780,  780,  780,  780,  780,  780,  780,  780,  780,  780,
 668       780,  780,  780,  780,  781,  781,  779,  779,  774,  771,
 669       771,  771,  780,  780,  780,  780,  780,  780,  788,  771,
 670       780,  780,  780,  780,  780,  780,  780,  780,  780,  780,
 671       780,  780,  780,  780,  780,  780,  780,  780,  781,  781,
 672
 673       779,  779,  774,  771,  771,  780,  780,  780,  780,  780,
 674       780,  780,  780,  780,  780,  780,  780,  780,  780,  780,
 675       780,  780,  780,  780,  780,  780,  780,  780,  780,  780,
 676       780,  780,  781,  781,  779,  779,  779,  779,  779,  774,
 677       771,  771,  780,  780,  780,  780,  780,  780,  780,  780,
 678       780,  780,  780,  780,  780,  780,  780,  780,  780,  780,
 679       780,  780,  780,  780,  780,  780,  781,  781,  781,  781,
 680       781,  779,  779,  779,  779,  779,  774,  780,  780,  780,
 681       780,  780,  780,  780,  780,  780,  780,  780,  780,  780,
 682       780,  780,  780,  780,  780,  780,  780,  780,  780,  781,
 683
 684       781,  781,  781,  781,  779,  779,  779,  779,  789,  780,
 685       780,  780,  780,  780,  780,  780,  780,  780,  780,  780,
 686       780,  780,  780,  780,  780,  780,  780,  780,  780,  780,
 687       780,  781,  781,  781,  781,  790,  779,  779,  779,  779,
 688       789,  780,  780,  780,  780,  780,  780,  780,  780,  780,
 689       780,  780,  780,  780,  780,  780,  780,  780,  780,  780,
 690       780,  780,  781,  781,  781,  781,  790,  779,  779,  779,
 691       779,  780,  780,  780,  780,  780,  780,  780,  780,  780,
 692       780,  780,  780,  780,  780,  780,  781,  781,  781,  781,
 693       779,  779,  779,  779,  780,  780,  780,  780,  780,  780,
 694
 695       780,  781,  781,  781,  781,  791,  779,  779,  779,  780,
 696       780,  780,  780,  780,  780,  780,  792,  781,  781,  781,
 697       791,  779,  793,  794,  780,  780,  780,  780,  792,  781,
 698       795,  796,  779,  793,  794,  780,  780,  780,  780,  781,
 699       795,  796,  779,  780,  780,  780,  780,  781,  797,  780,
 700       780,  780,  798,  797,  780,  780,  780,  798,  780,  780,
 701       780,  780,  780,  780,  780,  780,  780,  780,  780,  780,
 702         0,  771,  771,  771,  771,  771,  771,  771,  771,  771,
 703       771,  771,  771,  771,  771,  771,  771,  771,  771,  771,
 704       771,  771,  771,  771,  771,  771,  771,  771
 705
 706     } ;
 707
 708 static yyconst flex_int16_t yy_nxt[1788] =
 709     {   0,
 710         4,    5,    6,    5,    5,    7,    4,    8,    8,    8,
 711         8,    8,    9,   10,   10,   10,   10,   10,   10,   10,
 712        10,    8,    8,   11,   11,   11,   11,   11,   11,   11,
 713        11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
 714        11,   11,   12,   11,   11,   11,   13,   14,   15,   11,
 715        16,   17,   18,   11,   19,   11,   11,   20,   11,   11,
 716        21,   11,   11,   22,   23,   11,   24,   11,   25,   26,
 717        11,   11,   11,   27,   28,   29,   27,   33,   30,   34,
 718        41,   41,   41,   41,   31,   35,   35,   35,   35,   35,
 719        35,   35,   35,   40,   43,   39,   39,   39,   39,   39,
 720
 721        39,   39,   39,   39,   46,   39,   57,   58,   47,   39,
 722        45,   48,   49,   52,   50,   44,   54,   59,   53,   51,
 723        37,   39,   55,   60,   39,   56,   64,   65,   65,   64,
 724        61,   33,   72,   69,   43,   73,   62,   66,   39,   79,
 725        63,   35,   35,   35,   35,   35,   35,   35,   35,   43,
 726        77,   39,   82,   37,   39,   39,   41,   41,   41,   41,
 727        74,   74,   74,   74,   39,   80,   39,   81,   39,   39,
 728        39,   39,   39,   39,   39,  139,   37,   39,   39,   78,
 729        85,   39,   88,   89,   84,   39,   94,   87,   83,   90,
 730        39,   86,   91,   92,   39,   39,   39,   39,  101,   95,
 731
 732       103,   93,  139,   39,   37,   97,   76,   39,   98,  111,
 733        39,  112,   96,   64,   65,   65,   64,  106,  102,   74,
 734        74,   74,   74,  105,   66,   74,   74,   74,   74,   39,
 735        39,   39,   39,   39,   39,   39,   39,   39,  113,   39,
 736        39,  107,  114,  114,  114,  114,  117,  108,   39,  109,
 737       110,   39,  118,   39,  123,   39,  120,  119,   39,   39,
 738       121,  141,  146,  127,  125,   76,  149,  143,  122,   43,
 739        39,   76,  124,   37,   39,  147,   39,  126,   39,   39,
 740        39,  142,  144,   39,   39,  148,   39,  163,  151,   39,
 741        39,  153,  159,  150,   39,  152,  139,  155,  139,  154,
 742
 743       178,  115,  114,  114,  114,  114,  139,  116,  129,  158,
 744       176,  130,  131,  132,   39,  133,   39,  164,   39,  134,
 745        39,  170,  222,  135,  136,  165,  137,  138,  160,  160,
 746       160,  160,  139,   39,   39,   39,   39,  167,  139,  168,
 747       139,  139,  166,  139,  169,  172,  172,  172,  172,  139,
 748       139,  139,  173,  174,  177,  180,  171,  139,  179,  185,
 749       183,  156,  186,  175,  189,  182,  193,  157,  190,  181,
 750       194,  195,  184,  196,  197,   39,  198,  187,   37,   39,
 751       139,   39,   39,   39,  161,   39,  200,  162,   39,   39,
 752       199,   39,   39,  203,  160,  160,  160,  160,   39,   39,
 753
 754        39,  139,  207,   39,  204,   39,   39,   39,  211,  212,
 755       139,  215,   39,  208,  213,  213,  213,  213,  209,  210,
 756        39,   39,   39,  218,  216,  221,  217,  172,  172,  172,
 757       172,  139,  139,  225,  173,  219,  219,  219,  219,  139,
 758       139,  139,  246,  139,  220,  139,  223,  228,  139,  139,
 759       205,  224,  232,  206,  230,  242,  139,  243,  226,  227,
 760       244,   39,  231,  233,  229,   37,  245,  234,   39,   39,
 761       214,   39,   39,   39,   39,  251,   39,  247,  247,  247,
 762       247,   39,   39,   39,   39,   39,  252,  257,  258,  753,
 763       255,  213,  213,  213,  213,  256,   39,  139,  261,  139,
 764
 765       271,  259,  262,  262,  262,  262,   39,  139,  265,  269,
 766       139,  264,  219,  219,  219,  219,  266,  266,  266,  266,
 767       277,  220,  270,  272,  267,  273,  284,  139,  274,  139,
 768       139,  275,  139,  139,  276,  139,  296,  139,  285,  288,
 769       366,  287,  278,  297,   37,  248,  298,  260,   39,   39,
 770       139,  279,  263,  280,  286,  281,  282,   39,   39,  283,
 771       247,  247,  247,  247,   39,  139,  139,  304,   39,   39,
 772       302,  302,  302,  302,   39,  308,  307,   39,  326,  309,
 773        39,  314,  139,  311,  262,  262,  262,  262,  313,  266,
 774       266,  266,  266,  315,  315,  315,  315,  267,  139,  318,
 775
 776       316,  266,  266,  266,  266,  139,  139,  139,  320,  267,
 777       317,  139,  139,  321,  139,  139,  139,   39,  139,  323,
 778       139,  327,  139,  329,  328,  319,  139,  139,  248,  303,
 779       139,  322,  324,  325,  312,  331,  139,  333,  139,  340,
 780       334,  347,  339,  335,  139,  330,  332,  336,   39,  369,
 781       337,  139,  338,  302,  302,  302,  302,  139,  302,  302,
 782       302,  302,  139,  352,   39,  749,  354,  354,  354,  354,
 783        39,   39,  359,  139,  356,  315,  315,  315,  315,  139,
 784       362,  363,  316,  360,  360,  360,  360,  139,  139,  139,
 785       367,  365,  368,  139,  139,  371,  364,  139,  370,  139,
 786
 787       372,  139,  139,  139,  139,  384,  376,  374,  139,  373,
 788       139,  139,  350,   39,  139,  380,  381,  350,  382,  375,
 789       378,  377,  355,  139,  379,  393,  385,  392,  139,   39,
 790        39,  394,  394,  394,  394,  139,  139,   39,  383,  354,
 791       354,  354,  354,  398,   39,  139,   39,  354,  354,  354,
 792       354,  361,  396,  139,  402,  139,  139,  139,  400,  360,
 793       360,  360,  360,  139,  410,  139,  409,  404,  405,  406,
 794       408,  139,  139,  407,  139,  411,  139,  139,  139,  139,
 795       139,  414,  415,  139,  139,  412,  139,  416,  139,  418,
 796       139,  413,  139,  421,  139,  399,  426,  432,  417,  419,
 797
 798        39,   39,  420,  399,  139,  424,  423,  422,  439,  425,
 799       394,  394,  394,  394,  394,  394,  394,  394,   39,  436,
 800       139,  139,  139,  139,  440,  434,  139,  361,  441,  443,
 801       139,  396,  139,  446,  139,  396,  139,  447,  442,  139,
 802       139,  139,  450,  139,  444,  139,  139,  445,  139,  455,
 803       448,  449,  139,  139,  139,  452,  139,  451,  453,  454,
 804       456,  461,  457,  460,  105,  458,  459,  469,  139,  473,
 805       474,  464,  462,  463,  475,   39,  139,  139,  139,  139,
 806       139,  139,  481,  446,  139,  139,  477,  447,  139,  483,
 807       139,  139,  139,  488,  139,  476,  139,  478,  484,  486,
 808
 809       482,  489,  490,  139,  497,  485,  139,  509,  493,  487,
 810       494,  139,  510,  495,  496,  503,  139,  139,  491,  506,
 811       139,  139,  139,  517,  492,  529,  139,  139,  498,  504,
 812       504,  504,  504,  139,  139,  508,   39,  139,  505,  139,
 813       516,  507,  139,  511,  512,  513,  139,  514,  139,  519,
 814       520,  521,  522,  525,  523,  528,  526,  527,  139,  530,
 815       518,  139,  515,  139,  139,  532,  535,  536,  540,  524,
 816       748,  139,  504,  504,  504,  504,  139,  139,   39,  531,
 817       537,  505,  139,  139,  139,  139,  541,  541,  543,  541,
 818       139,  545,  548,  544,  542,  139,  546,  139,  547,  549,
 819
 820       550,  551,  139,  552,  557,  139,  139,  538,  553,  139,
 821       554,  139,  556,  139,  139,  139,  139,  558,  139,  555,
 822       559,  560,  139,  561,  562,  563,  139,  139,  139,  567,
 823       568,  139,  577,  139,  139,  139,  139,  566,  139,  139,
 824       743,  564,  565,  569,  579,   39,  541,  541,  578,  541,
 825       580,  740,  139,  620,  542,  581,  139,  139,  139,  139,
 826       583,  582,  139,  584,  139,  585,  139,  586,  139,  139,
 827       570,  587,  139,  139,  139,  589,  139,  591,  590,  139,
 828       592,  139,  593,  139,  594,  139,  588,  139,  595,  139,
 829       597,  139,  596,  610,  139,  139,  139,  611,  139,  615,
 830
 831       139,  139,  598,  616,  617,  599,  139,  139,  139,  618,
 832       139,  622,  613,  612,  139,  614,  139,  139,  139,  624,
 833       625,  626,  139,  139,  629,  619,  627,  621,  139,  139,
 834       631,  623,  630,  644,  139,  139,  642,  139,  139,  628,
 835       139,  139,  643,  139,  139,  139,  139,  139,  139,  660,
 836       139,  139,  139,  139,  139,  645,  139,  139,  646,  139,
 837       139,  647,  648,  649,  650,  651,  652,  653,  654,  139,
 838       139,  655,  139,  656,  657,  659,  658,  139,  661,  139,
 839       672,  139,  139,  139,  139,  139,  139,  139,  733,  662,
 840       139,  139,  139,  673,  732,  139,  675,  676,  677,  678,
 841
 842       686,  680,  681,  674,  685,  679,  682,  683,  139,  139,
 843       139,  684,  139,  139,  139,  139,  700,  139,  701,  696,
 844       139,  139,  712,  139,  139,  139,  695,  698,  697,  139,
 845       716,  699,  139,  139,  139,  710,  139,  728,  726,  711,
 846       714,  139,  713,  715,  139,  725,  727,  139,  738,  139,
 847       139,  737,  139,  745,  139,  746,  750,  139,  139,  736,
 848       751,  731,  139,  139,  744,  139,  739,  747,  139,  139,
 849       139,  752,  139,  755,  757,  139,  139,  139,  759,  756,
 850       762,  760,  139,  139,  139,  763,  766,  139,  767,  139,
 851       139,  730,  761,  768,  139,  139,  139,  139,  764,  724,
 852
 853       139,  723,  722,  765,  720,  719,  769,  718,  717,  770,
 854        32,   32,   32,  709,   32,   32,   32,   32,   32,   32,
 855        36,   36,  708,   36,   38,   38,  707,   38,   42,   42,
 856       706,  705,  704,   42,   67,   67,   67,   67,   67,   67,
 857        67,   67,   67,   67,   71,   71,  703,   71,   71,   71,
 858        71,   71,   71,   71,   75,   75,  702,  139,   75,   75,
 859       139,  139,   75,  100,  100,  139,  100,  100,  100,  100,
 860       100,  100,  100,  128,  128,  139,  128,  140,  140,  139,
 861       140,  140,  140,  140,  140,  140,  140,  240,  240,  240,
 862       240,  240,  240,  240,  240,  240,  240,  268,  268,  139,
 863
 864       268,  268,  268,  139,  268,  292,  292,  292,  292,  292,
 865       292,  292,  292,  292,  292,  389,  389,  694,  389,  389,
 866       389,  389,  389,  389,  389,  395,  395,  693,  692,  395,
 867       395,  395,  395,  427,  427,  691,  427,  427,  427,  427,
 868       427,  427,  427,  479,  479,  479,  479,  479,  479,  479,
 869       479,  479,  479,  641,  641,  690,  641,  641,  641,  641,
 870       641,  641,  641,  667,  667,  689,  667,  667,  667,  667,
 871       667,  667,  667,  721,  721,  688,  721,  721,  721,  721,
 872       721,  721,  721,  729,  729,  687,  729,  729,  729,  729,
 873       729,  729,  729,  734,  734,  139,  734,  734,  734,  734,
 874
 875       734,  734,  734,  735,  735,  139,  735,  735,  735,  735,
 876       735,  735,  735,  741,  741,  139,  741,  741,  741,  741,
 877       741,  741,  741,  742,  742,  139,  742,  742,  742,  742,
 878       742,  742,  742,  754,  754,  139,  754,  754,  754,  754,
 879       754,  754,  754,  758,  758,  139,  758,  758,  758,  758,
 880       758,  758,  758,  671,  670,  669,  668,  666,  665,  664,
 881       663,  139,  640,  639,  638,  637,  636,  635,  634,  633,
 882       632,  139,   39,  609,  608,  607,  606,  605,  604,  603,
 883       602,  601,  600,  139,  139,  576,  575,  574,  573,  572,
 884       571,  139,  139,  139,  539,  534,  533,  139,  139,  139,
 885
 886       139,  139,  139,  480,  502,  501,  500,  499,  139,  139,
 887       480,  139,  472,   39,  471,   39,  470,  468,  467,  466,
 888       465,  139,  438,   39,  437,  435,  433,   39,  431,  430,
 889       429,  428,  139,  403,  401,   39,  397,  391,  390,  388,
 890       387,  386,   39,  358,   39,  357,   39,  353,   39,  351,
 891       349,  348,   37,  346,  345,  344,  241,  343,  342,  341,
 892        39,  310,   39,   39,  306,  305,  301,  300,  299,   39,
 893        39,  241,  295,  294,  293,  241,  291,  290,  289,   39,
 894        39,  254,  253,  250,  249,   39,   39,  241,  239,  238,
 895       237,  236,  235,  202,  201,   39,   39,  192,  191,  188,
 896
 897       139,   39,   39,  145,  104,   68,   99,   39,   37,   70,
 898        68,   39,  771,    3,  771,  771,  771,  771,  771,  771,
 899       771,  771,  771,  771,  771,  771,  771,  771,  771,  771,
 900       771,  771,  771,  771,  771,  771,  771,  771,  771,  771,
 901       771,  771,  771,  771,  771,  771,  771,  771,  771,  771,
 902       771,  771,  771,  771,  771,  771,  771,  771,  771,  771,
 903       771,  771,  771,  771,  771,  771,  771,  771,  771,  771,
 904       771,  771,  771,  771,  771,  771,  771,  771,  771,  771,
 905       771,  771,  771,  771,  771,  771,  771
 906     } ;
 907
 908 static yyconst flex_int16_t yy_chk[1788] =
 909     {   0,
 910         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 911         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 912         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 913         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 914         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 915         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 916         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 917         1,    1,    1,    2,    2,    2,    2,    9,    2,    9,
 918        13,   13,   13,   13,    2,   10,   10,   10,   10,   10,
 919        10,   10,   10,   12,   15,   16,   17,   18,   24,   20,
 920
 921        22,   12,   19,   21,   17,   23,   24,   24,   17,   25,
 922        16,   17,   18,   20,   19,   15,   22,   24,   21,   19,
 923        10,   26,   23,   25,   45,   23,   27,   27,   27,   27,
 924        26,   31,   37,   31,   39,   40,   26,   27,   48,   45,
 925        26,   35,   35,   35,   35,   35,   35,   35,   35,   44,
 926        43,   40,   48,   37,   43,   39,   41,   41,   41,   41,
 927        42,   42,   42,   42,   46,   46,   47,   47,   49,   50,
 928        44,   51,   52,   53,   55,  770,   35,   54,   57,   44,
 929        51,   60,   54,   55,   50,   59,   59,   53,   49,   55,
 930        56,   52,   56,   57,   58,   61,   62,   63,   69,   60,
 931
 932        72,   58,  764,   78,   72,   62,   42,   83,   63,   83,
 933        84,   84,   61,   64,   64,   64,   64,   78,   69,   74,
 934        74,   74,   74,   77,   64,   75,   75,   75,   75,   79,
 935        80,   81,   82,   85,   77,   88,   89,   90,   85,   87,
 936        93,   79,   86,   86,   86,   86,   87,   80,   91,   81,
 937        82,   92,   88,   94,   93,   95,   90,   89,   96,   97,
 938        91,   99,  103,   97,   95,   74,  105,  101,   92,  104,
 939       109,   75,   94,  103,  106,  104,  110,   96,  105,  111,
 940       112,   99,  101,  113,  116,  104,  118,  118,  109,   86,
 941       104,  111,  116,  106,  115,  110,  133,  113,  131,  112,
 942
 943       133,   86,  114,  114,  114,  114,  175,   86,   98,  115,
 944       131,   98,   98,   98,  125,   98,  119,  119,  122,   98,
 945       120,  125,  175,   98,   98,  120,   98,   98,  117,  117,
 946       117,  117,   98,  121,  123,  124,  126,  122,  129,  123,
 947       130,  136,  121,  134,  124,  127,  127,  127,  127,  132,
 948       135,  137,  127,  129,  132,  135,  126,  138,  134,  139,
 949       137,  114,  141,  130,  143,  136,  146,  114,  143,  135,
 950       147,  148,  138,  149,  150,  117,  151,  141,  146,  158,
 951       139,  148,  155,  149,  117,  153,  155,  117,  161,  159,
 952       153,  147,  127,  158,  160,  160,  160,  160,  162,  163,
 953
 954       164,  761,  161,  150,  159,  165,  166,  168,  165,  166,
 955       174,  168,  170,  162,  167,  167,  167,  167,  163,  164,
 956       151,  169,  171,  171,  169,  174,  170,  172,  172,  172,
 957       172,  176,  177,  178,  172,  173,  173,  173,  173,  179,
 958       180,  178,  197,  181,  173,  184,  176,  181,  182,  183,
 959       160,  177,  185,  160,  183,  193,  185,  194,  179,  180,
 960       195,  167,  184,  186,  182,  193,  196,  186,  203,  204,
 961       167,  207,  209,  197,  196,  203,  194,  198,  198,  198,
 962       198,  208,  211,  210,  214,  195,  204,  209,  210,  748,
 963       207,  213,  213,  213,  213,  208,  218,  221,  214,  223,
 964
 965       223,  211,  215,  215,  215,  215,  217,  222,  218,  221,
 966       225,  217,  219,  219,  219,  219,  220,  220,  220,  220,
 967       226,  219,  222,  224,  220,  224,  228,  226,  224,  231,
 968       321,  224,  230,  229,  225,  228,  242,  224,  229,  232,
 969       321,  231,  227,  243,  242,  198,  244,  213,  252,  215,
 970       232,  227,  215,  227,  230,  227,  227,  244,  257,  227,
 971       247,  247,  247,  247,  261,  227,  278,  252,  243,  256,
 972       251,  251,  251,  251,  259,  257,  256,  264,  278,  259,
 973       263,  264,  270,  261,  262,  262,  262,  262,  263,  266,
 974       266,  266,  266,  267,  267,  267,  267,  266,  747,  270,
 975
 976       267,  268,  268,  268,  268,  269,  271,  272,  272,  268,
 977       269,  273,  274,  273,  275,  277,  276,  251,  281,  275,
 978       279,  279,  280,  281,  280,  271,  282,  284,  247,  251,
 979       283,  274,  276,  277,  262,  283,  286,  285,  287,  288,
 980       285,  297,  287,  285,  324,  282,  284,  285,  303,  324,
 981       285,  288,  286,  300,  300,  300,  300,  285,  302,  302,
 982       302,  302,  318,  303,  297,  743,  307,  307,  307,  307,
 983       309,  313,  313,  322,  309,  315,  315,  315,  315,  317,
 984       317,  318,  315,  316,  316,  316,  316,  319,  320,  323,
 985       322,  320,  323,  325,  326,  326,  319,  327,  325,  328,
 986
 987       327,  329,  330,  331,  332,  339,  331,  329,  333,  328,
 988       334,  336,  300,  307,  335,  335,  336,  302,  337,  330,
 989       333,  332,  307,  338,  334,  348,  340,  347,  339,  352,
 990       347,  349,  349,  349,  349,  337,  340,  359,  338,  353,
 991       353,  353,  353,  352,  355,  368,  348,  354,  354,  354,
 992       354,  316,  349,  362,  359,  364,  365,  367,  355,  360,
 993       360,  360,  360,  363,  368,  366,  367,  362,  363,  364,
 994       366,  370,  371,  365,  372,  370,  373,  374,  375,  376,
 995       377,  373,  374,  379,  378,  371,  381,  375,  383,  377,
 996       380,  372,  382,  380,  384,  353,  385,  393,  376,  378,
 997
 998       400,  393,  379,  354,  385,  383,  382,  381,  404,  384,
 999       394,  394,  394,  394,  395,  395,  395,  395,  398,  400,
1000       405,  406,  404,  407,  405,  398,  408,  360,  406,  408,
1001       409,  394,  410,  411,  412,  395,  413,  411,  407,  414,
1002       415,  416,  414,  417,  409,  418,  421,  410,  419,  419,
1003       412,  413,  422,  423,  424,  416,  425,  415,  417,  418,
1004       420,  422,  420,  421,  432,  420,  420,  432,  439,  439,
1005       440,  425,  423,  424,  441,  432,  443,  411,  440,  444,
1006       445,  450,  448,  446,  451,  441,  444,  446,  453,  451,
1007       455,  452,  454,  456,  420,  443,  448,  445,  452,  454,
1008
1009       450,  457,  458,  460,  463,  453,  461,  476,  462,  455,
1010       462,  464,  477,  462,  462,  469,  473,  474,  460,  473,
1011       475,  476,  456,  482,  461,  494,  477,  463,  464,  472,
1012       472,  472,  472,  458,  457,  475,  469,  482,  472,  481,
1013       481,  474,  462,  478,  478,  478,  483,  478,  492,  484,
1014       485,  485,  485,  487,  485,  493,  487,  492,  494,  495,
1015       483,  498,  478,  484,  497,  498,  501,  501,  503,  485,
1016       740,  506,  504,  504,  504,  504,  478,  507,  503,  497,
1017       501,  504,  508,  485,  493,  487,  505,  505,  506,  505,
1018       495,  508,  511,  507,  505,  509,  509,  510,  510,  512,
1019
1020       513,  514,  515,  515,  520,  516,  511,  501,  516,  517,
1021       517,  519,  519,  512,  513,  514,  518,  521,  520,  518,
1022       522,  523,  524,  524,  525,  526,  527,  531,  532,  533,
1023       533,  521,  540,  543,  522,  523,  545,  532,  588,  544,
1024       733,  527,  531,  533,  544,  540,  541,  541,  543,  541,
1025       545,  730,  546,  588,  541,  546,  526,  525,  547,  548,
1026       548,  547,  549,  549,  550,  550,  551,  551,  552,  553,
1027       533,  552,  554,  555,  556,  554,  564,  556,  555,  557,
1028       557,  558,  558,  559,  559,  565,  553,  560,  560,  561,
1029       564,  566,  561,  579,  580,  581,  583,  579,  582,  583,
1030
1031       584,  585,  565,  584,  585,  566,  586,  579,  587,  586,
1032       589,  590,  581,  580,  591,  582,  592,  593,  594,  592,
1033       593,  594,  596,  595,  597,  587,  595,  589,  598,  599,
1034       599,  591,  598,  612,  590,  610,  610,  611,  597,  596,
1035       613,  612,  611,  614,  615,  616,  617,  618,  629,  629,
1036       619,  621,  622,  623,  624,  613,  625,  626,  614,  627,
1037       628,  615,  616,  617,  618,  619,  621,  622,  623,  630,
1038       631,  624,  643,  625,  626,  628,  627,  642,  630,  644,
1039       642,  647,  648,  649,  650,  653,  655,  656,  722,  631,
1040       661,  657,  658,  643,  720,  662,  647,  648,  649,  650,
1041
1042       662,  655,  656,  644,  661,  653,  657,  658,  660,  672,
1043       673,  660,  674,  679,  684,  685,  685,  697,  686,  673,
1044       695,  696,  697,  698,  700,  699,  672,  679,  674,  701,
1045       701,  684,  686,  713,  716,  695,  711,  716,  713,  696,
1046       699,  715,  698,  700,  725,  711,  715,  726,  727,  728,
1047       736,  726,  739,  737,  738,  738,  744,  752,  745,  725,
1048       745,  719,  727,  759,  736,  737,  728,  739,  746,  751,
1049       744,  746,  750,  750,  752,  755,  756,  757,  755,  751,
1050       759,  756,  760,  762,  763,  760,  765,  766,  766,  768,
1051       767,  718,  757,  767,  769,  714,  712,  710,  762,  709,
1052
1053       765,  708,  707,  763,  705,  704,  768,  703,  702,  769,
1054       772,  772,  772,  694,  772,  772,  772,  772,  772,  772,
1055       773,  773,  693,  773,  774,  774,  692,  774,  775,  775,
1056       691,  690,  689,  775,  776,  776,  776,  776,  776,  776,
1057       776,  776,  776,  776,  777,  777,  688,  777,  777,  777,
1058       777,  777,  777,  777,  778,  778,  687,  683,  778,  778,
1059       682,  681,  778,  779,  779,  680,  779,  779,  779,  779,
1060       779,  779,  779,  780,  780,  678,  780,  781,  781,  677,
1061       781,  781,  781,  781,  781,  781,  781,  782,  782,  782,
1062       782,  782,  782,  782,  782,  782,  782,  783,  783,  676,
1063
1064       783,  783,  783,  675,  783,  784,  784,  784,  784,  784,
1065       784,  784,  784,  784,  784,  785,  785,  671,  785,  785,
1066       785,  785,  785,  785,  785,  786,  786,  670,  669,  786,
1067       786,  786,  786,  787,  787,  668,  787,  787,  787,  787,
1068       787,  787,  787,  788,  788,  788,  788,  788,  788,  788,
1069       788,  788,  788,  789,  789,  666,  789,  789,  789,  789,
1070       789,  789,  789,  790,  790,  665,  790,  790,  790,  790,
1071       790,  790,  790,  791,  791,  664,  791,  791,  791,  791,
1072       791,  791,  791,  792,  792,  663,  792,  792,  792,  792,
1073       792,  792,  792,  793,  793,  659,  793,  793,  793,  793,
1074
1075       793,  793,  793,  794,  794,  654,  794,  794,  794,  794,
1076       794,  794,  794,  795,  795,  652,  795,  795,  795,  795,
1077       795,  795,  795,  796,  796,  651,  796,  796,  796,  796,
1078       796,  796,  796,  797,  797,  646,  797,  797,  797,  797,
1079       797,  797,  797,  798,  798,  645,  798,  798,  798,  798,
1080       798,  798,  798,  640,  639,  638,  637,  635,  634,  633,
1081       632,  620,  608,  607,  606,  605,  604,  603,  602,  601,
1082       600,  578,  577,  576,  575,  574,  573,  572,  571,  570,
1083       569,  568,  567,  563,  562,  539,  538,  537,  536,  535,
1084       534,  530,  529,  528,  502,  500,  499,  496,  491,  490,
1085
1086       489,  488,  486,  479,  468,  467,  466,  465,  459,  449,
1087       447,  442,  438,  436,  435,  434,  433,  431,  430,  429,
1088       428,  426,  403,  402,  401,  399,  397,  392,  391,  390,
1089       388,  387,  369,  361,  358,  356,  350,  346,  345,  343,
1090       342,  341,  314,  312,  311,  310,  308,  306,  304,  301,
1091       299,  298,  296,  295,  294,  293,  292,  291,  290,  289,
1092       265,  260,  258,  255,  254,  253,  250,  249,  248,  246,
1093       245,  240,  239,  238,  237,  236,  235,  234,  233,  216,
1094       212,  206,  205,  202,  201,  200,  199,  192,  191,  190,
1095       189,  188,  187,  157,  156,  154,  152,  145,  144,  142,
1096
1097       128,  108,  107,  102,   73,   67,   66,   38,   36,   32,
1098        30,   11,    3,  771,  771,  771,  771,  771,  771,  771,
1099       771,  771,  771,  771,  771,  771,  771,  771,  771,  771,
1100       771,  771,  771,  771,  771,  771,  771,  771,  771,  771,
1101       771,  771,  771,  771,  771,  771,  771,  771,  771,  771,
1102       771,  771,  771,  771,  771,  771,  771,  771,  771,  771,
1103       771,  771,  771,  771,  771,  771,  771,  771,  771,  771,
1104       771,  771,  771,  771,  771,  771,  771,  771,  771,  771,
1105       771,  771,  771,  771,  771,  771,  771
1106     } ;
1107
1108 /* Table of booleans, true if rule could match eol. */
1109 static yyconst flex_int32_t yy_rule_can_match_eol[95] =
1110     {   0,
1111 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1,
1112     1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1113     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1114     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1115     0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0,     };
1116
1117 static yy_state_type yy_last_accepting_state;
1118 static char *yy_last_accepting_cpos;
1119
1120 extern int yy_flex_debug;
1121 int yy_flex_debug = 0;
1122
1123 /* The intent behind this definition is that it'll catch
1124  * any uses of REJECT which flex missed.
1125  */
1126 #define REJECT reject_used_but_not_detected
1127 #define yymore() yymore_used_but_not_detected
1128 #define YY_MORE_ADJ 0
1129 #define YY_RESTORE_YY_MORE_OFFSET
1130 char *yytext;
1131 #line 1 "vtkParse.l"
1132 #line 3 "vtkParse.l"
1133
1134 /*
1135
1136 This file must be translated to C and modified to build everywhere.
1137
1138 Run flex like this:
1139
1140   flex -olex.yy.c vtkParse.l
1141
1142 Modify lex.yy.c:
1143   - remove yyunput function
1144   - remove TABs
1145   - change yy_n_chars declarations from "int yy_n_chars;" to
1146     "size_t yy_n_chars;" in both the yy_buffer_state structure
1147     and the global scope.
1148   - change num_to_read declaration from "int num_to_read;" to
1149     "size_t num_to_read;" in yy_get_next_buffer function.
1150
1151 */
1152
1153 /* We do not care of interactive mode */
1154 #define YY_NEVER_INTERACTIVE 1
1155 #define YY_NO_UNPUT 1
1156
1157 /* Do not include unistd.h in generated source. */
1158 #define YY_NO_UNISTD_H
1159
1160 /* Skip declaring this function.  It is a macro.  */
1161 #define YY_SKIP_YYWRAP
1162
1163 #ifdef _WIN32
1164 #pragma warning ( disable : 4018 )
1165 #pragma warning ( disable : 4127 )
1166 #pragma warning ( disable : 4131 )
1167 #pragma warning ( disable : 4244 )
1168 #pragma warning ( disable : 4251 )
1169 #pragma warning ( disable : 4267 )
1170 #pragma warning ( disable : 4305 )
1171 #pragma warning ( disable : 4309 )
1172 #pragma warning ( disable : 4706 )
1173 #pragma warning ( disable : 4786 )
1174 #endif
1175
1176 #line 1179 "lex.yy.c"
1177
1178 #define INITIAL 0
1179
1180 #ifndef YY_NO_UNISTD_H
1181 /* Special case for "unistd.h", since it is non-ANSI. We include it way
1182  * down here because we want the user's section 1 to have been scanned first.
1183  * The user has a chance to override it with an option.
1184  */
1185 #include <unistd.h>
1186 #endif
1187
1188 #ifndef YY_EXTRA_TYPE
1189 #define YY_EXTRA_TYPE void *
1190 #endif
1191
1192 static int yy_init_globals (void );
1193
1194 /* Accessor methods to globals.
1195    These are made visible to non-reentrant scanners for convenience. */
1196
1197 int yylex_destroy (void );
1198
1199 int yyget_debug (void );
1200
1201 void yyset_debug (int debug_flag  );
1202
1203 YY_EXTRA_TYPE yyget_extra (void );
1204
1205 void yyset_extra (YY_EXTRA_TYPE user_defined  );
1206
1207 FILE *yyget_in (void );
1208
1209 void yyset_in  (FILE * in_str  );
1210
1211 FILE *yyget_out (void );
1212
1213 void yyset_out  (FILE * out_str  );
1214
1215 int yyget_leng (void );
1216
1217 char *yyget_text (void );
1218
1219 int yyget_lineno (void );
1220
1221 void yyset_lineno (int line_number  );
1222
1223 /* Macros after this point can all be overridden by user definitions in
1224  * section 1.
1225  */
1226
1227 #ifndef YY_SKIP_YYWRAP
1228 #ifdef __cplusplus
1229 extern "C" int yywrap (void );
1230 #else
1231 extern int yywrap (void );
1232 #endif
1233 #endif
1234
1235 #ifndef yytext_ptr
1236 static void yy_flex_strncpy (char *,yyconst char *,int );
1237 #endif
1238
1239 #ifdef YY_NEED_STRLEN
1240 static int yy_flex_strlen (yyconst char * );
1241 #endif
1242
1243 #ifndef YY_NO_INPUT
1244
1245 #ifdef __cplusplus
1246 static int yyinput (void );
1247 #else
1248 static int input (void );
1249 #endif
1250
1251 #endif
1252
1253 /* Amount of stuff to slurp up with each read. */
1254 #ifndef YY_READ_BUF_SIZE
1255 #ifdef __ia64__
1256 /* On IA-64, the buffer size is 16k, not 8k */
1257 #define YY_READ_BUF_SIZE 16384
1258 #else
1259 #define YY_READ_BUF_SIZE 8192
1260 #endif /* __ia64__ */
1261 #endif
1262
1263 /* Copy whatever the last rule matched to the standard output. */
1264 #ifndef ECHO
1265 /* This used to be an fputs(), but since the string might contain NUL's,
1266  * we now use fwrite().
1267  */
1268 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
1269 #endif
1270
1271 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
1272  * is returned in "result".
1273  */
1274 #ifndef YY_INPUT
1275 #define YY_INPUT(buf,result,max_size) \
1276   if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1277     { \
1278     int c = '*'; \
1279     size_t n; \
1280     for ( n = 0; n < max_size && \
1281            (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1282       buf[n] = (char) c; \
1283     if ( c == '\n' ) \
1284       buf[n++] = (char) c; \
1285     if ( c == EOF && ferror( yyin ) ) \
1286       YY_FATAL_ERROR( "input in flex scanner failed" ); \
1287     result = n; \
1288     } \
1289   else \
1290     { \
1291     errno=0; \
1292     while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
1293       { \
1294       if( errno != EINTR) \
1295         { \
1296         YY_FATAL_ERROR( "input in flex scanner failed" ); \
1297         break; \
1298         } \
1299       errno=0; \
1300       clearerr(yyin); \
1301       } \
1302     }\
1303 \
1304
1305 #endif
1306
1307 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1308  * we don't want an extra ';' after the "return" because that will cause
1309  * some compilers to complain about unreachable statements.
1310  */
1311 #ifndef yyterminate
1312 #define yyterminate() return YY_NULL
1313 #endif
1314
1315 /* Number of entries by which start-condition stack grows. */
1316 #ifndef YY_START_STACK_INCR
1317 #define YY_START_STACK_INCR 25
1318 #endif
1319
1320 /* Report a fatal error. */
1321 #ifndef YY_FATAL_ERROR
1322 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1323 #endif
1324
1325 /* end tables serialization structures and prototypes */
1326
1327 /* Default declaration of generated scanner - a define so the user can
1328  * easily add parameters.
1329  */
1330 #ifndef YY_DECL
1331 #define YY_DECL_IS_OURS 1
1332
1333 extern int yylex (void);
1334
1335 #define YY_DECL int yylex (void)
1336 #endif /* !YY_DECL */
1337
1338 /* Code executed at the beginning of each rule, after yytext and yyleng
1339  * have been set up.
1340  */
1341 #ifndef YY_USER_ACTION
1342 #define YY_USER_ACTION
1343 #endif
1344
1345 /* Code executed at the end of each rule. */
1346 #ifndef YY_BREAK
1347 #define YY_BREAK break;
1348 #endif
1349
1350 #define YY_RULE_SETUP \
1351   if ( yyleng > 0 ) \
1352     YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
1353         (yytext[yyleng - 1] == '\n'); \
1354   YY_USER_ACTION
1355
1356 /** The main scanner function which does all the work.
1357  */
1358 YY_DECL
1359 {
1360   register yy_state_type yy_current_state;
1361   register char *yy_cp, *yy_bp;
1362   register int yy_act;
1363
1364 #line 49 "vtkParse.l"
1365
1366
1367 #line 1372 "lex.yy.c"
1368
1369   if ( !(yy_init) )
1370     {
1371     (yy_init) = 1;
1372
1373 #ifdef YY_USER_INIT
1374     YY_USER_INIT;
1375 #endif
1376
1377     if ( ! (yy_start) )
1378       (yy_start) = 1;  /* first start state */
1379
1380     if ( ! yyin )
1381       yyin = stdin;
1382
1383     if ( ! yyout )
1384       yyout = stdout;
1385
1386     if ( ! YY_CURRENT_BUFFER ) {
1387       yyensure_buffer_stack ();
1388       YY_CURRENT_BUFFER_LVALUE =
1389         yy_create_buffer(yyin,YY_BUF_SIZE );
1390     }
1391
1392     yy_load_buffer_state( );
1393     }
1394
1395   while ( 1 )    /* loops until end-of-file is reached */
1396     {
1397     yy_cp = (yy_c_buf_p);
1398
1399     /* Support of yytext. */
1400     *yy_cp = (yy_hold_char);
1401
1402     /* yy_bp points to the position in yy_ch_buf of the start of
1403      * the current run.
1404      */
1405     yy_bp = yy_cp;
1406
1407     yy_current_state = (yy_start);
1408     yy_current_state += YY_AT_BOL();
1409 yy_match:
1410     do
1411       {
1412       register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1413       if ( yy_accept[yy_current_state] )
1414         {
1415         (yy_last_accepting_state) = yy_current_state;
1416         (yy_last_accepting_cpos) = yy_cp;
1417         }
1418       while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1419         {
1420         yy_current_state = (int) yy_def[yy_current_state];
1421         if ( yy_current_state >= 772 )
1422           yy_c = yy_meta[(unsigned int) yy_c];
1423         }
1424       yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1425       ++yy_cp;
1426       }
1427     while ( yy_base[yy_current_state] != 1714 );
1428
1429 yy_find_action:
1430     yy_act = yy_accept[yy_current_state];
1431     if ( yy_act == 0 )
1432       { /* have to back up */
1433       yy_cp = (yy_last_accepting_cpos);
1434       yy_current_state = (yy_last_accepting_state);
1435       yy_act = yy_accept[yy_current_state];
1436       }
1437
1438     YY_DO_BEFORE_ACTION;
1439
1440     if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
1441       {
1442       int yyl;
1443       for ( yyl = 0; yyl < yyleng; ++yyl )
1444         if ( yytext[yyl] == '\n' )
1445
1446     yylineno++;
1447 ;
1448       }
1449
1450 do_action:  /* This label is used only to access EOF actions. */
1451
1452     switch ( yy_act )
1453   { /* beginning of action switch */
1454       case 0: /* must back up */
1455       /* undo the effects of YY_DO_BEFORE_ACTION */
1456       *yy_cp = (yy_hold_char);
1457       yy_cp = (yy_last_accepting_cpos);
1458       yy_current_state = (yy_last_accepting_state);
1459       goto yy_find_action;
1460
1461 case 1:
1462 YY_RULE_SETUP
1463 #line 51 "vtkParse.l"
1464 { int c1 = 0, c2 = input();
1465        for (;;)
1466    {
1467          if (c2 == 0)
1468            {
1469            fprintf(yyout,"Cannot find closing comment.\n");
1470            break;
1471            }
1472          if (c1 == '*' && c2 == '/') break;
1473          c1 = c2; c2 = input();
1474          }
1475      };
1476   YY_BREAK
1477 case 2:
1478 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1479 (yy_c_buf_p) = yy_cp -= 1;
1480 YY_DO_BEFORE_ACTION; /* set up yytext again */
1481 YY_RULE_SETUP
1482 #line 64 "vtkParse.l"
1483 {
1484        int c1 = 0, c2 = 0, c3 = 0, c4 = 0, c5 = input();
1485        for (;;)
1486    {
1487          if (c5 == 0)
1488            {
1489            fprintf(yyout,"Cannot find matching //ETX.\n");
1490            break;
1491            }
1492          if (c1 == '/' && c2 == '/' && c3 == 'E' && c4 == 'T' && c5 == 'X') break;
1493          c1 = c2; c2 = c3; c3 = c4; c4 = c5; c5 = input();
1494          }
1495        for (;;)
1496          {
1497          if (c5 == 0) break;
1498          if (c5 == '\n') break;
1499          c5 = input();
1500          }
1501      };
1502   YY_BREAK
1503 case 3:
1504 YY_RULE_SETUP
1505 #line 84 "vtkParse.l"
1506 {
1507      int pos = 1;
1508      while (yytext[pos-1] != 'M' || yytext[pos] != 'E')
1509        {
1510        pos++;
1511        }
1512      yylval.str = (char *)malloc(yyleng + 1 - pos - 1);
1513      memcpy(yylval.str,yytext+ pos + 1,yyleng - pos - 1);
1514      yylval.str[yyleng - pos - 1] = '\0';
1515      data.NameComment = vtkstrdup(yylval.str);
1516      };
1517   YY_BREAK
1518 case 4:
1519 YY_RULE_SETUP
1520 #line 96 "vtkParse.l"
1521 {
1522      CommentState = 1;
1523      data.Description = (char*)malloc(100000);
1524      data.Description[0] = '\0';
1525      };
1526   YY_BREAK
1527 case 5:
1528 YY_RULE_SETUP
1529 #line 102 "vtkParse.l"
1530 {
1531      CommentState = 3;
1532      data.SeeAlso = (char*)malloc(100000);
1533      data.SeeAlso[0] = '\0';
1534      };
1535   YY_BREAK
1536 case 6:
1537 YY_RULE_SETUP
1538 #line 108 "vtkParse.l"
1539 {
1540      CommentState = 3;
1541      data.SeeAlso = (char*)malloc(100000);
1542      data.SeeAlso[0] = '\0';
1543      };
1544   YY_BREAK
1545 case 7:
1546 YY_RULE_SETUP
1547 #line 114 "vtkParse.l"
1548 {
1549      CommentState = 4;
1550      data.Caveats = (char*)malloc(100000);
1551      data.Caveats[0] = '\0';
1552      };
1553   YY_BREAK
1554 case 8:
1555 YY_RULE_SETUP
1556 #line 120 "vtkParse.l"
1557 {
1558      CommentState = 2;
1559      HaveComment = 1;
1560      CommentText[0] = '\0';
1561      };
1562   YY_BREAK
1563 case 9:
1564 /* rule 9 can match eol */
1565 YY_RULE_SETUP
1566 #line 126 "vtkParse.l"
1567 {
1568      HaveComment = 0;
1569      CommentState = 0;
1570      };
1571   YY_BREAK
1572 case 10:
1573 YY_RULE_SETUP
1574 #line 131 "vtkParse.l"
1575 {
1576      int pos = 1;
1577      while (yytext[pos-1] != '/' || yytext[pos] != '/') pos++;
1578      yylval.str = (char *)malloc(yyleng + 1 - pos - 1 + 1);
1579      memcpy(yylval.str,yytext+ pos + 1,yyleng - pos - 1);
1580      yylval.str[yyleng - pos - 1] = '\n';
1581      yylval.str[yyleng - pos] = '\0';
1582      switch (CommentState)
1583        {
1584        case 1: strcat(data.Description,yylval.str); break;
1585        case 2: strcat(CommentText,yylval.str); break;
1586        case 3: strcat(data.SeeAlso,yylval.str); break;
1587        case 4: strcat(data.Caveats,yylval.str); break;
1588        }
1589      };
1590   YY_BREAK
1591 case 11:
1592 YY_RULE_SETUP
1593 #line 147 "vtkParse.l"
1594 ;
1595   YY_BREAK
1596 case 12:
1597 YY_RULE_SETUP
1598 #line 149 "vtkParse.l"
1599 ;
1600   YY_BREAK
1601 case 13:
1602 /* rule 13 can match eol */
1603 YY_RULE_SETUP
1604 #line 151 "vtkParse.l"
1605 ;
1606   YY_BREAK
1607 case 14:
1608 /* rule 14 can match eol */
1609 YY_RULE_SETUP
1610 #line 153 "vtkParse.l"
1611 {
1612    sscanf(yytext+1,"%d",&yylval.integer); return(ARRAY_NUM);}
1613   YY_BREAK
1614 case 15:
1615 /* rule 15 can match eol */
1616 YY_RULE_SETUP
1617 #line 157 "vtkParse.l"
1618 return(CLASS_REF);
1619   YY_BREAK
1620 case 16:
1621 /* rule 16 can match eol */
1622 YY_RULE_SETUP
1623 #line 159 "vtkParse.l"
1624 return(VAR_FUNCTION);
1625   YY_BREAK
1626 case 17:
1627 /* rule 17 can match eol */
1628 YY_RULE_SETUP
1629 #line 161 "vtkParse.l"
1630 return(SHORT);
1631   YY_BREAK
1632 case 18:
1633 /* rule 18 can match eol */
1634 YY_RULE_SETUP
1635 #line 162 "vtkParse.l"
1636 return(LONG);
1637   YY_BREAK
1638 case 19:
1639 /* rule 19 can match eol */
1640 YY_RULE_SETUP
1641 #line 163 "vtkParse.l"
1642 return(SHORT);
1643   YY_BREAK
1644 case 20:
1645 /* rule 20 can match eol */
1646 YY_RULE_SETUP
1647 #line 164 "vtkParse.l"
1648 return(LONG);
1649   YY_BREAK
1650 case 21:
1651 /* rule 21 can match eol */
1652 YY_RULE_SETUP
1653 #line 166 "vtkParse.l"
1654 return(LONG_LONG);
1655   YY_BREAK
1656 case 22:
1657 /* rule 22 can match eol */
1658 YY_RULE_SETUP
1659 #line 167 "vtkParse.l"
1660 return(LONG_LONG);
1661   YY_BREAK
1662 case 23:
1663 /* rule 23 can match eol */
1664 YY_RULE_SETUP
1665 #line 168 "vtkParse.l"
1666 return(LONG_LONG);
1667   YY_BREAK
1668 case 24:
1669 YY_RULE_SETUP
1670 #line 170 "vtkParse.l"
1671 return(INT64__);
1672   YY_BREAK
1673 case 25:
1674 /* rule 25 can match eol */
1675 YY_RULE_SETUP
1676 #line 172 "vtkParse.l"
1677 return(SIGNED_CHAR);
1678   YY_BREAK
1679 case 26:
1680 YY_RULE_SETUP
1681 #line 174 "vtkParse.l"
1682 return(CLASS);
1683   YY_BREAK
1684 case 27:
1685 YY_RULE_SETUP
1686 #line 175 "vtkParse.l"
1687 return(PUBLIC);
1688   YY_BREAK
1689 case 28:
1690 YY_RULE_SETUP
1691 #line 176 "vtkParse.l"
1692 return(PRIVATE);
1693   YY_BREAK
1694 case 29:
1695 YY_RULE_SETUP
1696 #line 177 "vtkParse.l"
1697 return(PROTECTED);
1698   YY_BREAK
1699 case 30:
1700 YY_RULE_SETUP
1701 #line 178 "vtkParse.l"
1702 return(INT);
1703   YY_BREAK
1704 case 31:
1705 YY_RULE_SETUP
1706 #line 179 "vtkParse.l"
1707 return(FLOAT);
1708   YY_BREAK
1709 case 32:
1710 YY_RULE_SETUP
1711 #line 180 "vtkParse.l"
1712 return(SHORT);
1713   YY_BREAK
1714 case 33:
1715 YY_RULE_SETUP
1716 #line 181 "vtkParse.l"
1717 return(LONG);
1718   YY_BREAK
1719 case 34:
1720 YY_RULE_SETUP
1721 #line 182 "vtkParse.l"
1722 return(DOUBLE);
1723   YY_BREAK
1724 case 35:
1725 YY_RULE_SETUP
1726 #line 183 "vtkParse.l"
1727 return(VOID);
1728   YY_BREAK
1729 case 36:
1730 YY_RULE_SETUP
1731 #line 184 "vtkParse.l"
1732 return(CHAR);
1733   YY_BREAK
1734 case 37:
1735 YY_RULE_SETUP
1736 #line 185 "vtkParse.l"
1737 return(BOOL);
1738   YY_BREAK
1739 case 38:
1740 YY_RULE_SETUP
1741 #line 186 "vtkParse.l"
1742 return(VIRTUAL);
1743   YY_BREAK
1744 case 39:
1745 YY_RULE_SETUP
1746 #line 187 "vtkParse.l"
1747 return(CONST);
1748   YY_BREAK
1749 case 40:
1750 YY_RULE_SETUP
1751 #line 188 "vtkParse.l"
1752 return(OPERATOR);
1753   YY_BREAK
1754 case 41:
1755 YY_RULE_SETUP
1756 #line 189 "vtkParse.l"
1757 return(UNSIGNED);
1758   YY_BREAK
1759 case 42:
1760 YY_RULE_SETUP
1761 #line 190 "vtkParse.l"
1762 return(FRIEND);
1763   YY_BREAK
1764 case 43:
1765 YY_RULE_SETUP
1766 #line 191 "vtkParse.l"
1767 return(STATIC);
1768   YY_BREAK
1769 case 44:
1770 YY_RULE_SETUP
1771 #line 193 "vtkParse.l"
1772 return(DOUBLE);
1773   YY_BREAK
1774 case 45:
1775 YY_RULE_SETUP
1776 #line 194 "vtkParse.l"
1777 return(IdType);
1778   YY_BREAK
1779 case 46:
1780 YY_RULE_SETUP
1781 #line 195 "vtkParse.l"
1782 return(StdString);
1783   YY_BREAK
1784 case 47:
1785 YY_RULE_SETUP
1786 #line 196 "vtkParse.l"
1787 return(SetMacro);
1788   YY_BREAK
1789 case 48:
1790 YY_RULE_SETUP
1791 #line 197 "vtkParse.l"
1792 return(GetMacro);
1793   YY_BREAK
1794 case 49:
1795 YY_RULE_SETUP
1796 #line 198 "vtkParse.l"
1797 return(SetStringMacro);
1798   YY_BREAK
1799 case 50:
1800 YY_RULE_SETUP
1801 #line 199 "vtkParse.l"
1802 return(GetStringMacro);
1803   YY_BREAK
1804 case 51:
1805 YY_RULE_SETUP
1806 #line 200 "vtkParse.l"
1807 return(SetClampMacro);
1808   YY_BREAK
1809 case 52:
1810 YY_RULE_SETUP
1811 #line 201 "vtkParse.l"
1812 return(SetObjectMacro);
1813   YY_BREAK
1814 case 53:
1815 YY_RULE_SETUP
1816 #line 202 "vtkParse.l"
1817 return(SetReferenceCountedObjectMacro);
1818   YY_BREAK
1819 case 54:
1820 YY_RULE_SETUP
1821 #line 203 "vtkParse.l"
1822 return(GetObjectMacro);
1823   YY_BREAK
1824 case 55:
1825 YY_RULE_SETUP
1826 #line 204 "vtkParse.l"
1827 return(BooleanMacro);
1828   YY_BREAK
1829 case 56:
1830 YY_RULE_SETUP
1831 #line 205 "vtkParse.l"
1832 return(SetVector2Macro);
1833   YY_BREAK
1834 case 57:
1835 YY_RULE_SETUP
1836 #line 206 "vtkParse.l"
1837 return(SetVector3Macro);
1838   YY_BREAK
1839 case 58:
1840 YY_RULE_SETUP
1841 #line 207 "vtkParse.l"
1842 return(SetVector4Macro);
1843   YY_BREAK
1844 case 59:
1845 YY_RULE_SETUP
1846 #line 208 "vtkParse.l"
1847 return(SetVector6Macro);
1848   YY_BREAK
1849 case 60:
1850 YY_RULE_SETUP
1851 #line 209 "vtkParse.l"
1852 return(GetVector2Macro);
1853   YY_BREAK
1854 case 61:
1855 YY_RULE_SETUP
1856 #line 210 "vtkParse.l"
1857 return(GetVector3Macro);
1858   YY_BREAK
1859 case 62:
1860 YY_RULE_SETUP
1861 #line 211 "vtkParse.l"
1862 return(GetVector4Macro);
1863   YY_BREAK
1864 case 63:
1865 YY_RULE_SETUP
1866 #line 212 "vtkParse.l"
1867 return(GetVector6Macro);
1868   YY_BREAK
1869 case 64:
1870 YY_RULE_SETUP
1871 #line 213 "vtkParse.l"
1872 return(SetVectorMacro);
1873   YY_BREAK
1874 case 65:
1875 YY_RULE_SETUP
1876 #line 214 "vtkParse.l"
1877 return(GetVectorMacro);
1878   YY_BREAK
1879 case 66:
1880 YY_RULE_SETUP
1881 #line 215 "vtkParse.l"
1882 return(ViewportCoordinateMacro);
1883   YY_BREAK
1884 case 67:
1885 YY_RULE_SETUP
1886 #line 216 "vtkParse.l"
1887 return(WorldCoordinateMacro);
1888   YY_BREAK
1889 case 68:
1890 YY_RULE_SETUP
1891 #line 217 "vtkParse.l"
1892 return(TypeMacro);
1893   YY_BREAK
1894 case 69:
1895 YY_RULE_SETUP
1896 #line 218 "vtkParse.l"
1897 return(TypeMacro);
1898   YY_BREAK
1899 case 70:
1900 YY_RULE_SETUP
1901 #line 219 "vtkParse.l"
1902 return(TypeMacro);
1903   YY_BREAK
1904 case 71:
1905 YY_RULE_SETUP
1906 #line 220 "vtkParse.l"
1907 return(TypeMacro);
1908   YY_BREAK
1909 case 72:
1910 YY_RULE_SETUP
1911 #line 221 "vtkParse.l"
1912 return(VTK_LEGACY);
1913   YY_BREAK
1914 case 73:
1915 YY_RULE_SETUP
1916 #line 222 "vtkParse.l"
1917 return(VTK_WRAP_EXTERN);
1918   YY_BREAK
1919 case 74:
1920 YY_RULE_SETUP
1921 #line 223 "vtkParse.l"
1922 return(TypeInt8);
1923   YY_BREAK
1924 case 75:
1925 YY_RULE_SETUP
1926 #line 224 "vtkParse.l"
1927 return(TypeUInt8);
1928   YY_BREAK
1929 case 76:
1930 YY_RULE_SETUP
1931 #line 225 "vtkParse.l"
1932 return(TypeInt16);
1933   YY_BREAK
1934 case 77:
1935 YY_RULE_SETUP
1936 #line 226 "vtkParse.l"
1937 return(TypeUInt16);
1938   YY_BREAK
1939 case 78:
1940 YY_RULE_SETUP
1941 #line 227 "vtkParse.l"
1942 return(TypeInt32);
1943   YY_BREAK
1944 case 79:
1945 YY_RULE_SETUP
1946 #line 228 "vtkParse.l"
1947 return(TypeUInt32);
1948   YY_BREAK
1949 case 80:
1950 YY_RULE_SETUP
1951 #line 229 "vtkParse.l"
1952 return(TypeInt64);
1953   YY_BREAK
1954 case 81:
1955 YY_RULE_SETUP
1956 #line 230 "vtkParse.l"
1957 return(TypeUInt64);
1958   YY_BREAK
1959 case 82:
1960 YY_RULE_SETUP
1961 #line 231 "vtkParse.l"
1962 return(TypeFloat32);
1963   YY_BREAK
1964 case 83:
1965 YY_RULE_SETUP
1966 #line 232 "vtkParse.l"
1967 return(TypeFloat64);
1968   YY_BREAK
1969 case 84:
1970 YY_RULE_SETUP
1971 #line 235 "vtkParse.l"
1972 { sscanf(yytext,"%d",&yylval.integer); return(NUM);}
1973   YY_BREAK
1974 case 85:
1975 /* rule 85 can match eol */
1976 YY_RULE_SETUP
1977 #line 237 "vtkParse.l"
1978 {
1979     yylval.str =  vtkstrdup(yytext + 1);
1980     yylval.str[strlen(yytext)-2] = '\0';
1981     return(STRING);
1982     }
1983   YY_BREAK
1984 case 86:
1985 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1986 (yy_c_buf_p) = yy_cp -= 1;
1987 YY_DO_BEFORE_ACTION; /* set up yytext again */
1988 YY_RULE_SETUP
1989 #line 243 "vtkParse.l"
1990 ;
1991   YY_BREAK
1992 case 87:
1993 YY_RULE_SETUP
1994 #line 246 "vtkParse.l"
1995 { yylval.str = (char *)malloc(yyleng + 1);
1996                      memcpy(yylval.str,yytext,yyleng);
1997                      yylval.str[yyleng] = '\0';
1998                      return(VTK_ID);
1999                     }
2000   YY_BREAK
2001 case 88:
2002 YY_RULE_SETUP
2003 #line 252 "vtkParse.l"
2004 { yylval.str = (char *)malloc(yyleng + 1);
2005                           memcpy(yylval.str,yytext,yyleng);
2006                           yylval.str[yyleng] = '\0';
2007                           return(ID);
2008                         }
2009   YY_BREAK
2010 case 89:
2011 /* rule 89 can match eol */
2012 YY_RULE_SETUP
2013 #line 258 "vtkParse.l"
2014 ;
2015   YY_BREAK
2016 case 90:
2017 YY_RULE_SETUP
2018 #line 261 "vtkParse.l"
2019 return(yytext[0]);
2020   YY_BREAK
2021 case 91:
2022 YY_RULE_SETUP
2023 #line 262 "vtkParse.l"
2024 return(yytext[0]);
2025   YY_BREAK
2026 case 92:
2027 YY_RULE_SETUP
2028 #line 265 "vtkParse.l"
2029 {  return(yytext[0]); }
2030   YY_BREAK
2031 case 93:
2032 YY_RULE_SETUP
2033 #line 267 "vtkParse.l"
2034 return(OTHER);
2035   YY_BREAK
2036 case 94:
2037 YY_RULE_SETUP
2038 #line 268 "vtkParse.l"
2039 ECHO;
2040   YY_BREAK
2041 #line 2046 "lex.yy.c"
2042 case YY_STATE_EOF(INITIAL):
2043   yyterminate();
2044
2045   case YY_END_OF_BUFFER:
2046     {
2047     /* Amount of text matched not including the EOB char. */
2048     int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
2049
2050     /* Undo the effects of YY_DO_BEFORE_ACTION. */
2051     *yy_cp = (yy_hold_char);
2052     YY_RESTORE_YY_MORE_OFFSET
2053
2054     if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
2055       {
2056       /* We're scanning a new file or input source.  It's
2057        * possible that this happened because the user
2058        * just pointed yyin at a new source and called
2059        * yylex().  If so, then we have to assure
2060        * consistency between YY_CURRENT_BUFFER and our
2061        * globals.  Here is the right place to do so, because
2062        * this is the first action (other than possibly a
2063        * back-up) that will match for the new input source.
2064        */
2065       (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2066       YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
2067       YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
2068       }
2069
2070     /* Note that here we test for yy_c_buf_p "<=" to the position
2071      * of the first EOB in the buffer, since yy_c_buf_p will
2072      * already have been incremented past the NUL character
2073      * (since all states make transitions on EOB to the
2074      * end-of-buffer state).  Contrast this with the test
2075      * in input().
2076      */
2077     if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2078       { /* This was really a NUL. */
2079       yy_state_type yy_next_state;
2080
2081       (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
2082
2083       yy_current_state = yy_get_previous_state(  );
2084
2085       /* Okay, we're now positioned to make the NUL
2086        * transition.  We couldn't have
2087        * yy_get_previous_state() go ahead and do it
2088        * for us because it doesn't know how to deal
2089        * with the possibility of jamming (and we don't
2090        * want to build jamming into it because then it
2091        * will run more slowly).
2092        */
2093
2094       yy_next_state = yy_try_NUL_trans( yy_current_state );
2095
2096       yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2097
2098       if ( yy_next_state )
2099         {
2100         /* Consume the NUL. */
2101         yy_cp = ++(yy_c_buf_p);
2102         yy_current_state = yy_next_state;
2103         goto yy_match;
2104         }
2105
2106       else
2107         {
2108         yy_cp = (yy_c_buf_p);
2109         goto yy_find_action;
2110         }
2111       }
2112
2113     else switch ( yy_get_next_buffer(  ) )
2114       {
2115       case EOB_ACT_END_OF_FILE:
2116         {
2117         (yy_did_buffer_switch_on_eof) = 0;
2118
2119         if ( yywrap( ) )
2120           {
2121           /* Note: because we've taken care in
2122            * yy_get_next_buffer() to have set up
2123            * yytext, we can now set up
2124            * yy_c_buf_p so that if some total
2125            * hoser (like flex itself) wants to
2126            * call the scanner after we return the
2127            * YY_NULL, it'll still work - another
2128            * YY_NULL will get returned.
2129            */
2130           (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
2131
2132           yy_act = YY_STATE_EOF(YY_START);
2133           goto do_action;
2134           }
2135
2136         else
2137           {
2138           if ( ! (yy_did_buffer_switch_on_eof) )
2139             YY_NEW_FILE;
2140           }
2141         break;
2142         }
2143
2144       case EOB_ACT_CONTINUE_SCAN:
2145         (yy_c_buf_p) =
2146           (yytext_ptr) + yy_amount_of_matched_text;
2147
2148         yy_current_state = yy_get_previous_state(  );
2149
2150         yy_cp = (yy_c_buf_p);
2151         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2152         goto yy_match;
2153
2154       case EOB_ACT_LAST_MATCH:
2155         (yy_c_buf_p) =
2156         &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
2157
2158         yy_current_state = yy_get_previous_state(  );
2159
2160         yy_cp = (yy_c_buf_p);
2161         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2162         goto yy_find_action;
2163       }
2164     break;
2165     }
2166
2167   default:
2168     YY_FATAL_ERROR(
2169       "fatal flex scanner internal error--no action found" );
2170   } /* end of action switch */
2171     } /* end of scanning one token */
2172 } /* end of yylex */
2173
2174 /* yy_get_next_buffer - try to read in a new buffer
2175  *
2176  * Returns a code representing an action:
2177  *  EOB_ACT_LAST_MATCH -
2178  *  EOB_ACT_CONTINUE_SCAN - continue scanning from current position
2179  *  EOB_ACT_END_OF_FILE - end of file
2180  */
2181 static int yy_get_next_buffer (void)
2182 {
2183       register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
2184   register char *source = (yytext_ptr);
2185   register int number_to_move, i;
2186   int ret_val;
2187
2188   if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
2189     YY_FATAL_ERROR(
2190     "fatal flex scanner internal error--end of buffer missed" );
2191
2192   if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
2193     { /* Don't try to fill the buffer, so this is an EOF. */
2194     if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
2195       {
2196       /* We matched a single character, the EOB, so
2197        * treat this as a final EOF.
2198        */
2199       return EOB_ACT_END_OF_FILE;
2200       }
2201
2202     else
2203       {
2204       /* We matched some text prior to the EOB, first
2205        * process it.
2206        */
2207       return EOB_ACT_LAST_MATCH;
2208       }
2209     }
2210
2211   /* Try to read more data. */
2212
2213   /* First move last chars to start of buffer. */
2214   number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
2215
2216   for ( i = 0; i < number_to_move; ++i )
2217     *(dest++) = *(source++);
2218
2219   if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
2220     /* don't do the read, it's not guaranteed to return an EOF,
2221      * just force an EOF
2222      */
2223     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
2224
2225   else
2226     {
2227       size_t num_to_read =
2228       YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
2229
2230     while ( num_to_read <= 0 )
2231       { /* Not enough room in the buffer - grow it. */
2232
2233       /* just a shorter name for the current buffer */
2234       YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
2235
2236       int yy_c_buf_p_offset =
2237         (int) ((yy_c_buf_p) - b->yy_ch_buf);
2238
2239       if ( b->yy_is_our_buffer )
2240         {
2241         int new_size = b->yy_buf_size * 2;
2242
2243         if ( new_size <= 0 )
2244           b->yy_buf_size += b->yy_buf_size / 8;
2245         else
2246           b->yy_buf_size *= 2;
2247
2248         b->yy_ch_buf = (char *)
2249           /* Include room in for 2 EOB chars. */
2250           yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
2251         }
2252       else
2253         /* Can't grow it, we don't own it. */
2254         b->yy_ch_buf = 0;
2255
2256       if ( ! b->yy_ch_buf )
2257         YY_FATAL_ERROR(
2258         "fatal error - scanner input buffer overflow" );
2259
2260       (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
2261
2262       num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
2263             number_to_move - 1;
2264
2265       }
2266
2267     if ( num_to_read > YY_READ_BUF_SIZE )
2268       num_to_read = YY_READ_BUF_SIZE;
2269
2270     /* Read in more data. */
2271     YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
2272       (yy_n_chars), (size_t) num_to_read );
2273
2274     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2275     }
2276
2277   if ( (yy_n_chars) == 0 )
2278     {
2279     if ( number_to_move == YY_MORE_ADJ )
2280       {
2281       ret_val = EOB_ACT_END_OF_FILE;
2282       yyrestart(yyin  );
2283       }
2284
2285     else
2286       {
2287       ret_val = EOB_ACT_LAST_MATCH;
2288       YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
2289         YY_BUFFER_EOF_PENDING;
2290       }
2291     }
2292
2293   else
2294     ret_val = EOB_ACT_CONTINUE_SCAN;
2295
2296   if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
2297     /* Extend the array by 50%, plus the number we really need. */
2298     yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
2299     YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
2300     if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
2301       YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
2302   }
2303
2304   (yy_n_chars) += number_to_move;
2305   YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
2306   YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
2307
2308   (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
2309
2310   return ret_val;
2311 }
2312
2313 /* yy_get_previous_state - get the state just before the EOB char was reached */
2314
2315     static yy_state_type yy_get_previous_state (void)
2316 {
2317   register yy_state_type yy_current_state;
2318   register char *yy_cp;
2319
2320   yy_current_state = (yy_start);
2321   yy_current_state += YY_AT_BOL();
2322
2323   for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
2324     {
2325     register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
2326     if ( yy_accept[yy_current_state] )
2327       {
2328       (yy_last_accepting_state) = yy_current_state;
2329       (yy_last_accepting_cpos) = yy_cp;
2330       }
2331     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2332       {
2333       yy_current_state = (int) yy_def[yy_current_state];
2334       if ( yy_current_state >= 772 )
2335         yy_c = yy_meta[(unsigned int) yy_c];
2336       }
2337     yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2338     }
2339
2340   return yy_current_state;
2341 }
2342
2343 /* yy_try_NUL_trans - try to make a transition on the NUL character
2344  *
2345  * synopsis
2346  *  next_state = yy_try_NUL_trans( current_state );
2347  */
2348     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
2349 {
2350   register int yy_is_jam;
2351       register char *yy_cp = (yy_c_buf_p);
2352
2353   register YY_CHAR yy_c = 1;
2354   if ( yy_accept[yy_current_state] )
2355     {
2356     (yy_last_accepting_state) = yy_current_state;
2357     (yy_last_accepting_cpos) = yy_cp;
2358     }
2359   while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2360     {
2361     yy_current_state = (int) yy_def[yy_current_state];
2362     if ( yy_current_state >= 772 )
2363       yy_c = yy_meta[(unsigned int) yy_c];
2364     }
2365   yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2366   yy_is_jam = (yy_current_state == 771);
2367
2368   return yy_is_jam ? 0 : yy_current_state;
2369 }
2370
2371 #ifndef YY_NO_INPUT
2372 #ifdef __cplusplus
2373     static int yyinput (void)
2374 #else
2375     static int input  (void)
2376 #endif
2377
2378 {
2379   int c;
2380
2381   *(yy_c_buf_p) = (yy_hold_char);
2382
2383   if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
2384     {
2385     /* yy_c_buf_p now points to the character we want to return.
2386      * If this occurs *before* the EOB characters, then it's a
2387      * valid NUL; if not, then we've hit the end of the buffer.
2388      */
2389     if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2390       /* This was really a NUL. */
2391       *(yy_c_buf_p) = '\0';
2392
2393     else
2394       { /* need more input */
2395       int offset = (yy_c_buf_p) - (yytext_ptr);
2396       ++(yy_c_buf_p);
2397
2398       switch ( yy_get_next_buffer(  ) )
2399         {
2400         case EOB_ACT_LAST_MATCH:
2401           /* This happens because yy_g_n_b()
2402            * sees that we've accumulated a
2403            * token and flags that we need to
2404            * try matching the token before
2405            * proceeding.  But for input(),
2406            * there's no matching to consider.
2407            * So convert the EOB_ACT_LAST_MATCH
2408            * to EOB_ACT_END_OF_FILE.
2409            */
2410
2411           /* Reset buffer status. */
2412           yyrestart(yyin );
2413
2414           /*FALLTHROUGH*/
2415
2416         case EOB_ACT_END_OF_FILE:
2417           {
2418           if ( yywrap( ) )
2419             return EOF;
2420
2421           if ( ! (yy_did_buffer_switch_on_eof) )
2422             YY_NEW_FILE;
2423 #ifdef __cplusplus
2424           return yyinput();
2425 #else
2426           return input();
2427 #endif
2428           }
2429
2430         case EOB_ACT_CONTINUE_SCAN:
2431           (yy_c_buf_p) = (yytext_ptr) + offset;
2432           break;
2433         }
2434       }
2435     }
2436
2437   c = *(unsigned char *) (yy_c_buf_p);  /* cast for 8-bit char's */
2438   *(yy_c_buf_p) = '\0';  /* preserve yytext */
2439   (yy_hold_char) = *++(yy_c_buf_p);
2440
2441   YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
2442   if ( YY_CURRENT_BUFFER_LVALUE->yy_at_bol )
2443
2444     yylineno++;
2445 ;
2446
2447   return c;
2448 }
2449 #endif  /* ifndef YY_NO_INPUT */
2450
2451 /** Immediately switch to a different input stream.
2452  * @param input_file A readable stream.
2453  *
2454  * @note This function does not reset the start condition to @c INITIAL .
2455  */
2456     void yyrestart  (FILE * input_file )
2457 {
2458
2459   if ( ! YY_CURRENT_BUFFER ){
2460         yyensure_buffer_stack ();
2461     YY_CURRENT_BUFFER_LVALUE =
2462             yy_create_buffer(yyin,YY_BUF_SIZE );
2463   }
2464
2465   yy_init_buffer(YY_CURRENT_BUFFER,input_file );
2466   yy_load_buffer_state( );
2467 }
2468
2469 /** Switch to a different input buffer.
2470  * @param new_buffer The new input buffer.
2471  *
2472  */
2473     void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
2474 {
2475
2476   /* TODO. We should be able to replace this entire function body
2477    * with
2478    *    yypop_buffer_state();
2479    *    yypush_buffer_state(new_buffer);
2480      */
2481   yyensure_buffer_stack ();
2482   if ( YY_CURRENT_BUFFER == new_buffer )
2483     return;
2484
2485   if ( YY_CURRENT_BUFFER )
2486     {
2487     /* Flush out information for old buffer. */
2488     *(yy_c_buf_p) = (yy_hold_char);
2489     YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2490     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2491     }
2492
2493   YY_CURRENT_BUFFER_LVALUE = new_buffer;
2494   yy_load_buffer_state( );
2495
2496   /* We don't actually know whether we did this switch during
2497    * EOF (yywrap()) processing, but the only time this flag
2498    * is looked at is after yywrap() is called, so it's safe
2499    * to go ahead and always set it.
2500    */
2501   (yy_did_buffer_switch_on_eof) = 1;
2502 }
2503
2504 static void yy_load_buffer_state  (void)
2505 {
2506       (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2507   (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
2508   yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
2509   (yy_hold_char) = *(yy_c_buf_p);
2510 }
2511
2512 /** Allocate and initialize an input buffer state.
2513  * @param file A readable stream.
2514  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2515  *
2516  * @return the allocated buffer state.
2517  */
2518     YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
2519 {
2520   YY_BUFFER_STATE b;
2521
2522   b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
2523   if ( ! b )
2524     YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2525
2526   b->yy_buf_size = size;
2527
2528   /* yy_ch_buf has to be 2 characters longer than the size given because
2529    * we need to put in 2 end-of-buffer characters.
2530    */
2531   b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
2532   if ( ! b->yy_ch_buf )
2533     YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2534
2535   b->yy_is_our_buffer = 1;
2536
2537   yy_init_buffer(b,file );
2538
2539   return b;
2540 }
2541
2542 /** Destroy the buffer.
2543  * @param b a buffer created with yy_create_buffer()
2544  *
2545  */
2546     void yy_delete_buffer (YY_BUFFER_STATE  b )
2547 {
2548
2549   if ( ! b )
2550     return;
2551
2552   if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
2553     YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
2554
2555   if ( b->yy_is_our_buffer )
2556     yyfree((void *) b->yy_ch_buf  );
2557
2558   yyfree((void *) b  );
2559 }
2560
2561 #ifndef __cplusplus
2562 extern int isatty (int );
2563 #endif /* __cplusplus */
2564
2565 /* Initializes or reinitializes a buffer.
2566  * This function is sometimes called more than once on the same buffer,
2567  * such as during a yyrestart() or at EOF.
2568  */
2569     static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
2570
2571 {
2572   int oerrno = errno;
2573
2574   yy_flush_buffer(b );
2575
2576   b->yy_input_file = file;
2577   b->yy_fill_buffer = 1;
2578
2579     /* If b is the current buffer, then yy_init_buffer was _probably_
2580      * called from yyrestart() or through yy_get_next_buffer.
2581      * In that case, we don't want to reset the lineno or column.
2582      */
2583     if (b != YY_CURRENT_BUFFER){
2584         b->yy_bs_lineno = 1;
2585         b->yy_bs_column = 0;
2586     }
2587
2588         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2589
2590   errno = oerrno;
2591 }
2592
2593 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2594  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2595  *
2596  */
2597     void yy_flush_buffer (YY_BUFFER_STATE  b )
2598 {
2599       if ( ! b )
2600     return;
2601
2602   b->yy_n_chars = 0;
2603
2604   /* We always need two end-of-buffer characters.  The first causes
2605    * a transition to the end-of-buffer state.  The second causes
2606    * a jam in that state.
2607    */
2608   b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2609   b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2610
2611   b->yy_buf_pos = &b->yy_ch_buf[0];
2612
2613   b->yy_at_bol = 1;
2614   b->yy_buffer_status = YY_BUFFER_NEW;
2615
2616   if ( b == YY_CURRENT_BUFFER )
2617     yy_load_buffer_state( );
2618 }
2619
2620 /** Pushes the new state onto the stack. The new state becomes
2621  *  the current state. This function will allocate the stack
2622  *  if necessary.
2623  *  @param new_buffer The new state.
2624  *
2625  */
2626 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
2627 {
2628       if (new_buffer == NULL)
2629     return;
2630
2631   yyensure_buffer_stack();
2632
2633   /* This block is copied from yy_switch_to_buffer. */
2634   if ( YY_CURRENT_BUFFER )
2635     {
2636     /* Flush out information for old buffer. */
2637     *(yy_c_buf_p) = (yy_hold_char);
2638     YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2639     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2640     }
2641
2642   /* Only push if top exists. Otherwise, replace top. */
2643   if (YY_CURRENT_BUFFER)
2644     (yy_buffer_stack_top)++;
2645   YY_CURRENT_BUFFER_LVALUE = new_buffer;
2646
2647   /* copied from yy_switch_to_buffer. */
2648   yy_load_buffer_state( );
2649   (yy_did_buffer_switch_on_eof) = 1;
2650 }
2651
2652 /** Removes and deletes the top of the stack, if present.
2653  *  The next element becomes the new top.
2654  *
2655  */
2656 void yypop_buffer_state (void)
2657 {
2658       if (!YY_CURRENT_BUFFER)
2659     return;
2660
2661   yy_delete_buffer(YY_CURRENT_BUFFER );
2662   YY_CURRENT_BUFFER_LVALUE = NULL;
2663   if ((yy_buffer_stack_top) > 0)
2664     --(yy_buffer_stack_top);
2665
2666   if (YY_CURRENT_BUFFER) {
2667     yy_load_buffer_state( );
2668     (yy_did_buffer_switch_on_eof) = 1;
2669   }
2670 }
2671
2672 /* Allocates the stack if it does not exist.
2673  *  Guarantees space for at least one push.
2674  */
2675 static void yyensure_buffer_stack (void)
2676 {
2677   int num_to_alloc;
2678
2679   if (!(yy_buffer_stack)) {
2680
2681     /* First allocation is just for 2 elements, since we don't know if this
2682      * scanner will even need a stack. We use 2 instead of 1 to avoid an
2683      * immediate realloc on the next call.
2684          */
2685     num_to_alloc = 1;
2686     (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
2687                 (num_to_alloc * sizeof(struct yy_buffer_state*)
2688                 );
2689     if ( ! (yy_buffer_stack) )
2690       YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
2691
2692     memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2693
2694     (yy_buffer_stack_max) = num_to_alloc;
2695     (yy_buffer_stack_top) = 0;
2696     return;
2697   }
2698
2699   if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
2700
2701     /* Increase the buffer to prepare for a possible push. */
2702     int grow_size = 8 /* arbitrary grow size */;
2703
2704     num_to_alloc = (yy_buffer_stack_max) + grow_size;
2705     (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
2706                 ((yy_buffer_stack),
2707                 num_to_alloc * sizeof(struct yy_buffer_state*)
2708                 );
2709     if ( ! (yy_buffer_stack) )
2710       YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
2711
2712     /* zero only the new slots.*/
2713     memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2714     (yy_buffer_stack_max) = num_to_alloc;
2715   }
2716 }
2717
2718 /** Setup the input buffer state to scan directly from a user-specified character buffer.
2719  * @param base the character buffer
2720  * @param size the size in bytes of the character buffer
2721  *
2722  * @return the newly allocated buffer state object.
2723  */
2724 YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
2725 {
2726   YY_BUFFER_STATE b;
2727
2728   if ( size < 2 ||
2729        base[size-2] != YY_END_OF_BUFFER_CHAR ||
2730        base[size-1] != YY_END_OF_BUFFER_CHAR )
2731     /* They forgot to leave room for the EOB's. */
2732     return 0;
2733
2734   b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
2735   if ( ! b )
2736     YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2737
2738   b->yy_buf_size = size - 2;  /* "- 2" to take care of EOB's */
2739   b->yy_buf_pos = b->yy_ch_buf = base;
2740   b->yy_is_our_buffer = 0;
2741   b->yy_input_file = 0;
2742   b->yy_n_chars = b->yy_buf_size;
2743   b->yy_is_interactive = 0;
2744   b->yy_at_bol = 1;
2745   b->yy_fill_buffer = 0;
2746   b->yy_buffer_status = YY_BUFFER_NEW;
2747
2748   yy_switch_to_buffer(b  );
2749
2750   return b;
2751 }
2752
2753 /** Setup the input buffer state to scan a string. The next call to yylex() will
2754  * scan from a @e copy of @a str.
2755  * @param yystr a NUL-terminated string to scan
2756  *
2757  * @return the newly allocated buffer state object.
2758  * @note If you want to scan bytes that may contain NUL values, then use
2759  *       yy_scan_bytes() instead.
2760  */
2761 YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
2762 {
2763
2764   return yy_scan_bytes(yystr,strlen(yystr) );
2765 }
2766
2767 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
2768  * scan from a @e copy of @a bytes.
2769  * @param yybytes the byte buffer to scan
2770  * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
2771  *
2772  * @return the newly allocated buffer state object.
2773  */
2774 YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
2775 {
2776   YY_BUFFER_STATE b;
2777   char *buf;
2778   yy_size_t n;
2779   int i;
2780
2781   /* Get memory for full buffer, including space for trailing EOB's. */
2782   n = _yybytes_len + 2;
2783   buf = (char *) yyalloc(n  );
2784   if ( ! buf )
2785     YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2786
2787   for ( i = 0; i < _yybytes_len; ++i )
2788     buf[i] = yybytes[i];
2789
2790   buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2791
2792   b = yy_scan_buffer(buf,n );
2793   if ( ! b )
2794     YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2795
2796   /* It's okay to grow etc. this buffer, and we should throw it
2797    * away when we're done.
2798    */
2799   b->yy_is_our_buffer = 1;
2800
2801   return b;
2802 }
2803
2804 #ifndef YY_EXIT_FAILURE
2805 #define YY_EXIT_FAILURE 2
2806 #endif
2807
2808 static void yy_fatal_error (yyconst char* msg )
2809 {
2810       (void) fprintf( stderr, "%s\n", msg );
2811   exit( YY_EXIT_FAILURE );
2812 }
2813
2814 /* Redefine yyless() so it works in section 3 code. */
2815
2816 #undef yyless
2817 #define yyless(n) \
2818   do \
2819     { \
2820     /* Undo effects of setting up yytext. */ \
2821         int yyless_macro_arg = (n); \
2822         YY_LESS_LINENO(yyless_macro_arg);\
2823     yytext[yyleng] = (yy_hold_char); \
2824     (yy_c_buf_p) = yytext + yyless_macro_arg; \
2825     (yy_hold_char) = *(yy_c_buf_p); \
2826     *(yy_c_buf_p) = '\0'; \
2827     yyleng = yyless_macro_arg; \
2828     } \
2829   while ( 0 )
2830
2831 /* Accessor  methods (get/set functions) to struct members. */
2832
2833 /** Get the current line number.
2834  *
2835  */
2836 int yyget_lineno  (void)
2837 {
2838
2839     return yylineno;
2840 }
2841
2842 /** Get the input stream.
2843  *
2844  */
2845 FILE *yyget_in  (void)
2846 {
2847         return yyin;
2848 }
2849
2850 /** Get the output stream.
2851  *
2852  */
2853 FILE *yyget_out  (void)
2854 {
2855         return yyout;
2856 }
2857
2858 /** Get the length of the current token.
2859  *
2860  */
2861 int yyget_leng  (void)
2862 {
2863         return yyleng;
2864 }
2865
2866 /** Get the current token.
2867  *
2868  */
2869
2870 char *yyget_text  (void)
2871 {
2872         return yytext;
2873 }
2874
2875 /** Set the current line number.
2876  * @param line_number
2877  *
2878  */
2879 void yyset_lineno (int  line_number )
2880 {
2881
2882     yylineno = line_number;
2883 }
2884
2885 /** Set the input stream. This does not discard the current
2886  * input buffer.
2887  * @param in_str A readable stream.
2888  *
2889  * @see yy_switch_to_buffer
2890  */
2891 void yyset_in (FILE *  in_str )
2892 {
2893         yyin = in_str ;
2894 }
2895
2896 void yyset_out (FILE *  out_str )
2897 {
2898         yyout = out_str ;
2899 }
2900
2901 int yyget_debug  (void)
2902 {
2903         return yy_flex_debug;
2904 }
2905
2906 void yyset_debug (int  bdebug )
2907 {
2908         yy_flex_debug = bdebug ;
2909 }
2910
2911 static int yy_init_globals (void)
2912 {
2913         /* Initialization is the same as for the non-reentrant scanner.
2914      * This function is called from yylex_destroy(), so don't allocate here.
2915      */
2916
2917     /* We do not touch yylineno unless the option is enabled. */
2918     yylineno =  1;
2919
2920     (yy_buffer_stack) = 0;
2921     (yy_buffer_stack_top) = 0;
2922     (yy_buffer_stack_max) = 0;
2923     (yy_c_buf_p) = (char *) 0;
2924     (yy_init) = 0;
2925     (yy_start) = 0;
2926
2927 /* Defined in main.c */
2928 #ifdef YY_STDINIT
2929     yyin = stdin;
2930     yyout = stdout;
2931 #else
2932     yyin = (FILE *) 0;
2933     yyout = (FILE *) 0;
2934 #endif
2935
2936     /* For future reference: Set errno on error, since we are called by
2937      * yylex_init()
2938      */
2939     return 0;
2940 }
2941
2942 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
2943 int yylex_destroy  (void)
2944 {
2945
2946     /* Pop the buffer stack, destroying each element. */
2947   while(YY_CURRENT_BUFFER){
2948     yy_delete_buffer(YY_CURRENT_BUFFER  );
2949     YY_CURRENT_BUFFER_LVALUE = NULL;
2950     yypop_buffer_state();
2951   }
2952
2953   /* Destroy the stack itself. */
2954   yyfree((yy_buffer_stack) );
2955   (yy_buffer_stack) = NULL;
2956
2957     /* Reset the globals. This is important in a non-reentrant scanner so the next time
2958      * yylex() is called, initialization will occur. */
2959     yy_init_globals( );
2960
2961     return 0;
2962 }
2963
2964 /*
2965  * Internal utility routines.
2966  */
2967
2968 #ifndef yytext_ptr
2969 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2970 {
2971   register int i;
2972   for ( i = 0; i < n; ++i )
2973     s1[i] = s2[i];
2974 }
2975 #endif
2976
2977 #ifdef YY_NEED_STRLEN
2978 static int yy_flex_strlen (yyconst char * s )
2979 {
2980   register int n;
2981   for ( n = 0; s[n]; ++n )
2982     ;
2983
2984   return n;
2985 }
2986 #endif
2987
2988 void *yyalloc (yy_size_t  size )
2989 {
2990   return (void *) malloc( size );
2991 }
2992
2993 void *yyrealloc  (void * ptr, yy_size_t  size )
2994 {
2995   /* The cast to (char *) in the following accommodates both
2996    * implementations that use char* generic pointers, and those
2997    * that use void* generic pointers.  It works with the latter
2998    * because both ANSI C and C++ allow castless assignment from
2999    * any pointer type to void*, and deal with argument conversions
3000    * as though doing an assignment.
3001    */
3002   return (void *) realloc( (char *) ptr, size );
3003 }
3004
3005 void yyfree (void * ptr )
3006 {
3007   free( (char *) ptr );  /* see yyrealloc() for (char *) cast */
3008 }
3009
3010 #define YYTABLES_NAME "yytables"
3011
3012 #line 268 "vtkParse.l"
3013
3014
3015
3016