contrib/binutils-2.17/gas/itbl-lex.c

   1 /* A lexical scanner generated by flex */
   2
   3 /* Scanner skeleton version:
   4  * $Header: /cvs/src/src/gas/Attic/itbl-lex.c,v 1.1.16.1 2006/04/16 18:36:43 drow Exp $
   5  */
   6
   7 #define FLEX_SCANNER
   8 #define YY_FLEX_MAJOR_VERSION 2
   9 #define YY_FLEX_MINOR_VERSION 5
  10
  11 #include <stdio.h>
  12 #include <errno.h>
  13
  14 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  15 #ifdef c_plusplus
  16 #ifndef __cplusplus
  17 #define __cplusplus
  18 #endif
  19 #endif
  20
  21
  22 #ifdef __cplusplus
  23
  24 #include <stdlib.h>
  25 #ifndef _WIN32
  26 #include <unistd.h>
  27 #endif
  28
  29 /* Use prototypes in function declarations. */
  30 #define YY_USE_PROTOS
  31
  32 /* The "const" storage-class-modifier is valid. */
  33 #define YY_USE_CONST
  34
  35 #else   /* ! __cplusplus */
  36
  37 #if __STDC__
  38
  39 #define YY_USE_PROTOS
  40 #define YY_USE_CONST
  41
  42 #endif  /* __STDC__ */
  43 #endif  /* ! __cplusplus */
  44
  45 #ifdef __TURBOC__
  46  #pragma warn -rch
  47  #pragma warn -use
  48 #include <io.h>
  49 #include <stdlib.h>
  50 #define YY_USE_CONST
  51 #define YY_USE_PROTOS
  52 #endif
  53
  54 #ifdef YY_USE_CONST
  55 #define yyconst const
  56 #else
  57 #define yyconst
  58 #endif
  59
  60
  61 #ifdef YY_USE_PROTOS
  62 #define YY_PROTO(proto) proto
  63 #else
  64 #define YY_PROTO(proto) ()
  65 #endif
  66
  67
  68 /* Returned upon end-of-file. */
  69 #define YY_NULL 0
  70
  71 /* Promotes a possibly negative, possibly signed char to an unsigned
  72  * integer for use as an array index.  If the signed char is negative,
  73  * we want to instead treat it as an 8-bit unsigned char, hence the
  74  * double cast.
  75  */
  76 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
  77
  78 /* Enter a start condition.  This macro really ought to take a parameter,
  79  * but we do it the disgusting crufty way forced on us by the ()-less
  80  * definition of BEGIN.
  81  */
  82 #define BEGIN yy_start = 1 + 2 *
  83
  84 /* Translate the current start state into a value that can be later handed
  85  * to BEGIN to return to the state.  The YYSTATE alias is for lex
  86  * compatibility.
  87  */
  88 #define YY_START ((yy_start - 1) / 2)
  89 #define YYSTATE YY_START
  90
  91 /* Action number for EOF rule of a given start state. */
  92 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
  93
  94 /* Special action meaning "start processing a new file". */
  95 #define YY_NEW_FILE yyrestart( yyin )
  96
  97 #define YY_END_OF_BUFFER_CHAR 0
  98
  99 /* Size of default input buffer. */
 100 #define YY_BUF_SIZE 16384
 101
 102 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 103
 104 extern int yyleng;
 105 extern FILE *yyin, *yyout;
 106
 107 #define EOB_ACT_CONTINUE_SCAN 0
 108 #define EOB_ACT_END_OF_FILE 1
 109 #define EOB_ACT_LAST_MATCH 2
 110
 111 /* The funky do-while in the following #define is used to turn the definition
 112  * int a single C statement (which needs a semi-colon terminator).  This
 113  * avoids problems with code like:
 114  *
 115  *      if ( condition_holds )
 116  *              yyless( 5 );
 117  *      else
 118  *              do_something_else();
 119  *
 120  * Prior to using the do-while the compiler would get upset at the
 121  * "else" because it interpreted the "if" statement as being all
 122  * done when it reached the ';' after the yyless() call.
 123  */
 124
 125 /* Return all but the first 'n' matched characters back to the input stream. */
 126
 127 #define yyless(n) \
 128         do \
 129                 { \
 130                 /* Undo effects of setting up yytext. */ \
 131                 *yy_cp = yy_hold_char; \
 132                 YY_RESTORE_YY_MORE_OFFSET \
 133                 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
 134                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
 135                 } \
 136         while ( 0 )
 137
 138 #define unput(c) yyunput( c, yytext_ptr )
 139
 140 /* The following is because we cannot portably get our hands on size_t
 141  * (without autoconf's help, which isn't available because we want
 142  * flex-generated scanners to compile on their own).
 143  */
 144 typedef unsigned int yy_size_t;
 145
 146
 147 struct yy_buffer_state
 148         {
 149         FILE *yy_input_file;
 150
 151         char *yy_ch_buf;                /* input buffer */
 152         char *yy_buf_pos;               /* current position in input buffer */
 153
 154         /* Size of input buffer in bytes, not including room for EOB
 155          * characters.
 156          */
 157         yy_size_t yy_buf_size;
 158
 159         /* Number of characters read into yy_ch_buf, not including EOB
 160          * characters.
 161          */
 162         int yy_n_chars;
 163
 164         /* Whether we "own" the buffer - i.e., we know we created it,
 165          * and can realloc() it to grow it, and should free() it to
 166          * delete it.
 167          */
 168         int yy_is_our_buffer;
 169
 170         /* Whether this is an "interactive" input source; if so, and
 171          * if we're using stdio for input, then we want to use getc()
 172          * instead of fread(), to make sure we stop fetching input after
 173          * each newline.
 174          */
 175         int yy_is_interactive;
 176
 177         /* Whether we're considered to be at the beginning of a line.
 178          * If so, '^' rules will be active on the next match, otherwise
 179          * not.
 180          */
 181         int yy_at_bol;
 182
 183         /* Whether to try to fill the input buffer when we reach the
 184          * end of it.
 185          */
 186         int yy_fill_buffer;
 187
 188         int yy_buffer_status;
 189 #define YY_BUFFER_NEW 0
 190 #define YY_BUFFER_NORMAL 1
 191         /* When an EOF's been seen but there's still some text to process
 192          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 193          * shouldn't try reading from the input source any more.  We might
 194          * still have a bunch of tokens to match, though, because of
 195          * possible backing-up.
 196          *
 197          * When we actually see the EOF, we change the status to "new"
 198          * (via yyrestart()), so that the user can continue scanning by
 199          * just pointing yyin at a new input file.
 200          */
 201 #define YY_BUFFER_EOF_PENDING 2
 202         };
 203
 204 static YY_BUFFER_STATE yy_current_buffer = 0;
 205
 206 /* We provide macros for accessing buffer states in case in the
 207  * future we want to put the buffer states in a more general
 208  * "scanner state".
 209  */
 210 #define YY_CURRENT_BUFFER yy_current_buffer
 211
 212
 213 /* yy_hold_char holds the character lost when yytext is formed. */
 214 static char yy_hold_char;
 215
 216 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
 217
 218
 219 int yyleng;
 220
 221 /* Points to current character in buffer. */
 222 static char *yy_c_buf_p = (char *) 0;
 223 static int yy_init = 1;         /* whether we need to initialize */
 224 static int yy_start = 0;        /* start state number */
 225
 226 /* Flag which is used to allow yywrap()'s to do buffer switches
 227  * instead of setting up a fresh yyin.  A bit of a hack ...
 228  */
 229 static int yy_did_buffer_switch_on_eof;
 230
 231 void yyrestart YY_PROTO(( FILE *input_file ));
 232
 233 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
 234 void yy_load_buffer_state YY_PROTO(( void ));
 235 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
 236 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
 237 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
 238 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
 239 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
 240
 241 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
 242 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
 243 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
 244
 245 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
 246 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
 247 static void yy_flex_free YY_PROTO(( void * ));
 248
 249 #define yy_new_buffer yy_create_buffer
 250
 251 #define yy_set_interactive(is_interactive) \
 252         { \
 253         if ( ! yy_current_buffer ) \
 254                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
 255         yy_current_buffer->yy_is_interactive = is_interactive; \
 256         }
 257
 258 #define yy_set_bol(at_bol) \
 259         { \
 260         if ( ! yy_current_buffer ) \
 261                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
 262         yy_current_buffer->yy_at_bol = at_bol; \
 263         }
 264
 265 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
 266
 267 typedef unsigned char YY_CHAR;
 268 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
 269 typedef int yy_state_type;
 270 extern char *yytext;
 271 #define yytext_ptr yytext
 272
 273 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
 274 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
 275 static int yy_get_next_buffer YY_PROTO(( void ));
 276 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
 277
 278 /* Done after the current pattern has been matched and before the
 279  * corresponding action - sets up yytext.
 280  */
 281 #define YY_DO_BEFORE_ACTION \
 282         yytext_ptr = yy_bp; \
 283         yyleng = (int) (yy_cp - yy_bp); \
 284         yy_hold_char = *yy_cp; \
 285         *yy_cp = '\0'; \
 286         yy_c_buf_p = yy_cp;
 287
 288 #define YY_NUM_RULES 15
 289 #define YY_END_OF_BUFFER 16
 290 static yyconst short int yy_accept[60] =
 291     {   0,
 292         0,    0,   16,   14,   13,   12,   11,    8,    8,   10,
 293        10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
 294        10,    8,    0,   10,   10,   10,   10,   10,   10,   10,
 295        10,   10,   10,   10,   10,   10,    7,    9,   10,   10,
 296        10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
 297         5,    1,    2,    3,   10,    6,   10,    4,    0
 298     } ;
 299
 300 static yyconst int yy_ec[256] =
 301     {   0,
 302         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 303         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 304         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 305         1,    4,    1,    1,    5,    1,    1,    1,    1,    1,
 306         1,    1,    1,    1,    1,    1,    1,    6,    7,    7,
 307         7,    7,    7,    7,    7,    7,    7,    1,    8,    1,
 308         1,    1,    1,    1,    9,   10,   11,   12,   13,   10,
 309        14,   15,   16,   15,   15,   15,   17,   18,   15,   15,
 310        15,   19,   20,   15,   15,   15,   15,   15,   15,   15,
 311         1,    1,    1,    1,   15,    1,   21,   10,   22,   23,
 312
 313        24,   10,   25,   15,   26,   15,   15,   15,   27,   28,
 314        15,   29,   15,   30,   31,   15,   15,   15,   15,   32,
 315        15,   15,    1,    1,    1,    1,    1,    1,    1,    1,
 316         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 317         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 318         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 319         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 320         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 321         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 322         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 323
 324         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 325         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 326         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 327         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 328         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 329         1,    1,    1,    1,    1
 330     } ;
 331
 332 static yyconst int yy_meta[33] =
 333     {   0,
 334         1,    1,    1,    1,    1,    2,    2,    1,    2,    2,
 335         2,    2,    2,    3,    3,    3,    3,    3,    3,    3,
 336         2,    2,    2,    2,    3,    3,    3,    3,    3,    3,
 337         3,    3
 338     } ;
 339
 340 static yyconst short int yy_base[62] =
 341     {   0,
 342         0,    0,   83,   84,   84,   84,   84,   27,   29,   70,
 343         0,   62,   61,   60,   20,   55,   47,   46,   45,   12,
 344        35,   37,    0,    0,   62,   60,   59,   58,   53,   49,
 345        45,   43,   42,   41,   37,   32,    0,    0,   43,   44,
 346        43,   42,   42,   36,   23,   27,   26,   25,   25,   20,
 347         0,    0,    0,    0,   35,    0,   23,    0,   84,   58,
 348        43
 349     } ;
 350
 351 static yyconst short int yy_def[62] =
 352     {   0,
 353        59,    1,   59,   59,   59,   59,   59,   59,   59,   60,
 354        60,   60,   60,   60,   60,   60,   60,   60,   60,   60,
 355        60,   59,   61,   60,   60,   60,   60,   60,   60,   60,
 356        60,   60,   60,   60,   60,   60,   60,   61,   60,   60,
 357        60,   60,   60,   60,   60,   60,   60,   60,   60,   60,
 358        60,   60,   60,   60,   60,   60,   60,   60,    0,   59,
 359        59
 360     } ;
 361
 362 static yyconst short int yy_nxt[117] =
 363     {   0,
 364         4,    5,    6,    5,    7,    8,    9,    7,   10,   11,
 365        12,   13,   11,   14,   11,   15,   11,   11,   11,   11,
 366        16,   17,   18,   11,   19,   20,   11,   11,   21,   11,
 367        11,   11,   22,   22,   22,   22,   29,   30,   35,   36,
 368        37,   37,   22,   22,   38,   58,   58,   56,   57,   54,
 369        53,   52,   51,   56,   55,   54,   53,   52,   23,   24,
 370        24,   51,   50,   49,   48,   47,   46,   45,   44,   43,
 371        42,   41,   40,   39,   34,   33,   32,   31,   28,   27,
 372        26,   25,   59,    3,   59,   59,   59,   59,   59,   59,
 373        59,   59,   59,   59,   59,   59,   59,   59,   59,   59,
 374
 375        59,   59,   59,   59,   59,   59,   59,   59,   59,   59,
 376        59,   59,   59,   59,   59,   59
 377     } ;
 378
 379 static yyconst short int yy_chk[117] =
 380     {   0,
 381         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 382         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 383         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 384         1,    1,    8,    8,    9,    9,   15,   15,   20,   20,
 385        21,   21,   22,   22,   61,   57,   55,   50,   49,   48,
 386        47,   46,   45,   44,   43,   42,   41,   40,    8,   60,
 387        60,   39,   36,   35,   34,   33,   32,   31,   30,   29,
 388        28,   27,   26,   25,   19,   18,   17,   16,   14,   13,
 389        12,   10,    3,   59,   59,   59,   59,   59,   59,   59,
 390        59,   59,   59,   59,   59,   59,   59,   59,   59,   59,
 391
 392        59,   59,   59,   59,   59,   59,   59,   59,   59,   59,
 393        59,   59,   59,   59,   59,   59
 394     } ;
 395
 396 static yy_state_type yy_last_accepting_state;
 397 static char *yy_last_accepting_cpos;
 398
 399 /* The intent behind this definition is that it'll catch
 400  * any uses of REJECT which flex missed.
 401  */
 402 #define REJECT reject_used_but_not_detected
 403 #define yymore() yymore_used_but_not_detected
 404 #define YY_MORE_ADJ 0
 405 #define YY_RESTORE_YY_MORE_OFFSET
 406 char *yytext;
 407 #line 1 "itbl-lex.l"
 408 #define INITIAL 0
 409 /* itbl-lex.l
 410    Copyright 1997, 1998, 2001, 2002, 2005 Free Software Foundation, Inc.
 411
 412    This file is part of GAS, the GNU Assembler.
 413
 414    GAS is free software; you can redistribute it and/or modify
 415    it under the terms of the GNU General Public License as published by
 416    the Free Software Foundation; either version 2, or (at your option)
 417    any later version.
 418
 419    GAS is distributed in the hope that it will be useful,
 420    but WITHOUT ANY WARRANTY; without even the implied warranty of
 421    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 422    GNU General Public License for more details.
 423
 424    You should have received a copy of the GNU General Public License
 425    along with GAS; see the file COPYING.  If not, write to the Free
 426    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
 427    02110-1301, USA.  */
 428 #line 22 "itbl-lex.l"
 429 #include <stdio.h>
 430 #include <string.h>
 431 #include <stdlib.h>
 432
 433 #include "itbl-lex.h"
 434 #include <itbl-parse.h>
 435
 436 #ifdef DEBUG
 437 #define DBG(x) printf x
 438 #define MDBG(x) printf x
 439 #else
 440 #define DBG(x)
 441 #define MDBG(x)
 442 #endif
 443
 444 int insntbl_line = 1;
 445 #line 446 "itbl-lex.c"
 446
 447 /* Macros after this point can all be overridden by user definitions in
 448  * section 1.
 449  */
 450
 451 #ifndef YY_SKIP_YYWRAP
 452 #ifdef __cplusplus
 453 extern "C" int yywrap YY_PROTO(( void ));
 454 #else
 455 extern int yywrap YY_PROTO(( void ));
 456 #endif
 457 #endif
 458
 459 #ifndef YY_NO_UNPUT
 460 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
 461 #endif
 462
 463 #ifndef yytext_ptr
 464 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
 465 #endif
 466
 467 #ifdef YY_NEED_STRLEN
 468 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
 469 #endif
 470
 471 #ifndef YY_NO_INPUT
 472 #ifdef __cplusplus
 473 static int yyinput YY_PROTO(( void ));
 474 #else
 475 static int input YY_PROTO(( void ));
 476 #endif
 477 #endif
 478
 479 #if YY_STACK_USED
 480 static int yy_start_stack_ptr = 0;
 481 static int yy_start_stack_depth = 0;
 482 static int *yy_start_stack = 0;
 483 #ifndef YY_NO_PUSH_STATE
 484 static void yy_push_state YY_PROTO(( int new_state ));
 485 #endif
 486 #ifndef YY_NO_POP_STATE
 487 static void yy_pop_state YY_PROTO(( void ));
 488 #endif
 489 #ifndef YY_NO_TOP_STATE
 490 static int yy_top_state YY_PROTO(( void ));
 491 #endif
 492
 493 #else
 494 #define YY_NO_PUSH_STATE 1
 495 #define YY_NO_POP_STATE 1
 496 #define YY_NO_TOP_STATE 1
 497 #endif
 498
 499 #ifdef YY_MALLOC_DECL
 500 YY_MALLOC_DECL
 501 #else
 502 #if __STDC__
 503 #ifndef __cplusplus
 504 #include <stdlib.h>
 505 #endif
 506 #else
 507 /* Just try to get by without declaring the routines.  This will fail
 508  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
 509  * or sizeof(void*) != sizeof(int).
 510  */
 511 #endif
 512 #endif
 513
 514 /* Amount of stuff to slurp up with each read. */
 515 #ifndef YY_READ_BUF_SIZE
 516 #define YY_READ_BUF_SIZE 8192
 517 #endif
 518
 519 /* Copy whatever the last rule matched to the standard output. */
 520
 521 #ifndef ECHO
 522 /* This used to be an fputs(), but since the string might contain NUL's,
 523  * we now use fwrite().
 524  */
 525 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
 526 #endif
 527
 528 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 529  * is returned in "result".
 530  */
 531 #ifndef YY_INPUT
 532 #define YY_INPUT(buf,result,max_size) \
 533         if ( yy_current_buffer->yy_is_interactive ) \
 534                 { \
 535                 int c = '*', n; \
 536                 for ( n = 0; n < max_size && \
 537                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
 538                         buf[n] = (char) c; \
 539                 if ( c == '\n' ) \
 540                         buf[n++] = (char) c; \
 541                 if ( c == EOF && ferror( yyin ) ) \
 542                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
 543                 result = n; \
 544                 } \
 545         else \
 546                 { \
 547                 errno=0; \
 548                 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
 549                         { \
 550                         if( errno != EINTR) \
 551                                 { \
 552                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
 553                                 break; \
 554                                 } \
 555                         errno=0; \
 556                         clearerr(yyin); \
 557                         } \
 558                 }
 559 #endif
 560
 561 /* No semi-colon after return; correct usage is to write "yyterminate();" -
 562  * we don't want an extra ';' after the "return" because that will cause
 563  * some compilers to complain about unreachable statements.
 564  */
 565 #ifndef yyterminate
 566 #define yyterminate() return YY_NULL
 567 #endif
 568
 569 /* Number of entries by which start-condition stack grows. */
 570 #ifndef YY_START_STACK_INCR
 571 #define YY_START_STACK_INCR 25
 572 #endif
 573
 574 /* Report a fatal error. */
 575 #ifndef YY_FATAL_ERROR
 576 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 577 #endif
 578
 579 /* Default declaration of generated scanner - a define so the user can
 580  * easily add parameters.
 581  */
 582 #ifndef YY_DECL
 583 #define YY_DECL int yylex YY_PROTO(( void ))
 584 #endif
 585
 586 /* Code executed at the beginning of each rule, after yytext and yyleng
 587  * have been set up.
 588  */
 589 #ifndef YY_USER_ACTION
 590 #define YY_USER_ACTION
 591 #endif
 592
 593 /* Code executed at the end of each rule. */
 594 #ifndef YY_BREAK
 595 #define YY_BREAK break;
 596 #endif
 597
 598 #define YY_RULE_SETUP \
 599         YY_USER_ACTION
 600
 601 YY_DECL
 602         {
 603         register yy_state_type yy_current_state;
 604         register char *yy_cp, *yy_bp;
 605         register int yy_act;
 606
 607 #line 45 "itbl-lex.l"
 608
 609
 610 #line 611 "itbl-lex.c"
 611
 612         if ( yy_init )
 613                 {
 614                 yy_init = 0;
 615
 616 #ifdef YY_USER_INIT
 617                 YY_USER_INIT;
 618 #endif
 619
 620                 if ( ! yy_start )
 621                         yy_start = 1;   /* first start state */
 622
 623                 if ( ! yyin )
 624                         yyin = stdin;
 625
 626                 if ( ! yyout )
 627                         yyout = stdout;
 628
 629                 if ( ! yy_current_buffer )
 630                         yy_current_buffer =
 631                                 yy_create_buffer( yyin, YY_BUF_SIZE );
 632
 633                 yy_load_buffer_state();
 634                 }
 635
 636         while ( 1 )             /* loops until end-of-file is reached */
 637                 {
 638                 yy_cp = yy_c_buf_p;
 639
 640                 /* Support of yytext. */
 641                 *yy_cp = yy_hold_char;
 642
 643                 /* yy_bp points to the position in yy_ch_buf of the start of
 644                  * the current run.
 645                  */
 646                 yy_bp = yy_cp;
 647
 648                 yy_current_state = yy_start;
 649 yy_match:
 650                 do
 651                         {
 652                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
 653                         if ( yy_accept[yy_current_state] )
 654                                 {
 655                                 yy_last_accepting_state = yy_current_state;
 656                                 yy_last_accepting_cpos = yy_cp;
 657                                 }
 658                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 659                                 {
 660                                 yy_current_state = (int) yy_def[yy_current_state];
 661                                 if ( yy_current_state >= 60 )
 662                                         yy_c = yy_meta[(unsigned int) yy_c];
 663                                 }
 664                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 665                         ++yy_cp;
 666                         }
 667                 while ( yy_base[yy_current_state] != 84 );
 668
 669 yy_find_action:
 670                 yy_act = yy_accept[yy_current_state];
 671                 if ( yy_act == 0 )
 672                         { /* have to back up */
 673                         yy_cp = yy_last_accepting_cpos;
 674                         yy_current_state = yy_last_accepting_state;
 675                         yy_act = yy_accept[yy_current_state];
 676                         }
 677
 678                 YY_DO_BEFORE_ACTION;
 679
 680
 681 do_action:      /* This label is used only to access EOF actions. */
 682
 683
 684                 switch ( yy_act )
 685         { /* beginning of action switch */
 686                         case 0: /* must back up */
 687                         /* undo the effects of YY_DO_BEFORE_ACTION */
 688                         *yy_cp = yy_hold_char;
 689                         yy_cp = yy_last_accepting_cpos;
 690                         yy_current_state = yy_last_accepting_state;
 691                         goto yy_find_action;
 692
 693 case 1:
 694 YY_RULE_SETUP
 695 #line 47 "itbl-lex.l"
 696 {
 697     return CREG;
 698   }
 699         YY_BREAK
 700 case 2:
 701 YY_RULE_SETUP
 702 #line 50 "itbl-lex.l"
 703 {
 704     return DREG;
 705   }
 706         YY_BREAK
 707 case 3:
 708 YY_RULE_SETUP
 709 #line 53 "itbl-lex.l"
 710 {
 711     return GREG;
 712   }
 713         YY_BREAK
 714 case 4:
 715 YY_RULE_SETUP
 716 #line 56 "itbl-lex.l"
 717 {
 718     return IMMED;
 719   }
 720         YY_BREAK
 721 case 5:
 722 YY_RULE_SETUP
 723 #line 59 "itbl-lex.l"
 724 {
 725     return ADDR;
 726   }
 727         YY_BREAK
 728 case 6:
 729 YY_RULE_SETUP
 730 #line 62 "itbl-lex.l"
 731 {
 732     return INSN;
 733   }
 734         YY_BREAK
 735 case 7:
 736 YY_RULE_SETUP
 737 #line 65 "itbl-lex.l"
 738 {
 739     yytext[yyleng] = 0;
 740     yylval.processor = strtoul (yytext+1, 0, 0);
 741     return PNUM;
 742   }
 743         YY_BREAK
 744 case 8:
 745 YY_RULE_SETUP
 746 #line 70 "itbl-lex.l"
 747 {
 748     yytext[yyleng] = 0;
 749     yylval.num = strtoul (yytext, 0, 0);
 750     return NUM;
 751   }
 752         YY_BREAK
 753 case 9:
 754 YY_RULE_SETUP
 755 #line 75 "itbl-lex.l"
 756 {
 757     yytext[yyleng] = 0;
 758     yylval.num = strtoul (yytext, 0, 0);
 759     return NUM;
 760   }
 761         YY_BREAK
 762 case 10:
 763 YY_RULE_SETUP
 764 #line 80 "itbl-lex.l"
 765 {
 766     yytext[yyleng] = 0;
 767     yylval.str = strdup (yytext);
 768     return ID;
 769   }
 770         YY_BREAK
 771 case 11:
 772 YY_RULE_SETUP
 773 #line 85 "itbl-lex.l"
 774 {
 775     int c;
 776     while ((c = input ()) !=  EOF)
 777       {
 778         if (c ==  '\n')
 779         {
 780                 unput (c);
 781                 break;
 782         }
 783       }
 784   }
 785         YY_BREAK
 786 case 12:
 787 YY_RULE_SETUP
 788 #line 96 "itbl-lex.l"
 789 {
 790     insntbl_line++;
 791     MDBG (("in lex, NL = %d (x%x)\n", NL, NL));
 792     return NL;
 793   }
 794         YY_BREAK
 795 case 13:
 796 YY_RULE_SETUP
 797 #line 101 "itbl-lex.l"
 798 {
 799   }
 800         YY_BREAK
 801 case 14:
 802 YY_RULE_SETUP
 803 #line 103 "itbl-lex.l"
 804 {
 805     MDBG (("char = %x, %d\n", yytext[0], yytext[0]));
 806     return yytext[0];
 807   }
 808         YY_BREAK
 809 case 15:
 810 YY_RULE_SETUP
 811 #line 107 "itbl-lex.l"
 812 ECHO;
 813         YY_BREAK
 814 #line 815 "itbl-lex.c"
 815 case YY_STATE_EOF(INITIAL):
 816         yyterminate();
 817
 818         case YY_END_OF_BUFFER:
 819                 {
 820                 /* Amount of text matched not including the EOB char. */
 821                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
 822
 823                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
 824                 *yy_cp = yy_hold_char;
 825                 YY_RESTORE_YY_MORE_OFFSET
 826
 827                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
 828                         {
 829                         /* We're scanning a new file or input source.  It's
 830                          * possible that this happened because the user
 831                          * just pointed yyin at a new source and called
 832                          * yylex().  If so, then we have to assure
 833                          * consistency between yy_current_buffer and our
 834                          * globals.  Here is the right place to do so, because
 835                          * this is the first action (other than possibly a
 836                          * back-up) that will match for the new input source.
 837                          */
 838                         yy_n_chars = yy_current_buffer->yy_n_chars;
 839                         yy_current_buffer->yy_input_file = yyin;
 840                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
 841                         }
 842
 843                 /* Note that here we test for yy_c_buf_p "<=" to the position
 844                  * of the first EOB in the buffer, since yy_c_buf_p will
 845                  * already have been incremented past the NUL character
 846                  * (since all states make transitions on EOB to the
 847                  * end-of-buffer state).  Contrast this with the test
 848                  * in input().
 849                  */
 850                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
 851                         { /* This was really a NUL. */
 852                         yy_state_type yy_next_state;
 853
 854                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
 855
 856                         yy_current_state = yy_get_previous_state();
 857
 858                         /* Okay, we're now positioned to make the NUL
 859                          * transition.  We couldn't have
 860                          * yy_get_previous_state() go ahead and do it
 861                          * for us because it doesn't know how to deal
 862                          * with the possibility of jamming (and we don't
 863                          * want to build jamming into it because then it
 864                          * will run more slowly).
 865                          */
 866
 867                         yy_next_state = yy_try_NUL_trans( yy_current_state );
 868
 869                         yy_bp = yytext_ptr + YY_MORE_ADJ;
 870
 871                         if ( yy_next_state )
 872                                 {
 873                                 /* Consume the NUL. */
 874                                 yy_cp = ++yy_c_buf_p;
 875                                 yy_current_state = yy_next_state;
 876                                 goto yy_match;
 877                                 }
 878
 879                         else
 880                                 {
 881                                 yy_cp = yy_c_buf_p;
 882                                 goto yy_find_action;
 883                                 }
 884                         }
 885
 886                 else switch ( yy_get_next_buffer() )
 887                         {
 888                         case EOB_ACT_END_OF_FILE:
 889                                 {
 890                                 yy_did_buffer_switch_on_eof = 0;
 891
 892                                 if ( yywrap() )
 893                                         {
 894                                         /* Note: because we've taken care in
 895                                          * yy_get_next_buffer() to have set up
 896                                          * yytext, we can now set up
 897                                          * yy_c_buf_p so that if some total
 898                                          * hoser (like flex itself) wants to
 899                                          * call the scanner after we return the
 900                                          * YY_NULL, it'll still work - another
 901                                          * YY_NULL will get returned.
 902                                          */
 903                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
 904
 905                                         yy_act = YY_STATE_EOF(YY_START);
 906                                         goto do_action;
 907                                         }
 908
 909                                 else
 910                                         {
 911                                         if ( ! yy_did_buffer_switch_on_eof )
 912                                                 YY_NEW_FILE;
 913                                         }
 914                                 break;
 915                                 }
 916
 917                         case EOB_ACT_CONTINUE_SCAN:
 918                                 yy_c_buf_p =
 919                                         yytext_ptr + yy_amount_of_matched_text;
 920
 921                                 yy_current_state = yy_get_previous_state();
 922
 923                                 yy_cp = yy_c_buf_p;
 924                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
 925                                 goto yy_match;
 926
 927                         case EOB_ACT_LAST_MATCH:
 928                                 yy_c_buf_p =
 929                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
 930
 931                                 yy_current_state = yy_get_previous_state();
 932
 933                                 yy_cp = yy_c_buf_p;
 934                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
 935                                 goto yy_find_action;
 936                         }
 937                 break;
 938                 }
 939
 940         default:
 941                 YY_FATAL_ERROR(
 942                         "fatal flex scanner internal error--no action found" );
 943         } /* end of action switch */
 944                 } /* end of scanning one token */
 945         } /* end of yylex */
 946
 947
 948 /* yy_get_next_buffer - try to read in a new buffer
 949  *
 950  * Returns a code representing an action:
 951  *      EOB_ACT_LAST_MATCH -
 952  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
 953  *      EOB_ACT_END_OF_FILE - end of file
 954  */
 955
 956 static int yy_get_next_buffer()
 957         {
 958         register char *dest = yy_current_buffer->yy_ch_buf;
 959         register char *source = yytext_ptr;
 960         register int number_to_move, i;
 961         int ret_val;
 962
 963         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
 964                 YY_FATAL_ERROR(
 965                 "fatal flex scanner internal error--end of buffer missed" );
 966
 967         if ( yy_current_buffer->yy_fill_buffer == 0 )
 968                 { /* Don't try to fill the buffer, so this is an EOF. */
 969                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
 970                         {
 971                         /* We matched a single character, the EOB, so
 972                          * treat this as a final EOF.
 973                          */
 974                         return EOB_ACT_END_OF_FILE;
 975                         }
 976
 977                 else
 978                         {
 979                         /* We matched some text prior to the EOB, first
 980                          * process it.
 981                          */
 982                         return EOB_ACT_LAST_MATCH;
 983                         }
 984                 }
 985
 986         /* Try to read more data. */
 987
 988         /* First move last chars to start of buffer. */
 989         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
 990
 991         for ( i = 0; i < number_to_move; ++i )
 992                 *(dest++) = *(source++);
 993
 994         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
 995                 /* don't do the read, it's not guaranteed to return an EOF,
 996                  * just force an EOF
 997                  */
 998                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
 999
1000         else
1001                 {
1002                 int num_to_read =
1003                         yy_current_buffer->yy_buf_size - number_to_move - 1;
1004
1005                 while ( num_to_read <= 0 )
1006                         { /* Not enough room in the buffer - grow it. */
1007 #ifdef YY_USES_REJECT
1008                         YY_FATAL_ERROR(
1009 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1010 #else
1011
1012                         /* just a shorter name for the current buffer */
1013                         YY_BUFFER_STATE b = yy_current_buffer;
1014
1015                         int yy_c_buf_p_offset =
1016                                 (int) (yy_c_buf_p - b->yy_ch_buf);
1017
1018                         if ( b->yy_is_our_buffer )
1019                                 {
1020                                 int new_size = b->yy_buf_size * 2;
1021
1022                                 if ( new_size <= 0 )
1023                                         b->yy_buf_size += b->yy_buf_size / 8;
1024                                 else
1025                                         b->yy_buf_size *= 2;
1026
1027                                 b->yy_ch_buf = (char *)
1028                                         /* Include room in for 2 EOB chars. */
1029                                         yy_flex_realloc( (void *) b->yy_ch_buf,
1030                                                          b->yy_buf_size + 2 );
1031                                 }
1032                         else
1033                                 /* Can't grow it, we don't own it. */
1034                                 b->yy_ch_buf = 0;
1035
1036                         if ( ! b->yy_ch_buf )
1037                                 YY_FATAL_ERROR(
1038                                 "fatal error - scanner input buffer overflow" );
1039
1040                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1041
1042                         num_to_read = yy_current_buffer->yy_buf_size -
1043                                                 number_to_move - 1;
1044 #endif
1045                         }
1046
1047                 if ( num_to_read > YY_READ_BUF_SIZE )
1048                         num_to_read = YY_READ_BUF_SIZE;
1049
1050                 /* Read in more data. */
1051                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1052                         yy_n_chars, num_to_read );
1053
1054                 yy_current_buffer->yy_n_chars = yy_n_chars;
1055                 }
1056
1057         if ( yy_n_chars == 0 )
1058                 {
1059                 if ( number_to_move == YY_MORE_ADJ )
1060                         {
1061                         ret_val = EOB_ACT_END_OF_FILE;
1062                         yyrestart( yyin );
1063                         }
1064
1065                 else
1066                         {
1067                         ret_val = EOB_ACT_LAST_MATCH;
1068                         yy_current_buffer->yy_buffer_status =
1069                                 YY_BUFFER_EOF_PENDING;
1070                         }
1071                 }
1072
1073         else
1074                 ret_val = EOB_ACT_CONTINUE_SCAN;
1075
1076         yy_n_chars += number_to_move;
1077         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1078         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1079
1080         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1081
1082         return ret_val;
1083         }
1084
1085
1086 /* yy_get_previous_state - get the state just before the EOB char was reached */
1087
1088 static yy_state_type yy_get_previous_state()
1089         {
1090         register yy_state_type yy_current_state;
1091         register char *yy_cp;
1092
1093         yy_current_state = yy_start;
1094
1095         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1096                 {
1097                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1098                 if ( yy_accept[yy_current_state] )
1099                         {
1100                         yy_last_accepting_state = yy_current_state;
1101                         yy_last_accepting_cpos = yy_cp;
1102                         }
1103                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1104                         {
1105                         yy_current_state = (int) yy_def[yy_current_state];
1106                         if ( yy_current_state >= 60 )
1107                                 yy_c = yy_meta[(unsigned int) yy_c];
1108                         }
1109                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1110                 }
1111
1112         return yy_current_state;
1113         }
1114
1115
1116 /* yy_try_NUL_trans - try to make a transition on the NUL character
1117  *
1118  * synopsis
1119  *      next_state = yy_try_NUL_trans( current_state );
1120  */
1121
1122 #ifdef YY_USE_PROTOS
1123 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1124 #else
1125 static yy_state_type yy_try_NUL_trans( yy_current_state )
1126 yy_state_type yy_current_state;
1127 #endif
1128         {
1129         register int yy_is_jam;
1130         register char *yy_cp = yy_c_buf_p;
1131
1132         register YY_CHAR yy_c = 1;
1133         if ( yy_accept[yy_current_state] )
1134                 {
1135                 yy_last_accepting_state = yy_current_state;
1136                 yy_last_accepting_cpos = yy_cp;
1137                 }
1138         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1139                 {
1140                 yy_current_state = (int) yy_def[yy_current_state];
1141                 if ( yy_current_state >= 60 )
1142                         yy_c = yy_meta[(unsigned int) yy_c];
1143                 }
1144         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1145         yy_is_jam = (yy_current_state == 59);
1146
1147         return yy_is_jam ? 0 : yy_current_state;
1148         }
1149
1150
1151 #ifndef YY_NO_UNPUT
1152 #ifdef YY_USE_PROTOS
1153 static void yyunput( int c, register char *yy_bp )
1154 #else
1155 static void yyunput( c, yy_bp )
1156 int c;
1157 register char *yy_bp;
1158 #endif
1159         {
1160         register char *yy_cp = yy_c_buf_p;
1161
1162         /* undo effects of setting up yytext */
1163         *yy_cp = yy_hold_char;
1164
1165         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1166                 { /* need to shift things up to make room */
1167                 /* +2 for EOB chars. */
1168                 register int number_to_move = yy_n_chars + 2;
1169                 register char *dest = &yy_current_buffer->yy_ch_buf[
1170                                         yy_current_buffer->yy_buf_size + 2];
1171                 register char *source =
1172                                 &yy_current_buffer->yy_ch_buf[number_to_move];
1173
1174                 while ( source > yy_current_buffer->yy_ch_buf )
1175                         *--dest = *--source;
1176
1177                 yy_cp += (int) (dest - source);
1178                 yy_bp += (int) (dest - source);
1179                 yy_current_buffer->yy_n_chars =
1180                         yy_n_chars = yy_current_buffer->yy_buf_size;
1181
1182                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1183                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1184                 }
1185
1186         *--yy_cp = (char) c;
1187
1188
1189         yytext_ptr = yy_bp;
1190         yy_hold_char = *yy_cp;
1191         yy_c_buf_p = yy_cp;
1192         }
1193 #endif  /* ifndef YY_NO_UNPUT */
1194
1195
1196 #ifdef __cplusplus
1197 static int yyinput()
1198 #else
1199 static int input()
1200 #endif
1201         {
1202         int c;
1203
1204         *yy_c_buf_p = yy_hold_char;
1205
1206         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1207                 {
1208                 /* yy_c_buf_p now points to the character we want to return.
1209                  * If this occurs *before* the EOB characters, then it's a
1210                  * valid NUL; if not, then we've hit the end of the buffer.
1211                  */
1212                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1213                         /* This was really a NUL. */
1214                         *yy_c_buf_p = '\0';
1215
1216                 else
1217                         { /* need more input */
1218                         int offset = yy_c_buf_p - yytext_ptr;
1219                         ++yy_c_buf_p;
1220
1221                         switch ( yy_get_next_buffer() )
1222                                 {
1223                                 case EOB_ACT_LAST_MATCH:
1224                                         /* This happens because yy_g_n_b()
1225                                          * sees that we've accumulated a
1226                                          * token and flags that we need to
1227                                          * try matching the token before
1228                                          * proceeding.  But for input(),
1229                                          * there's no matching to consider.
1230                                          * So convert the EOB_ACT_LAST_MATCH
1231                                          * to EOB_ACT_END_OF_FILE.
1232                                          */
1233
1234                                         /* Reset buffer status. */
1235                                         yyrestart( yyin );
1236
1237                                         /* fall through */
1238
1239                                 case EOB_ACT_END_OF_FILE:
1240                                         {
1241                                         if ( yywrap() )
1242                                                 return EOF;
1243
1244                                         if ( ! yy_did_buffer_switch_on_eof )
1245                                                 YY_NEW_FILE;
1246 #ifdef __cplusplus
1247                                         return yyinput();
1248 #else
1249                                         return input();
1250 #endif
1251                                         }
1252
1253                                 case EOB_ACT_CONTINUE_SCAN:
1254                                         yy_c_buf_p = yytext_ptr + offset;
1255                                         break;
1256                                 }
1257                         }
1258                 }
1259
1260         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
1261         *yy_c_buf_p = '\0';     /* preserve yytext */
1262         yy_hold_char = *++yy_c_buf_p;
1263
1264
1265         return c;
1266         }
1267
1268
1269 #ifdef YY_USE_PROTOS
1270 void yyrestart( FILE *input_file )
1271 #else
1272 void yyrestart( input_file )
1273 FILE *input_file;
1274 #endif
1275         {
1276         if ( ! yy_current_buffer )
1277                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1278
1279         yy_init_buffer( yy_current_buffer, input_file );
1280         yy_load_buffer_state();
1281         }
1282
1283
1284 #ifdef YY_USE_PROTOS
1285 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1286 #else
1287 void yy_switch_to_buffer( new_buffer )
1288 YY_BUFFER_STATE new_buffer;
1289 #endif
1290         {
1291         if ( yy_current_buffer == new_buffer )
1292                 return;
1293
1294         if ( yy_current_buffer )
1295                 {
1296                 /* Flush out information for old buffer. */
1297                 *yy_c_buf_p = yy_hold_char;
1298                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1299                 yy_current_buffer->yy_n_chars = yy_n_chars;
1300                 }
1301
1302         yy_current_buffer = new_buffer;
1303         yy_load_buffer_state();
1304
1305         /* We don't actually know whether we did this switch during
1306          * EOF (yywrap()) processing, but the only time this flag
1307          * is looked at is after yywrap() is called, so it's safe
1308          * to go ahead and always set it.
1309          */
1310         yy_did_buffer_switch_on_eof = 1;
1311         }
1312
1313
1314 #ifdef YY_USE_PROTOS
1315 void yy_load_buffer_state( void )
1316 #else
1317 void yy_load_buffer_state()
1318 #endif
1319         {
1320         yy_n_chars = yy_current_buffer->yy_n_chars;
1321         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1322         yyin = yy_current_buffer->yy_input_file;
1323         yy_hold_char = *yy_c_buf_p;
1324         }
1325
1326
1327 #ifdef YY_USE_PROTOS
1328 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1329 #else
1330 YY_BUFFER_STATE yy_create_buffer( file, size )
1331 FILE *file;
1332 int size;
1333 #endif
1334         {
1335         YY_BUFFER_STATE b;
1336
1337         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1338         if ( ! b )
1339                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1340
1341         b->yy_buf_size = size;
1342
1343         /* yy_ch_buf has to be 2 characters longer than the size given because
1344          * we need to put in 2 end-of-buffer characters.
1345          */
1346         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1347         if ( ! b->yy_ch_buf )
1348                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1349
1350         b->yy_is_our_buffer = 1;
1351
1352         yy_init_buffer( b, file );
1353
1354         return b;
1355         }
1356
1357
1358 #ifdef YY_USE_PROTOS
1359 void yy_delete_buffer( YY_BUFFER_STATE b )
1360 #else
1361 void yy_delete_buffer( b )
1362 YY_BUFFER_STATE b;
1363 #endif
1364         {
1365         if ( ! b )
1366                 return;
1367
1368         if ( b == yy_current_buffer )
1369                 yy_current_buffer = (YY_BUFFER_STATE) 0;
1370
1371         if ( b->yy_is_our_buffer )
1372                 yy_flex_free( (void *) b->yy_ch_buf );
1373
1374         yy_flex_free( (void *) b );
1375         }
1376
1377
1378 #ifndef _WIN32
1379 #include <unistd.h>
1380 #else
1381 #ifndef YY_ALWAYS_INTERACTIVE
1382 #ifndef YY_NEVER_INTERACTIVE
1383 extern int isatty YY_PROTO(( int ));
1384 #endif
1385 #endif
1386 #endif
1387
1388 #ifdef YY_USE_PROTOS
1389 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1390 #else
1391 void yy_init_buffer( b, file )
1392 YY_BUFFER_STATE b;
1393 FILE *file;
1394 #endif
1395
1396
1397         {
1398         yy_flush_buffer( b );
1399
1400         b->yy_input_file = file;
1401         b->yy_fill_buffer = 1;
1402
1403 #if YY_ALWAYS_INTERACTIVE
1404         b->yy_is_interactive = 1;
1405 #else
1406 #if YY_NEVER_INTERACTIVE
1407         b->yy_is_interactive = 0;
1408 #else
1409         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1410 #endif
1411 #endif
1412         }
1413
1414
1415 #ifdef YY_USE_PROTOS
1416 void yy_flush_buffer( YY_BUFFER_STATE b )
1417 #else
1418 void yy_flush_buffer( b )
1419 YY_BUFFER_STATE b;
1420 #endif
1421
1422         {
1423         if ( ! b )
1424                 return;
1425
1426         b->yy_n_chars = 0;
1427
1428         /* We always need two end-of-buffer characters.  The first causes
1429          * a transition to the end-of-buffer state.  The second causes
1430          * a jam in that state.
1431          */
1432         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1433         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1434
1435         b->yy_buf_pos = &b->yy_ch_buf[0];
1436
1437         b->yy_at_bol = 1;
1438         b->yy_buffer_status = YY_BUFFER_NEW;
1439
1440         if ( b == yy_current_buffer )
1441                 yy_load_buffer_state();
1442         }
1443
1444
1445 #ifndef YY_NO_SCAN_BUFFER
1446 #ifdef YY_USE_PROTOS
1447 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1448 #else
1449 YY_BUFFER_STATE yy_scan_buffer( base, size )
1450 char *base;
1451 yy_size_t size;
1452 #endif
1453         {
1454         YY_BUFFER_STATE b;
1455
1456         if ( size < 2 ||
1457              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1458              base[size-1] != YY_END_OF_BUFFER_CHAR )
1459                 /* They forgot to leave room for the EOB's. */
1460                 return 0;
1461
1462         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1463         if ( ! b )
1464                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1465
1466         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1467         b->yy_buf_pos = b->yy_ch_buf = base;
1468         b->yy_is_our_buffer = 0;
1469         b->yy_input_file = 0;
1470         b->yy_n_chars = b->yy_buf_size;
1471         b->yy_is_interactive = 0;
1472         b->yy_at_bol = 1;
1473         b->yy_fill_buffer = 0;
1474         b->yy_buffer_status = YY_BUFFER_NEW;
1475
1476         yy_switch_to_buffer( b );
1477
1478         return b;
1479         }
1480 #endif
1481
1482
1483 #ifndef YY_NO_SCAN_STRING
1484 #ifdef YY_USE_PROTOS
1485 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
1486 #else
1487 YY_BUFFER_STATE yy_scan_string( yy_str )
1488 yyconst char *yy_str;
1489 #endif
1490         {
1491         int len;
1492         for ( len = 0; yy_str[len]; ++len )
1493                 ;
1494
1495         return yy_scan_bytes( yy_str, len );
1496         }
1497 #endif
1498
1499
1500 #ifndef YY_NO_SCAN_BYTES
1501 #ifdef YY_USE_PROTOS
1502 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1503 #else
1504 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1505 yyconst char *bytes;
1506 int len;
1507 #endif
1508         {
1509         YY_BUFFER_STATE b;
1510         char *buf;
1511         yy_size_t n;
1512         int i;
1513
1514         /* Get memory for full buffer, including space for trailing EOB's. */
1515         n = len + 2;
1516         buf = (char *) yy_flex_alloc( n );
1517         if ( ! buf )
1518                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1519
1520         for ( i = 0; i < len; ++i )
1521                 buf[i] = bytes[i];
1522
1523         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1524
1525         b = yy_scan_buffer( buf, n );
1526         if ( ! b )
1527                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1528
1529         /* It's okay to grow etc. this buffer, and we should throw it
1530          * away when we're done.
1531          */
1532         b->yy_is_our_buffer = 1;
1533
1534         return b;
1535         }
1536 #endif
1537
1538
1539 #ifndef YY_NO_PUSH_STATE
1540 #ifdef YY_USE_PROTOS
1541 static void yy_push_state( int new_state )
1542 #else
1543 static void yy_push_state( new_state )
1544 int new_state;
1545 #endif
1546         {
1547         if ( yy_start_stack_ptr >= yy_start_stack_depth )
1548                 {
1549                 yy_size_t new_size;
1550
1551                 yy_start_stack_depth += YY_START_STACK_INCR;
1552                 new_size = yy_start_stack_depth * sizeof( int );
1553
1554                 if ( ! yy_start_stack )
1555                         yy_start_stack = (int *) yy_flex_alloc( new_size );
1556
1557                 else
1558                         yy_start_stack = (int *) yy_flex_realloc(
1559                                         (void *) yy_start_stack, new_size );
1560
1561                 if ( ! yy_start_stack )
1562                         YY_FATAL_ERROR(
1563                         "out of memory expanding start-condition stack" );
1564                 }
1565
1566         yy_start_stack[yy_start_stack_ptr++] = YY_START;
1567
1568         BEGIN(new_state);
1569         }
1570 #endif
1571
1572
1573 #ifndef YY_NO_POP_STATE
1574 static void yy_pop_state()
1575         {
1576         if ( --yy_start_stack_ptr < 0 )
1577                 YY_FATAL_ERROR( "start-condition stack underflow" );
1578
1579         BEGIN(yy_start_stack[yy_start_stack_ptr]);
1580         }
1581 #endif
1582
1583
1584 #ifndef YY_NO_TOP_STATE
1585 static int yy_top_state()
1586         {
1587         return yy_start_stack[yy_start_stack_ptr - 1];
1588         }
1589 #endif
1590
1591 #ifndef YY_EXIT_FAILURE
1592 #define YY_EXIT_FAILURE 2
1593 #endif
1594
1595 #ifdef YY_USE_PROTOS
1596 static void yy_fatal_error( yyconst char msg[] )
1597 #else
1598 static void yy_fatal_error( msg )
1599 char msg[];
1600 #endif
1601         {
1602         (void) fprintf( stderr, "%s\n", msg );
1603         exit( YY_EXIT_FAILURE );
1604         }
1605
1606
1607
1608 /* Redefine yyless() so it works in section 3 code. */
1609
1610 #undef yyless
1611 #define yyless(n) \
1612         do \
1613                 { \
1614                 /* Undo effects of setting up yytext. */ \
1615                 yytext[yyleng] = yy_hold_char; \
1616                 yy_c_buf_p = yytext + n; \
1617                 yy_hold_char = *yy_c_buf_p; \
1618                 *yy_c_buf_p = '\0'; \
1619                 yyleng = n; \
1620                 } \
1621         while ( 0 )
1622
1623
1624 /* Internal utility routines. */
1625
1626 #ifndef yytext_ptr
1627 #ifdef YY_USE_PROTOS
1628 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
1629 #else
1630 static void yy_flex_strncpy( s1, s2, n )
1631 char *s1;
1632 yyconst char *s2;
1633 int n;
1634 #endif
1635         {
1636         register int i;
1637         for ( i = 0; i < n; ++i )
1638                 s1[i] = s2[i];
1639         }
1640 #endif
1641
1642 #ifdef YY_NEED_STRLEN
1643 #ifdef YY_USE_PROTOS
1644 static int yy_flex_strlen( yyconst char *s )
1645 #else
1646 static int yy_flex_strlen( s )
1647 yyconst char *s;
1648 #endif
1649         {
1650         register int n;
1651         for ( n = 0; s[n]; ++n )
1652                 ;
1653
1654         return n;
1655         }
1656 #endif
1657
1658
1659 #ifdef YY_USE_PROTOS
1660 static void *yy_flex_alloc( yy_size_t size )
1661 #else
1662 static void *yy_flex_alloc( size )
1663 yy_size_t size;
1664 #endif
1665         {
1666         return (void *) malloc( size );
1667         }
1668
1669 #ifdef YY_USE_PROTOS
1670 static void *yy_flex_realloc( void *ptr, yy_size_t size )
1671 #else
1672 static void *yy_flex_realloc( ptr, size )
1673 void *ptr;
1674 yy_size_t size;
1675 #endif
1676         {
1677         /* The cast to (char *) in the following accommodates both
1678          * implementations that use char* generic pointers, and those
1679          * that use void* generic pointers.  It works with the latter
1680          * because both ANSI C and C++ allow castless assignment from
1681          * any pointer type to void*, and deal with argument conversions
1682          * as though doing an assignment.
1683          */
1684         return (void *) realloc( (char *) ptr, size );
1685         }
1686
1687 #ifdef YY_USE_PROTOS
1688 static void yy_flex_free( void *ptr )
1689 #else
1690 static void yy_flex_free( ptr )
1691 void *ptr;
1692 #endif
1693         {
1694         free( ptr );
1695         }
1696
1697 #if YY_MAIN
1698 int main()
1699         {
1700         yylex();
1701         return 0;
1702         }
1703 #endif
1704 #line 107 "itbl-lex.l"
1705
1706
1707 #ifndef yywrap
1708 int
1709 yywrap ()
1710   {
1711     return 1;
1712   }
1713 #endif