binutils/arlex.c

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