linux/scripts/dtc/dtc-lexer.lex.c_shipped
<<
>>
Prefs
   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>
  43typedef int8_t flex_int8_t;
  44typedef uint8_t flex_uint8_t;
  45typedef int16_t flex_int16_t;
  46typedef uint16_t flex_uint16_t;
  47typedef int32_t flex_int32_t;
  48typedef uint32_t flex_uint32_t;
  49#else
  50typedef signed char flex_int8_t;
  51typedef short int flex_int16_t;
  52typedef int flex_int32_t;
  53typedef unsigned char flex_uint8_t; 
  54typedef unsigned short int flex_uint16_t;
  55typedef 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
 152typedef struct yy_buffer_state *YY_BUFFER_STATE;
 153#endif
 154
 155extern int yyleng;
 156
 157extern 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
 183typedef size_t yy_size_t;
 184#endif
 185
 186#ifndef YY_STRUCT_YY_BUFFER_STATE
 187#define YY_STRUCT_YY_BUFFER_STATE
 188struct 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. */
 252static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
 253static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
 254static 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. */
 272static char yy_hold_char;
 273static int yy_n_chars;          /* number of characters read into yy_ch_buf */
 274int yyleng;
 275
 276/* Points to current character in buffer. */
 277static char *yy_c_buf_p = (char *) 0;
 278static int yy_init = 0;         /* whether we need to initialize */
 279static 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 */
 284static int yy_did_buffer_switch_on_eof;
 285
 286void yyrestart (FILE *input_file  );
 287void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
 288YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
 289void yy_delete_buffer (YY_BUFFER_STATE b  );
 290void yy_flush_buffer (YY_BUFFER_STATE b  );
 291void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
 292void yypop_buffer_state (void );
 293
 294static void yyensure_buffer_stack (void );
 295static void yy_load_buffer_state (void );
 296static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
 297
 298#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
 299
 300YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
 301YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
 302YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );
 303
 304void *yyalloc (yy_size_t  );
 305void *yyrealloc (void *,yy_size_t  );
 306void 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
 337typedef unsigned char YY_CHAR;
 338
 339FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
 340
 341typedef int yy_state_type;
 342
 343extern int yylineno;
 344
 345int yylineno = 1;
 346
 347extern char *yytext;
 348#define yytext_ptr yytext
 349
 350static yy_state_type yy_get_previous_state (void );
 351static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
 352static int yy_get_next_buffer (void );
 353static 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. */
 369struct yy_trans_info
 370        {
 371        flex_int32_t yy_verify;
 372        flex_int32_t yy_nxt;
 373        };
 374static 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
 389static 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
 421static 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
 429static 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
 445static 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
 461static 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
 495static 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
 529static yy_state_type yy_last_accepting_state;
 530static char *yy_last_accepting_cpos;
 531
 532extern int yy_flex_debug;
 533int 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
 542char *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
 568YYLTYPE 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
 584static int dts_version = 1;
 585
 586#define BEGIN_DEFAULT()         DPRINT("<V1>\n"); \
 587                                BEGIN(V1); \
 588
 589static void push_input_file(const char *filename);
 590static 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
 610static int yy_init_globals (void );
 611
 612/* Accessor methods to globals.
 613   These are made visible to non-reentrant scanners for convenience. */
 614
 615int yylex_destroy (void );
 616
 617int yyget_debug (void );
 618
 619void yyset_debug (int debug_flag  );
 620
 621YY_EXTRA_TYPE yyget_extra (void );
 622
 623void yyset_extra (YY_EXTRA_TYPE user_defined  );
 624
 625FILE *yyget_in (void );
 626
 627void yyset_in  (FILE * in_str  );
 628
 629FILE *yyget_out (void );
 630
 631void yyset_out  (FILE * out_str  );
 632
 633int yyget_leng (void );
 634
 635char *yyget_text (void );
 636
 637int yyget_lineno (void );
 638
 639void 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
 647extern "C" int yywrap (void );
 648#else
 649extern int yywrap (void );
 650#endif
 651#endif
 652
 653#ifndef yytext_ptr
 654static void yy_flex_strncpy (char *,yyconst char *,int );
 655#endif
 656
 657#ifdef YY_NEED_STRLEN
 658static int yy_flex_strlen (yyconst char * );
 659#endif
 660
 661#ifndef YY_NO_INPUT
 662
 663#ifdef __cplusplus
 664static int yyinput (void );
 665#else
 666static 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
 746extern 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 */
 768YY_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);
 813yy_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
 835yy_find_action:
 836                yy_act = yy_accept[yy_current_state];
 837
 838                YY_DO_BEFORE_ACTION;
 839
 840do_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
 851case 1:
 852/* rule 1 can match eol */
 853YY_RULE_SETUP
 854{
 855                        char *name = strchr(yytext, '\"') + 1;
 856                        yytext[yyleng-1] = '\0';
 857                        push_input_file(name);
 858                }
 859        YY_BREAK
 860case YY_STATE_EOF(INITIAL):
 861case YY_STATE_EOF(INCLUDE):
 862case YY_STATE_EOF(BYTESTRING):
 863case YY_STATE_EOF(PROPNODENAME):
 864case YY_STATE_EOF(V1):
 865{
 866                        if (!pop_input_file()) {
 867                                yyterminate();
 868                        }
 869                }
 870        YY_BREAK
 871case 2:
 872/* rule 2 can match eol */
 873YY_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
 881case 3:
 882YY_RULE_SETUP
 883{
 884                        DPRINT("Keyword: /dts-v1/\n");
 885                        dts_version = 1;
 886                        BEGIN_DEFAULT();
 887                        return DT_V1;
 888                }
 889        YY_BREAK
 890case 4:
 891YY_RULE_SETUP
 892{
 893                        DPRINT("Keyword: /memreserve/\n");
 894                        BEGIN_DEFAULT();
 895                        return DT_MEMRESERVE;
 896                }
 897        YY_BREAK
 898case 5:
 899YY_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
 907case 6:
 908YY_RULE_SETUP
 909{
 910                        yylval.literal = xstrdup(yytext);
 911                        DPRINT("Literal: '%s'\n", yylval.literal);
 912                        return DT_LITERAL;
 913                }
 914        YY_BREAK
 915case 7:
 916YY_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
 923case 8:
 924YY_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
 932case 9:
 933YY_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
 940case 10:
 941YY_RULE_SETUP
 942{
 943                        DPRINT("/BYTESTRING\n");
 944                        BEGIN_DEFAULT();
 945                        return ']';
 946                }
 947        YY_BREAK
 948case 11:
 949YY_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
 957case 12:
 958YY_RULE_SETUP
 959{
 960                        DPRINT("Binary Include\n");
 961                        return DT_INCBIN;
 962                }
 963        YY_BREAK
 964case 13:
 965/* rule 13 can match eol */
 966YY_RULE_SETUP
 967/* eat whitespace */
 968        YY_BREAK
 969case 14:
 970/* rule 14 can match eol */
 971YY_RULE_SETUP
 972/* eat C-style comments */
 973        YY_BREAK
 974case 15:
 975/* rule 15 can match eol */
 976YY_RULE_SETUP
 977/* eat C++-style comments */
 978        YY_BREAK
 979case 16:
 980YY_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
 996case 17:
 997YY_RULE_SETUP
 998ECHO;
 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 */
