LCOV - code coverage report
Current view: top level - libcpu - i386_lex.c (source / functions) Hit Total Coverage
Test: elfutils-0.176 Lines: 159 363 43.8 %
Date: 2019-02-15 17:57:54 Functions: 10 31 32.3 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13