scripts/dtc/dtc-lexer.lex.c_shipped

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