1138static 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
1454static 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 */
1572void 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 */
1602void 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 */
1621static 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 */
1670YY_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 */
1707YY_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 */
1720YY_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
1754static 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 */
1782int yyget_lineno  (void)
1783{
1784        
1785    return yylineno;
1786}
1787
1788/** Get the input stream.
1789 * 
1790 */
1791FILE *yyget_in  (void)
1792{
1793        return yyin;
1794}
1795
1796/** Get the output stream.
1797 * 
1798 */
1799FILE *yyget_out  (void)
1800{
1801        return yyout;
1802}
1803
1804/** Get the length of the current token.
1805 * 
1806 */
1807int yyget_leng  (void)
1808{
1809        return yyleng;
1810}
1811
1812/** Get the current token.
1813 * 
1814 */
1815
1816char *yyget_text  (void)
1817{
1818        return yytext;
1819}
1820
1821/** Set the current line number.
1822 * @param line_number
1823 * 
1824 */
1825void 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 */
1837void yyset_in (FILE *  in_str )
1838{
1839        yyin = in_str ;
1840}
1841
1842void yyset_out (FILE *  out_str )
1843{
1844        yyout = out_str ;
1845}
1846
1847int yyget_debug  (void)
1848{
1849        return yy_flex_debug;
1850}
1851
1852void yyset_debug (int  bdebug )
1853{
1854        yy_flex_debug = bdebug ;
1855}
1856
1857static 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. */
1886int 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
1912static 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
1921static 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
1931void *yyalloc (yy_size_t  size )
1932{
1933        return (void *) malloc( size );
1934}
1935
1936void *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
1948void yyfree (void * ptr )
1949{
1950        free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
1951}
1952
1953#define YYTABLES_NAME "yytables"
1954
1955static 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
1966static 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
1977
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.