src/ldlex.c

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