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