LCOV - code coverage report
Current view: top level - libcpu - i386_lex.c (source / functions) Hit Total Coverage
Test: elfutils-0.189 Lines: 177 399 44.4 %
Date: 2023-11-02 17:35:49 Functions: 11 34 32.4 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 86 217 39.6 %

           Branch data     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                 :            : 
     812                 :            : #include <libeu.h>
     813                 :            : #include "system.h"
     814                 :            : #include "i386_parse.h"
     815                 :            : 
     816                 :            : 
     817                 :            : static void eat_to_eol (void);
     818                 :            : static void invalid_char (int ch);
     819                 :            : #line 820 "i386_lex.c"
     820                 :            : 
     821                 :            : #line 822 "i386_lex.c"
     822                 :            : 
     823                 :            : #define INITIAL 0
     824                 :            : #define MAIN 1
     825                 :            : 
     826                 :            : #ifndef YY_NO_UNISTD_H
     827                 :            : /* Special case for "unistd.h", since it is non-ANSI. We include it way
     828                 :            :  * down here because we want the user's section 1 to have been scanned first.
     829                 :            :  * The user has a chance to override it with an option.
     830                 :            :  */
     831                 :            : #include <unistd.h>
     832                 :            : #endif
     833                 :            : 
     834                 :            : #ifndef YY_EXTRA_TYPE
     835                 :            : #define YY_EXTRA_TYPE void *
     836                 :            : #endif
     837                 :            : 
     838                 :            : static int yy_init_globals ( void );
     839                 :            : 
     840                 :            : /* Accessor methods to globals.
     841                 :            :    These are made visible to non-reentrant scanners for convenience. */
     842                 :            : 
     843                 :            : int yylex_destroy ( void );
     844                 :            : 
     845                 :            : int yyget_debug ( void );
     846                 :            : 
     847                 :            : void yyset_debug ( int debug_flag  );
     848                 :            : 
     849                 :            : YY_EXTRA_TYPE yyget_extra ( void );
     850                 :            : 
     851                 :            : void yyset_extra ( YY_EXTRA_TYPE user_defined  );
     852                 :            : 
     853                 :            : FILE *yyget_in ( void );
     854                 :            : 
     855                 :            : void yyset_in  ( FILE * _in_str  );
     856                 :            : 
     857                 :            : FILE *yyget_out ( void );
     858                 :            : 
     859                 :            : void yyset_out  ( FILE * _out_str  );
     860                 :            : 
     861                 :            :                         int yyget_leng ( void );
     862                 :            : 
     863                 :            : char *yyget_text ( void );
     864                 :            : 
     865                 :            : int yyget_lineno ( void );
     866                 :            : 
     867                 :            : void yyset_lineno ( int _line_number  );
     868                 :            : 
     869                 :            : /* Macros after this point can all be overridden by user definitions in
     870                 :            :  * section 1.
     871                 :            :  */
     872                 :            : 
     873                 :            : #ifndef YY_SKIP_YYWRAP
     874                 :            : #ifdef __cplusplus
     875                 :            : extern "C" int yywrap ( void );
     876                 :            : #else
     877                 :            : extern int yywrap ( void );
     878                 :            : #endif
     879                 :            : #endif
     880                 :            : 
     881                 :            : #ifndef YY_NO_UNPUT
     882                 :            :     
     883                 :            :     static void yyunput ( int c, char *buf_ptr  );
     884                 :            :     
     885                 :            : #endif
     886                 :            : 
     887                 :            : #ifndef yytext_ptr
     888                 :            : static void yy_flex_strncpy ( char *, const char *, int );
     889                 :            : #endif
     890                 :            : 
     891                 :            : #ifdef YY_NEED_STRLEN
     892                 :            : static int yy_flex_strlen ( const char * );
     893                 :            : #endif
     894                 :            : 
     895                 :            : #ifndef YY_NO_INPUT
     896                 :            : #ifdef __cplusplus
     897                 :            : static int yyinput ( void );
     898                 :            : #else
     899                 :            : static int input ( void );
     900                 :            : #endif
     901                 :            : 
     902                 :            : #endif
     903                 :            : 
     904                 :            : /* Amount of stuff to slurp up with each read. */
     905                 :            : #ifndef YY_READ_BUF_SIZE
     906                 :            : #ifdef __ia64__
     907                 :            : /* On IA-64, the buffer size is 16k, not 8k */
     908                 :            : #define YY_READ_BUF_SIZE 16384
     909                 :            : #else
     910                 :            : #define YY_READ_BUF_SIZE 8192
     911                 :            : #endif /* __ia64__ */
     912                 :            : #endif
     913                 :            : 
     914                 :            : /* Copy whatever the last rule matched to the standard output. */
     915                 :            : #ifndef ECHO
     916                 :            : /* This used to be an fputs(), but since the string might contain NUL's,
     917                 :            :  * we now use fwrite().
     918                 :            :  */
     919                 :            : #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
     920                 :            : #endif
     921                 :            : 
     922                 :            : /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
     923                 :            :  * is returned in "result".
     924                 :            :  */
     925                 :            : #ifndef YY_INPUT
     926                 :            : #define YY_INPUT(buf,result,max_size) \
     927                 :            :         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
     928                 :            :                 { \
     929                 :            :                 int c = '*'; \
     930                 :            :                 int n; \
     931                 :            :                 for ( n = 0; n < max_size && \
     932                 :            :                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
     933                 :            :                         buf[n] = (char) c; \
     934                 :            :                 if ( c == '\n' ) \
     935                 :            :                         buf[n++] = (char) c; \
     936                 :            :                 if ( c == EOF && ferror( yyin ) ) \
     937                 :            :                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
     938                 :            :                 result = n; \
     939                 :            :                 } \
     940                 :            :         else \
     941                 :            :                 { \
     942                 :            :                 errno=0; \
     943                 :            :                 while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
     944                 :            :                         { \
     945                 :            :                         if( errno != EINTR) \
     946                 :            :                                 { \
     947                 :            :                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
     948                 :            :                                 break; \
     949                 :            :                                 } \
     950                 :            :                         errno=0; \
     951                 :            :                         clearerr(yyin); \
     952                 :            :                         } \
     953                 :            :                 }\
     954                 :            : \
     955                 :            : 
     956                 :            : #endif
     957                 :            : 
     958                 :            : /* No semi-colon after return; correct usage is to write "yyterminate();" -
     959                 :            :  * we don't want an extra ';' after the "return" because that will cause
     960                 :            :  * some compilers to complain about unreachable statements.
     961                 :            :  */
     962                 :            : #ifndef yyterminate
     963                 :            : #define yyterminate() return YY_NULL
     964                 :            : #endif
     965                 :            : 
     966                 :            : /* Number of entries by which start-condition stack grows. */
     967                 :            : #ifndef YY_START_STACK_INCR
     968                 :            : #define YY_START_STACK_INCR 25
     969                 :            : #endif
     970                 :            : 
     971                 :            : /* Report a fatal error. */
     972                 :            : #ifndef YY_FATAL_ERROR
     973                 :            : #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
     974                 :            : #endif
     975                 :            : 
     976                 :            : /* end tables serialization structures and prototypes */
     977                 :            : 
     978                 :            : /* Default declaration of generated scanner - a define so the user can
     979                 :            :  * easily add parameters.
     980                 :            :  */
     981                 :            : #ifndef YY_DECL
     982                 :            : #define YY_DECL_IS_OURS 1
     983                 :            : 
     984                 :            : extern int yylex (void);
     985                 :            : 
     986                 :            : #define YY_DECL int yylex (void)
     987                 :            : #endif /* !YY_DECL */
     988                 :            : 
     989                 :            : /* Code executed at the beginning of each rule, after yytext and yyleng
     990                 :            :  * have been set up.
     991                 :            :  */
     992                 :            : #ifndef YY_USER_ACTION
     993                 :            : #define YY_USER_ACTION
     994                 :            : #endif
     995                 :            : 
     996                 :            : /* Code executed at the end of each rule. */
     997                 :            : #ifndef YY_BREAK
     998                 :            : #define YY_BREAK /*LINTED*/break;
     999                 :            : #endif
    1000                 :            : 
    1001                 :            : #define YY_RULE_SETUP \
    1002                 :            :         if ( yyleng > 0 ) \
    1003                 :            :                 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
    1004                 :            :                                 (yytext[yyleng - 1] == '\n'); \
    1005                 :            :         YY_USER_ACTION
    1006                 :            : 
    1007                 :            : /** The main scanner function which does all the work.
    1008                 :            :  */
    1009                 :      45251 : YY_DECL
    1010                 :            : {
    1011                 :      45251 :         yy_state_type yy_current_state;
    1012                 :      45251 :         char *yy_cp, *yy_bp;
    1013                 :      45251 :         int yy_act;
    1014                 :            :     
    1015         [ +  + ]:      45251 :         if ( !(yy_init) )
    1016                 :            :                 {
    1017                 :          2 :                 (yy_init) = 1;
    1018                 :            : 
    1019                 :            : #ifdef YY_USER_INIT
    1020                 :            :                 YY_USER_INIT;
    1021                 :            : #endif
    1022                 :            : 
    1023         [ +  - ]:          2 :                 if ( ! (yy_start) )
    1024                 :          2 :                         (yy_start) = 1; /* first start state */
    1025                 :            : 
    1026         [ -  + ]:          2 :                 if ( ! yyin )
    1027                 :          0 :                         yyin = stdin;
    1028                 :            : 
    1029         [ +  - ]:          2 :                 if ( ! yyout )
    1030                 :          2 :                         yyout = stdout;
    1031                 :            : 
    1032   [ -  +  -  - ]:          2 :                 if ( ! YY_CURRENT_BUFFER ) {
    1033                 :          2 :                         yyensure_buffer_stack ();
    1034                 :          2 :                         YY_CURRENT_BUFFER_LVALUE =
    1035                 :          2 :                                 yy_create_buffer( yyin, YY_BUF_SIZE );
    1036                 :            :                 }
    1037                 :            : 
    1038                 :          2 :                 yy_load_buffer_state(  );
    1039                 :            :                 }
    1040                 :            : 
    1041                 :            :         {
    1042                 :            : #line 56 "i386_lex.l"
    1043                 :            : 
    1044                 :            : 
    1045                 :            : #line 1046 "i386_lex.c"
    1046                 :            : 
    1047                 :      45589 :         while ( /*CONSTCOND*/1 )                /* loops until end-of-file is reached */
    1048                 :            :                 {
    1049                 :      45589 :                 yy_cp = (yy_c_buf_p);
    1050                 :            : 
    1051                 :            :                 /* Support of yytext. */
    1052                 :      45589 :                 *yy_cp = (yy_hold_char);
    1053                 :            : 
    1054                 :            :                 /* yy_bp points to the position in yy_ch_buf of the start of
    1055                 :            :                  * the current run.
    1056                 :            :                  */
    1057                 :      45589 :                 yy_bp = yy_cp;
    1058                 :            : 
    1059                 :      45589 :                 yy_current_state = (yy_start);
    1060                 :      45589 :                 yy_current_state += YY_AT_BOL();
    1061                 :            : yy_match:
    1062                 :     133225 :                 do
    1063                 :            :                         {
    1064                 :     133225 :                         YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
    1065         [ +  + ]:     133225 :                         if ( yy_accept[yy_current_state] )
    1066                 :            :                                 {
    1067                 :      60105 :                                 (yy_last_accepting_state) = yy_current_state;
    1068                 :      60105 :                                 (yy_last_accepting_cpos) = yy_cp;
    1069                 :            :                                 }
    1070         [ +  + ]:     215760 :                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
    1071                 :            :                                 {
    1072                 :      82535 :                                 yy_current_state = (int) yy_def[yy_current_state];
    1073         [ +  + ]:      82535 :                                 if ( yy_current_state >= 62 )
    1074                 :      35431 :                                         yy_c = yy_meta[yy_c];
    1075                 :            :                                 }
    1076                 :     133225 :                         yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
    1077                 :     133225 :                         ++yy_cp;
    1078                 :            :                         }
    1079         [ +  + ]:     133225 :                 while ( yy_current_state != 61 );
    1080                 :      45601 :                 yy_cp = (yy_last_accepting_cpos);
    1081                 :      45601 :                 yy_current_state = (yy_last_accepting_state);
    1082                 :            : 
    1083                 :            : yy_find_action:
    1084                 :      45601 :                 yy_act = yy_accept[yy_current_state];
    1085                 :            : 
    1086                 :      45601 :                 YY_DO_BEFORE_ACTION;
    1087                 :            : 
    1088   [ +  +  +  + ]:      45601 :                 if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
    1089                 :            :                         {
    1090                 :            :                         int yyl;
    1091         [ +  + ]:       6308 :                         for ( yyl = 0; yyl < yyleng; ++yyl )
    1092         [ +  + ]:       3155 :                                 if ( yytext[yyl] == '\n' )
    1093                 :            :                                         
    1094                 :       1617 :     yylineno++;
    1095                 :      45603 : ;
    1096                 :            :                         }
    1097                 :            : 
    1098                 :      45601 : do_action:      /* This label is used only to access EOF actions. */
    1099                 :            : 
    1100   [ -  +  +  +  :      45603 :                 switch ( yy_act )
          +  +  +  +  +  
          +  +  +  +  +  
          -  +  +  +  +  
          +  -  -  +  -  
                      + ]
    1101                 :            :         { /* beginning of action switch */
    1102                 :          0 :                         case 0: /* must back up */
    1103                 :            :                         /* undo the effects of YY_DO_BEFORE_ACTION */
    1104                 :          0 :                         *yy_cp = (yy_hold_char);
    1105                 :          0 :                         yy_cp = (yy_last_accepting_cpos);
    1106                 :          0 :                         yy_current_state = (yy_last_accepting_state);
    1107                 :          0 :                         goto yy_find_action;
    1108                 :            : 
    1109                 :         94 : case 1:
    1110         [ +  - ]:         94 : YY_RULE_SETUP
    1111                 :            : #line 58 "i386_lex.l"
    1112                 :            : { return kMASK; }
    1113                 :            :         YY_BREAK
    1114                 :            : case 2:
    1115                 :            : YY_RULE_SETUP
    1116                 :            : #line 60 "i386_lex.l"
    1117                 :            : { return kPREFIX; }
    1118                 :            :         YY_BREAK
    1119                 :            : case 3:
    1120                 :            : YY_RULE_SETUP
    1121                 :            : #line 61 "i386_lex.l"
    1122                 :            : { return kSUFFIX; }
    1123                 :            :         YY_BREAK
    1124                 :            : case 4:
    1125                 :            : YY_RULE_SETUP
    1126                 :            : #line 63 "i386_lex.l"
    1127                 :            : { return kSYNONYM; }
    1128                 :            :         YY_BREAK
    1129                 :            : case 5:
    1130                 :            : YY_RULE_SETUP
    1131                 :            : #line 65 "i386_lex.l"
    1132                 :            : { i386_lval.num = strtoul (yytext, NULL, 10);
    1133                 :            :                                   return kNUMBER; }
    1134                 :            :         YY_BREAK
    1135                 :            : case 6:
    1136                 :            : YY_RULE_SETUP
    1137                 :            : #line 68 "i386_lex.l"
    1138                 :            : { BEGIN (MAIN); return kPERCPERC; }
    1139                 :            :         YY_BREAK
    1140                 :            : case 7:
    1141                 :            : YY_RULE_SETUP
    1142                 :            : #line 71 "i386_lex.l"
    1143                 :            : { return '0'; }
    1144                 :            :         YY_BREAK
    1145                 :            : case 8:
    1146                 :            : YY_RULE_SETUP
    1147                 :            : #line 72 "i386_lex.l"
    1148                 :            : { return '1'; }
    1149                 :            :         YY_BREAK
    1150                 :            : case 9:
    1151                 :            : YY_RULE_SETUP
    1152                 :            : #line 74 "i386_lex.l"
    1153                 :            : { i386_lval.str = xstrndup (yytext + 1,
    1154                 :            :                                                             yyleng - 2);
    1155                 :            :                                   return kBITFIELD; }
    1156                 :            :         YY_BREAK
    1157                 :            : case 10:
    1158                 :            : YY_RULE_SETUP
    1159                 :            : #line 78 "i386_lex.l"
    1160                 :            : { i386_lval.str = (void *) -1l;
    1161                 :            :                                   return kID; }
    1162                 :            :         YY_BREAK
    1163                 :            : case 11:
    1164                 :            : YY_RULE_SETUP
    1165                 :            : #line 81 "i386_lex.l"
    1166                 :            : { i386_lval.str = xstrndup (yytext, yyleng);
    1167                 :            :                                   return kID; }
    1168                 :            :         YY_BREAK
    1169                 :            : case 12:
    1170                 :            : YY_RULE_SETUP
    1171                 :            : #line 84 "i386_lex.l"
    1172                 :            : { return ','; }
    1173                 :            :         YY_BREAK
    1174                 :            : case 13:
    1175                 :            : YY_RULE_SETUP
    1176                 :            : #line 86 "i386_lex.l"
    1177                 :            : { return ':'; }
    1178                 :            :         YY_BREAK
    1179                 :            : case 14:
    1180                 :            : /* rule 14 can match eol */
    1181                 :            : YY_RULE_SETUP
    1182                 :            : #line 88 "i386_lex.l"
    1183                 :            : { /* IGNORE */ }
    1184                 :            :         YY_BREAK
    1185                 :            : case 15:
    1186                 :            : /* rule 15 can match eol */
    1187                 :            : YY_RULE_SETUP
    1188                 :            : #line 90 "i386_lex.l"
    1189                 :            : { return '\n'; }
    1190                 :            :         YY_BREAK
    1191                 :            : case 16:
    1192                 :            : YY_RULE_SETUP
    1193                 :            : #line 92 "i386_lex.l"
    1194                 :            : { eat_to_eol (); }
    1195                 :            :         YY_BREAK
    1196                 :            : case 17:
    1197                 :            : /* rule 17 can match eol */
    1198                 :            : YY_RULE_SETUP
    1199                 :            : #line 94 "i386_lex.l"
    1200                 :            : { /* IGNORE */ }
    1201                 :            :         YY_BREAK
    1202                 :            : case 18:
    1203                 :            : /* rule 18 can match eol */
    1204                 :            : YY_RULE_SETUP
    1205                 :            : #line 96 "i386_lex.l"
    1206                 :            : { return kSPACE; }
    1207                 :            :         YY_BREAK
    1208                 :            : case 19:
    1209                 :            : YY_RULE_SETUP
    1210                 :            : #line 98 "i386_lex.l"
    1211                 :            : { i386_lval.ch = *yytext; return kCHAR; }
    1212                 :            :         YY_BREAK
    1213                 :            : case 20:
    1214                 :            : YY_RULE_SETUP
    1215                 :            : #line 100 "i386_lex.l"
    1216                 :            : { invalid_char (*yytext); }
    1217                 :            :         YY_BREAK
    1218                 :            : case 21:
    1219                 :            : YY_RULE_SETUP
    1220                 :            : #line 103 "i386_lex.l"
    1221                 :            : ECHO;
    1222                 :            :         YY_BREAK
    1223                 :            : #line 1224 "i386_lex.c"
    1224                 :            : case YY_STATE_EOF(INITIAL):
    1225                 :            : case YY_STATE_EOF(MAIN):
    1226                 :            :         yyterminate();
    1227                 :            : 
    1228                 :         14 :         case YY_END_OF_BUFFER:
    1229                 :            :                 {
    1230                 :            :                 /* Amount of text matched not including the EOB char. */
    1231                 :         14 :                 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
    1232                 :            : 
    1233                 :            :                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
    1234                 :         14 :                 *yy_cp = (yy_hold_char);
    1235                 :            :                 YY_RESTORE_YY_MORE_OFFSET
    1236                 :            : 
    1237         [ +  + ]:         14 :                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
    1238                 :            :                         {
    1239                 :            :                         /* We're scanning a new file or input source.  It's
    1240                 :            :                          * possible that this happened because the user
    1241                 :            :                          * just pointed yyin at a new source and called
    1242                 :            :                          * yylex().  If so, then we have to assure
    1243                 :            :                          * consistency between YY_CURRENT_BUFFER and our
    1244                 :            :                          * globals.  Here is the right place to do so, because
    1245                 :            :                          * this is the first action (other than possibly a
    1246                 :            :                          * back-up) that will match for the new input source.
    1247                 :            :                          */
    1248                 :          2 :                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
    1249                 :          2 :                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
    1250                 :          2 :                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
    1251                 :            :                         }
    1252                 :            : 
    1253                 :            :                 /* Note that here we test for yy_c_buf_p "<=" to the position
    1254                 :            :                  * of the first EOB in the buffer, since yy_c_buf_p will
    1255                 :            :                  * already have been incremented past the NUL character
    1256                 :            :                  * (since all states make transitions on EOB to the
    1257                 :            :                  * end-of-buffer state).  Contrast this with the test
    1258                 :            :                  * in input().
    1259                 :            :                  */
    1260         [ -  + ]:         14 :                 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
    1261                 :            :                         { /* This was really a NUL. */
    1262                 :          0 :                         yy_state_type yy_next_state;
    1263                 :            : 
    1264                 :          0 :                         (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
    1265                 :            : 
    1266                 :          0 :                         yy_current_state = yy_get_previous_state(  );
    1267                 :            : 
    1268                 :            :                         /* Okay, we're now positioned to make the NUL
    1269                 :            :                          * transition.  We couldn't have
    1270                 :            :                          * yy_get_previous_state() go ahead and do it
    1271                 :            :                          * for us because it doesn't know how to deal
    1272                 :            :                          * with the possibility of jamming (and we don't
    1273                 :            :                          * want to build jamming into it because then it
    1274                 :            :                          * will run more slowly).
    1275                 :            :                          */
    1276                 :            : 
    1277                 :          0 :                         yy_next_state = yy_try_NUL_trans( yy_current_state );
    1278                 :            : 
    1279                 :          0 :                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
    1280                 :            : 
    1281         [ #  # ]:          0 :                         if ( yy_next_state )
    1282                 :            :                                 {
    1283                 :            :                                 /* Consume the NUL. */
    1284                 :          0 :                                 yy_cp = ++(yy_c_buf_p);
    1285                 :          0 :                                 yy_current_state = yy_next_state;
    1286                 :          0 :                                 goto yy_match;
    1287                 :            :                                 }
    1288                 :            : 
    1289                 :            :                         else
    1290                 :            :                                 {
    1291                 :          0 :                                 yy_cp = (yy_last_accepting_cpos);
    1292                 :          0 :                                 yy_current_state = (yy_last_accepting_state);
    1293                 :          0 :                                 goto yy_find_action;
    1294                 :            :                                 }
    1295                 :            :                         }
    1296                 :            : 
    1297                 :         14 :                 else switch ( yy_get_next_buffer(  ) )
    1298                 :            :                         {
    1299                 :          2 :                         case EOB_ACT_END_OF_FILE:
    1300                 :            :                                 {
    1301                 :          2 :                                 (yy_did_buffer_switch_on_eof) = 0;
    1302                 :            : 
    1303                 :          2 :                                 if ( yywrap(  ) )
    1304                 :            :                                         {
    1305                 :            :                                         /* Note: because we've taken care in
    1306                 :            :                                          * yy_get_next_buffer() to have set up
    1307                 :            :                                          * yytext, we can now set up
    1308                 :            :                                          * yy_c_buf_p so that if some total
    1309                 :            :                                          * hoser (like flex itself) wants to
    1310                 :            :                                          * call the scanner after we return the
    1311                 :            :                                          * YY_NULL, it'll still work - another
    1312                 :            :                                          * YY_NULL will get returned.
    1313                 :            :                                          */
    1314                 :          2 :                                         (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
    1315                 :            : 
    1316                 :          2 :                                         yy_act = YY_STATE_EOF(YY_START);
    1317                 :          2 :                                         goto do_action;
    1318                 :            :                                         }
    1319                 :            : 
    1320                 :            :                                 else
    1321                 :            :                                         {
    1322                 :            :                                         if ( ! (yy_did_buffer_switch_on_eof) )
    1323                 :            :                                                 YY_NEW_FILE;
    1324                 :            :                                         }
    1325                 :            :                                 break;
    1326                 :            :                                 }
    1327                 :            : 
    1328                 :         12 :                         case EOB_ACT_CONTINUE_SCAN:
    1329                 :         12 :                                 (yy_c_buf_p) =
    1330                 :         12 :                                         (yytext_ptr) + yy_amount_of_matched_text;
    1331                 :            : 
    1332                 :         12 :                                 yy_current_state = yy_get_previous_state(  );
    1333                 :            : 
    1334                 :         12 :                                 yy_cp = (yy_c_buf_p);
    1335                 :         12 :                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
    1336                 :         12 :                                 goto yy_match;
    1337                 :            : 
    1338                 :          0 :                         case EOB_ACT_LAST_MATCH:
    1339                 :          0 :                                 (yy_c_buf_p) =
    1340                 :          0 :                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
    1341                 :            : 
    1342                 :          0 :                                 yy_current_state = yy_get_previous_state(  );
    1343                 :            : 
    1344                 :          0 :                                 yy_cp = (yy_c_buf_p);
    1345                 :          0 :                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
    1346                 :          0 :                                 goto yy_find_action;
    1347                 :            :                         }
    1348                 :            :                 break;
    1349                 :            :                 }
    1350                 :            : 
    1351                 :          0 :         default:
    1352                 :          0 :                 YY_FATAL_ERROR(
    1353                 :            :                         "fatal flex scanner internal error--no action found" );
    1354                 :            :         } /* end of action switch */
    1355                 :            :                 } /* end of scanning one token */
    1356                 :            :         } /* end of user's declarations */
    1357                 :            : } /* end of yylex */
    1358                 :            : 
    1359                 :            : /* yy_get_next_buffer - try to read in a new buffer
    1360                 :            :  *
    1361                 :            :  * Returns a code representing an action:
    1362                 :            :  *      EOB_ACT_LAST_MATCH -
    1363                 :            :  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
    1364                 :            :  *      EOB_ACT_END_OF_FILE - end of file
    1365                 :            :  */
    1366                 :         14 : static int yy_get_next_buffer (void)
    1367                 :            : {
    1368                 :         14 :         char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
    1369                 :         14 :         char *source = (yytext_ptr);
    1370                 :         14 :         int number_to_move, i;
    1371                 :         14 :         int ret_val;
    1372                 :            : 
    1373         [ -  + ]:         14 :         if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
    1374                 :          0 :                 YY_FATAL_ERROR(
    1375                 :            :                 "fatal flex scanner internal error--end of buffer missed" );
    1376                 :            : 
    1377         [ -  + ]:         14 :         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
    1378                 :            :                 { /* Don't try to fill the buffer, so this is an EOF. */
    1379         [ #  # ]:          0 :                 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
    1380                 :            :                         {
    1381                 :            :                         /* We matched a single character, the EOB, so
    1382                 :            :                          * treat this as a final EOF.
    1383                 :            :                          */
    1384                 :            :                         return EOB_ACT_END_OF_FILE;
    1385                 :            :                         }
    1386                 :            : 
    1387                 :            :                 else
    1388                 :            :                         {
    1389                 :            :                         /* We matched some text prior to the EOB, first
    1390                 :            :                          * process it.
    1391                 :            :                          */
    1392                 :          0 :                         return EOB_ACT_LAST_MATCH;
    1393                 :            :                         }
    1394                 :            :                 }
    1395                 :            : 
    1396                 :            :         /* Try to read more data. */
    1397                 :            : 
    1398                 :            :         /* First move last chars to start of buffer. */
    1399                 :         14 :         number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
    1400                 :            : 
    1401         [ +  + ]:         48 :         for ( i = 0; i < number_to_move; ++i )
    1402                 :         34 :                 *(dest++) = *(source++);
    1403                 :            : 
    1404         [ -  + ]:         14 :         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
    1405                 :            :                 /* don't do the read, it's not guaranteed to return an EOF,
    1406                 :            :                  * just force an EOF
    1407                 :            :                  */
    1408                 :          0 :                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
    1409                 :            : 
    1410                 :            :         else
    1411                 :            :                 {
    1412                 :         14 :                         int num_to_read =
    1413                 :         14 :                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
    1414                 :            : 
    1415         [ -  + ]:         14 :                 while ( num_to_read <= 0 )
    1416                 :            :                         { /* Not enough room in the buffer - grow it. */
    1417                 :            : 
    1418                 :            :                         /* just a shorter name for the current buffer */
    1419                 :          0 :                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
    1420                 :            : 
    1421                 :          0 :                         int yy_c_buf_p_offset =
    1422                 :          0 :                                 (int) ((yy_c_buf_p) - b->yy_ch_buf);
    1423                 :            : 
    1424         [ #  # ]:          0 :                         if ( b->yy_is_our_buffer )
    1425                 :            :                                 {
    1426                 :          0 :                                 int new_size = b->yy_buf_size * 2;
    1427                 :            : 
    1428         [ #  # ]:          0 :                                 if ( new_size <= 0 )
    1429                 :          0 :                                         b->yy_buf_size += b->yy_buf_size / 8;
    1430                 :            :                                 else
    1431                 :          0 :                                         b->yy_buf_size *= 2;
    1432                 :            : 
    1433                 :          0 :                                 b->yy_ch_buf = (char *)
    1434                 :            :                                         /* Include room in for 2 EOB chars. */
    1435                 :          0 :                                         yyrealloc( (void *) b->yy_ch_buf,
    1436                 :          0 :                                                          (yy_size_t) (b->yy_buf_size + 2)  );
    1437                 :            :                                 }
    1438                 :            :                         else
    1439                 :            :                                 /* Can't grow it, we don't own it. */
    1440                 :          0 :                                 b->yy_ch_buf = NULL;
    1441                 :            : 
    1442         [ #  # ]:          0 :                         if ( ! b->yy_ch_buf )
    1443                 :          0 :                                 YY_FATAL_ERROR(
    1444                 :            :                                 "fatal error - scanner input buffer overflow" );
    1445                 :            : 
    1446                 :          0 :                         (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
    1447                 :            : 
    1448                 :          0 :                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
    1449                 :            :                                                 number_to_move - 1;
    1450                 :            : 
    1451                 :            :                         }
    1452                 :            : 
    1453                 :         14 :                 if ( num_to_read > YY_READ_BUF_SIZE )
    1454                 :            :                         num_to_read = YY_READ_BUF_SIZE;
    1455                 :            : 
    1456                 :            :                 /* Read in more data. */
    1457   [ -  +  -  -  :         28 :                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
          -  -  -  -  -  
          -  -  -  -  -  
          -  -  +  -  +  
                +  -  + ]
    1458                 :         14 :                         (yy_n_chars), num_to_read );
    1459                 :            : 
    1460                 :         14 :                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
    1461                 :            :                 }
    1462                 :            : 
    1463         [ +  + ]:         14 :         if ( (yy_n_chars) == 0 )
    1464                 :            :                 {
    1465         [ +  - ]:          2 :                 if ( number_to_move == YY_MORE_ADJ )
    1466                 :            :                         {
    1467                 :          2 :                         ret_val = EOB_ACT_END_OF_FILE;
    1468                 :          2 :                         yyrestart( yyin  );
    1469                 :            :                         }
    1470                 :            : 
    1471                 :            :                 else
    1472                 :            :                         {
    1473                 :          0 :                         ret_val = EOB_ACT_LAST_MATCH;
    1474                 :          0 :                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
    1475                 :            :                                 YY_BUFFER_EOF_PENDING;
    1476                 :            :                         }
    1477                 :            :                 }
    1478                 :            : 
    1479                 :            :         else
    1480                 :            :                 ret_val = EOB_ACT_CONTINUE_SCAN;
    1481                 :            : 
    1482         [ -  + ]:         14 :         if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
    1483                 :            :                 /* Extend the array by 50%, plus the number we really need. */
    1484                 :          0 :                 int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
    1485                 :          0 :                 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
    1486                 :          0 :                         (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size  );
    1487         [ #  # ]:          0 :                 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
    1488                 :          0 :                         YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
    1489                 :            :                 /* "- 2" to take care of EOB's */
    1490                 :          0 :                 YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
    1491                 :            :         }
    1492                 :            : 
    1493                 :         14 :         (yy_n_chars) += number_to_move;
    1494                 :         14 :         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
    1495                 :         14 :         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
    1496                 :            : 
    1497                 :         14 :         (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
    1498                 :            : 
    1499                 :         14 :         return ret_val;
    1500                 :            : }
    1501                 :            : 
    1502                 :            : /* yy_get_previous_state - get the state just before the EOB char was reached */
    1503                 :            : 
    1504                 :         12 :     static yy_state_type yy_get_previous_state (void)
    1505                 :            : {
    1506                 :         12 :         yy_state_type yy_current_state;
    1507                 :         12 :         char *yy_cp;
    1508                 :            :     
    1509                 :         12 :         yy_current_state = (yy_start);
    1510                 :         12 :         yy_current_state += YY_AT_BOL();
    1511                 :            : 
    1512         [ +  + ]:         46 :         for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
    1513                 :            :                 {
    1514         [ +  - ]:         34 :                 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
    1515         [ +  + ]:         34 :                 if ( yy_accept[yy_current_state] )
    1516                 :            :                         {
    1517                 :         20 :                         (yy_last_accepting_state) = yy_current_state;
    1518                 :         20 :                         (yy_last_accepting_cpos) = yy_cp;
    1519                 :            :                         }
    1520         [ +  + ]:         58 :                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
    1521                 :            :                         {
    1522                 :         24 :                         yy_current_state = (int) yy_def[yy_current_state];
    1523         [ +  - ]:         24 :                         if ( yy_current_state >= 62 )
    1524                 :         24 :                                 yy_c = yy_meta[yy_c];
    1525                 :            :                         }
    1526                 :         34 :                 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
    1527                 :            :                 }
    1528                 :            : 
    1529                 :         12 :         return yy_current_state;
    1530                 :            : }
    1531                 :            : 
    1532                 :            : /* yy_try_NUL_trans - try to make a transition on the NUL character
    1533                 :            :  *
    1534                 :            :  * synopsis
    1535                 :            :  *      next_state = yy_try_NUL_trans( current_state );
    1536                 :            :  */
    1537                 :          0 :     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
    1538                 :            : {
    1539                 :          0 :         int yy_is_jam;
    1540                 :          0 :         char *yy_cp = (yy_c_buf_p);
    1541                 :            : 
    1542                 :          0 :         YY_CHAR yy_c = 1;
    1543         [ #  # ]:          0 :         if ( yy_accept[yy_current_state] )
    1544                 :            :                 {
    1545                 :          0 :                 (yy_last_accepting_state) = yy_current_state;
    1546                 :          0 :                 (yy_last_accepting_cpos) = yy_cp;
    1547                 :            :                 }
    1548         [ #  # ]:          0 :         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
    1549                 :            :                 {
    1550                 :          0 :                 yy_current_state = (int) yy_def[yy_current_state];
    1551                 :          0 :                 if ( yy_current_state >= 62 )
    1552                 :            :                         yy_c = yy_meta[yy_c];
    1553                 :            :                 }
    1554                 :          0 :         yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
    1555                 :          0 :         yy_is_jam = (yy_current_state == 61);
    1556                 :            : 
    1557         [ #  # ]:          0 :                 return yy_is_jam ? 0 : yy_current_state;
    1558                 :            : }
    1559                 :            : 
    1560                 :            : #ifndef YY_NO_UNPUT
    1561                 :            : 
    1562                 :            :     static void yyunput (int c, char * yy_bp )
    1563                 :            : {
    1564                 :            :         char *yy_cp;
    1565                 :            :     
    1566                 :            :     yy_cp = (yy_c_buf_p);
    1567                 :            : 
    1568                 :            :         /* undo effects of setting up yytext */
    1569                 :            :         *yy_cp = (yy_hold_char);
    1570                 :            : 
    1571                 :            :         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
    1572                 :            :                 { /* need to shift things up to make room */
    1573                 :            :                 /* +2 for EOB chars. */
    1574                 :            :                 int number_to_move = (yy_n_chars) + 2;
    1575                 :            :                 char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
    1576                 :            :                                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
    1577                 :            :                 char *source =
    1578                 :            :                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
    1579                 :            : 
    1580                 :            :                 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
    1581                 :            :                         *--dest = *--source;
    1582                 :            : 
    1583                 :            :                 yy_cp += (int) (dest - source);
    1584                 :            :                 yy_bp += (int) (dest - source);
    1585                 :            :                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
    1586                 :            :                         (yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
    1587                 :            : 
    1588                 :            :                 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
    1589                 :            :                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
    1590                 :            :                 }
    1591                 :            : 
    1592                 :            :         *--yy_cp = (char) c;
    1593                 :            : 
    1594                 :            :     if ( c == '\n' ){
    1595                 :            :         --yylineno;
    1596                 :            :     }
    1597                 :            : 
    1598                 :            :         (yytext_ptr) = yy_bp;
    1599                 :            :         (yy_hold_char) = *yy_cp;
    1600                 :            :         (yy_c_buf_p) = yy_cp;
    1601                 :            : }
    1602                 :            : 
    1603                 :            : #endif
    1604                 :            : 
    1605                 :            : #ifndef YY_NO_INPUT
    1606                 :            : #ifdef __cplusplus
    1607                 :            :     static int yyinput (void)
    1608                 :            : #else
    1609                 :       1502 :     static int input  (void)
    1610                 :            : #endif
    1611                 :            : 
    1612                 :            : {
    1613                 :       1502 :         int c;
    1614                 :            :     
    1615                 :       1502 :         *(yy_c_buf_p) = (yy_hold_char);
    1616                 :            : 
    1617         [ -  + ]:       1502 :         if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
    1618                 :            :                 {
    1619                 :            :                 /* yy_c_buf_p now points to the character we want to return.
    1620                 :            :                  * If this occurs *before* the EOB characters, then it's a
    1621                 :            :                  * valid NUL; if not, then we've hit the end of the buffer.
    1622                 :            :                  */
    1623         [ #  # ]:          0 :                 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
    1624                 :            :                         /* This was really a NUL. */
    1625                 :          0 :                         *(yy_c_buf_p) = '\0';
    1626                 :            : 
    1627                 :            :                 else
    1628                 :            :                         { /* need more input */
    1629                 :          0 :                         int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
    1630                 :          0 :                         ++(yy_c_buf_p);
    1631                 :            : 
    1632   [ #  #  #  # ]:          0 :                         switch ( yy_get_next_buffer(  ) )
    1633                 :            :                                 {
    1634                 :          0 :                                 case EOB_ACT_LAST_MATCH:
    1635                 :            :                                         /* This happens because yy_g_n_b()
    1636                 :            :                                          * sees that we've accumulated a
    1637                 :            :                                          * token and flags that we need to
    1638                 :            :                                          * try matching the token before
    1639                 :            :                                          * proceeding.  But for input(),
    1640                 :            :                                          * there's no matching to consider.
    1641                 :            :                                          * So convert the EOB_ACT_LAST_MATCH
    1642                 :            :                                          * to EOB_ACT_END_OF_FILE.
    1643                 :            :                                          */
    1644                 :            : 
    1645                 :            :                                         /* Reset buffer status. */
    1646                 :          0 :                                         yyrestart( yyin );
    1647                 :            : 
    1648                 :            :                                         /*FALLTHROUGH*/
    1649                 :            : 
    1650                 :            :                                 case EOB_ACT_END_OF_FILE:
    1651                 :            :                                         {
    1652                 :          0 :                                         if ( yywrap(  ) )
    1653                 :          0 :                                                 return 0;
    1654                 :            : 
    1655                 :            :                                         if ( ! (yy_did_buffer_switch_on_eof) )
    1656                 :            :                                                 YY_NEW_FILE;
    1657                 :            : #ifdef __cplusplus
    1658                 :            :                                         return yyinput();
    1659                 :            : #else
    1660                 :            :                                         return input();
    1661                 :            : #endif
    1662                 :            :                                         }
    1663                 :            : 
    1664                 :          0 :                                 case EOB_ACT_CONTINUE_SCAN:
    1665                 :          0 :                                         (yy_c_buf_p) = (yytext_ptr) + offset;
    1666                 :          0 :                                         break;
    1667                 :            :                                 }
    1668                 :            :                         }
    1669                 :            :                 }
    1670                 :            : 
    1671                 :       1502 :         c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
    1672                 :       1502 :         *(yy_c_buf_p) = '\0';   /* preserve yytext */
    1673                 :       1502 :         (yy_hold_char) = *++(yy_c_buf_p);
    1674                 :            : 
    1675                 :       1502 :         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
    1676         [ +  + ]:       1502 :         if ( YY_CURRENT_BUFFER_LVALUE->yy_at_bol )
    1677                 :            :                 
    1678                 :        120 :     yylineno++;
    1679                 :            : ;
    1680                 :            : 
    1681                 :            :         return c;
    1682                 :            : }
    1683                 :            : #endif  /* ifndef YY_NO_INPUT */
    1684                 :            : 
    1685                 :            : /** Immediately switch to a different input stream.
    1686                 :            :  * @param input_file A readable stream.
    1687                 :            :  * 
    1688                 :            :  * @note This function does not reset the start condition to @c INITIAL .
    1689                 :            :  */
    1690                 :          2 :     void yyrestart  (FILE * input_file )
    1691                 :            : {
    1692                 :            :     
    1693   [ +  -  -  + ]:          2 :         if ( ! YY_CURRENT_BUFFER ){
    1694                 :          0 :         yyensure_buffer_stack ();
    1695                 :          0 :                 YY_CURRENT_BUFFER_LVALUE =
    1696                 :          0 :             yy_create_buffer( yyin, YY_BUF_SIZE );
    1697                 :            :         }
    1698                 :            : 
    1699         [ +  - ]:          2 :         yy_init_buffer( YY_CURRENT_BUFFER, input_file );
    1700                 :          2 :         yy_load_buffer_state(  );
    1701                 :          2 : }
    1702                 :            : 
    1703                 :            : /** Switch to a different input buffer.
    1704                 :            :  * @param new_buffer The new input buffer.
    1705                 :            :  * 
    1706                 :            :  */
    1707                 :          0 :     void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
    1708                 :            : {
    1709                 :            :     
    1710                 :            :         /* TODO. We should be able to replace this entire function body
    1711                 :            :          * with
    1712                 :            :          *              yypop_buffer_state();
    1713                 :            :          *              yypush_buffer_state(new_buffer);
    1714                 :            :      */
    1715                 :          0 :         yyensure_buffer_stack ();
    1716   [ #  #  #  # ]:          0 :         if ( YY_CURRENT_BUFFER == new_buffer )
    1717                 :            :                 return;
    1718                 :            : 
    1719   [ #  #  #  # ]:          0 :         if ( YY_CURRENT_BUFFER )
    1720                 :            :                 {
    1721                 :            :                 /* Flush out information for old buffer. */
    1722                 :          0 :                 *(yy_c_buf_p) = (yy_hold_char);
    1723                 :          0 :                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
    1724                 :          0 :                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
    1725                 :            :                 }
    1726                 :            : 
    1727                 :          0 :         YY_CURRENT_BUFFER_LVALUE = new_buffer;
    1728                 :          0 :         yy_load_buffer_state(  );
    1729                 :            : 
    1730                 :            :         /* We don't actually know whether we did this switch during
    1731                 :            :          * EOF (yywrap()) processing, but the only time this flag
    1732                 :            :          * is looked at is after yywrap() is called, so it's safe
    1733                 :            :          * to go ahead and always set it.
    1734                 :            :          */
    1735                 :          0 :         (yy_did_buffer_switch_on_eof) = 1;
    1736                 :            : }
    1737                 :            : 
    1738                 :          6 : static void yy_load_buffer_state  (void)
    1739                 :            : {
    1740                 :          6 :         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
    1741                 :          6 :         (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
    1742                 :          6 :         yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
    1743                 :          6 :         (yy_hold_char) = *(yy_c_buf_p);
    1744                 :          6 : }
    1745                 :            : 
    1746                 :            : /** Allocate and initialize an input buffer state.
    1747                 :            :  * @param file A readable stream.
    1748                 :            :  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
    1749                 :            :  * 
    1750                 :            :  * @return the allocated buffer state.
    1751                 :            :  */
    1752                 :          2 :     YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
    1753                 :            : {
    1754                 :          2 :         YY_BUFFER_STATE b;
    1755                 :            :     
    1756                 :          2 :         b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state )  );
    1757         [ -  + ]:          2 :         if ( ! b )
    1758                 :          0 :                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
    1759                 :            : 
    1760                 :          2 :         b->yy_buf_size = size;
    1761                 :            : 
    1762                 :            :         /* yy_ch_buf has to be 2 characters longer than the size given because
    1763                 :            :          * we need to put in 2 end-of-buffer characters.
    1764                 :            :          */
    1765                 :          2 :         b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2)  );
    1766         [ -  + ]:          2 :         if ( ! b->yy_ch_buf )
    1767                 :          0 :                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
    1768                 :            : 
    1769                 :          2 :         b->yy_is_our_buffer = 1;
    1770                 :            : 
    1771                 :          2 :         yy_init_buffer( b, file );
    1772                 :            : 
    1773                 :          2 :         return b;
    1774                 :            : }
    1775                 :            : 
    1776                 :            : /** Destroy the buffer.
    1777                 :            :  * @param b a buffer created with yy_create_buffer()
    1778                 :            :  * 
    1779                 :            :  */
    1780                 :          0 :     void yy_delete_buffer (YY_BUFFER_STATE  b )
    1781                 :            : {
    1782                 :            :     
    1783         [ #  # ]:          0 :         if ( ! b )
    1784                 :            :                 return;
    1785                 :            : 
    1786   [ #  #  #  # ]:          0 :         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
    1787                 :          0 :                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
    1788                 :            : 
    1789         [ #  # ]:          0 :         if ( b->yy_is_our_buffer )
    1790                 :          0 :                 yyfree( (void *) b->yy_ch_buf  );
    1791                 :            : 
    1792                 :          0 :         yyfree( (void *) b  );
    1793                 :            : }
    1794                 :            : 
    1795                 :            : /* Initializes or reinitializes a buffer.
    1796                 :            :  * This function is sometimes called more than once on the same buffer,
    1797                 :            :  * such as during a yyrestart() or at EOF.
    1798                 :            :  */
    1799                 :          4 :     static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
    1800                 :            : 
    1801                 :            : {
    1802                 :          4 :         int oerrno = errno;
    1803                 :            :     
    1804                 :          4 :         yy_flush_buffer( b );
    1805                 :            : 
    1806                 :          4 :         b->yy_input_file = file;
    1807                 :          4 :         b->yy_fill_buffer = 1;
    1808                 :            : 
    1809                 :            :     /* If b is the current buffer, then yy_init_buffer was _probably_
    1810                 :            :      * called from yyrestart() or through yy_get_next_buffer.
    1811                 :            :      * In that case, we don't want to reset the lineno or column.
    1812                 :            :      */
    1813   [ +  -  +  + ]:          4 :     if (b != YY_CURRENT_BUFFER){
    1814                 :          2 :         b->yy_bs_lineno = 1;
    1815                 :          2 :         b->yy_bs_column = 0;
    1816                 :            :     }
    1817                 :            : 
    1818                 :          4 :         b->yy_is_interactive = 0;
    1819                 :            :     
    1820                 :          4 :         errno = oerrno;
    1821                 :          4 : }
    1822                 :            : 
    1823                 :            : /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
    1824                 :            :  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
    1825                 :            :  * 
    1826                 :            :  */
    1827                 :          4 :     void yy_flush_buffer (YY_BUFFER_STATE  b )
    1828                 :            : {
    1829         [ +  - ]:          4 :         if ( ! b )
    1830                 :            :                 return;
    1831                 :            : 
    1832                 :          4 :         b->yy_n_chars = 0;
    1833                 :            : 
    1834                 :            :         /* We always need two end-of-buffer characters.  The first causes
    1835                 :            :          * a transition to the end-of-buffer state.  The second causes
    1836                 :            :          * a jam in that state.
    1837                 :            :          */
    1838                 :          4 :         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
    1839                 :          4 :         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
    1840                 :            : 
    1841                 :          4 :         b->yy_buf_pos = &b->yy_ch_buf[0];
    1842                 :            : 
    1843                 :          4 :         b->yy_at_bol = 1;
    1844                 :          4 :         b->yy_buffer_status = YY_BUFFER_NEW;
    1845                 :            : 
    1846   [ +  -  +  + ]:          4 :         if ( b == YY_CURRENT_BUFFER )
    1847                 :          2 :                 yy_load_buffer_state(  );
    1848                 :            : }
    1849                 :            : 
    1850                 :            : /** Pushes the new state onto the stack. The new state becomes
    1851                 :            :  *  the current state. This function will allocate the stack
    1852                 :            :  *  if necessary.
    1853                 :            :  *  @param new_buffer The new state.
    1854                 :            :  *  
    1855                 :            :  */
    1856                 :          0 : void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
    1857                 :            : {
    1858         [ #  # ]:          0 :         if (new_buffer == NULL)
    1859                 :            :                 return;
    1860                 :            : 
    1861                 :          0 :         yyensure_buffer_stack();
    1862                 :            : 
    1863                 :            :         /* This block is copied from yy_switch_to_buffer. */
    1864   [ #  #  #  # ]:          0 :         if ( YY_CURRENT_BUFFER )
    1865                 :            :                 {
    1866                 :            :                 /* Flush out information for old buffer. */
    1867                 :          0 :                 *(yy_c_buf_p) = (yy_hold_char);
    1868                 :          0 :                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
    1869                 :          0 :                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
    1870                 :            :                 }
    1871                 :            : 
    1872                 :            :         /* Only push if top exists. Otherwise, replace top. */
    1873   [ #  #  #  # ]:          0 :         if (YY_CURRENT_BUFFER)
    1874                 :          0 :                 (yy_buffer_stack_top)++;
    1875                 :          0 :         YY_CURRENT_BUFFER_LVALUE = new_buffer;
    1876                 :            : 
    1877                 :            :         /* copied from yy_switch_to_buffer. */
    1878                 :          0 :         yy_load_buffer_state(  );
    1879                 :          0 :         (yy_did_buffer_switch_on_eof) = 1;
    1880                 :            : }
    1881                 :            : 
    1882                 :            : /** Removes and deletes the top of the stack, if present.
    1883                 :            :  *  The next element becomes the new top.
    1884                 :            :  *  
    1885                 :            :  */
    1886                 :          0 : void yypop_buffer_state (void)
    1887                 :            : {
    1888   [ #  #  #  # ]:          0 :         if (!YY_CURRENT_BUFFER)
    1889                 :            :                 return;
    1890                 :            : 
    1891                 :          0 :         yy_delete_buffer(YY_CURRENT_BUFFER );
    1892                 :          0 :         YY_CURRENT_BUFFER_LVALUE = NULL;
    1893         [ #  # ]:          0 :         if ((yy_buffer_stack_top) > 0)
    1894                 :          0 :                 --(yy_buffer_stack_top);
    1895                 :            : 
    1896   [ #  #  #  # ]:          0 :         if (YY_CURRENT_BUFFER) {
    1897                 :          0 :                 yy_load_buffer_state(  );
    1898                 :          0 :                 (yy_did_buffer_switch_on_eof) = 1;
    1899                 :            :         }
    1900                 :            : }
    1901                 :            : 
    1902                 :            : /* Allocates the stack if it does not exist.
    1903                 :            :  *  Guarantees space for at least one push.
    1904                 :            :  */
    1905                 :          2 : static void yyensure_buffer_stack (void)
    1906                 :            : {
    1907                 :          2 :         yy_size_t num_to_alloc;
    1908                 :            :     
    1909         [ +  - ]:          2 :         if (!(yy_buffer_stack)) {
    1910                 :            : 
    1911                 :            :                 /* First allocation is just for 2 elements, since we don't know if this
    1912                 :            :                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
    1913                 :            :                  * immediate realloc on the next call.
    1914                 :            :          */
    1915                 :          2 :       num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
    1916                 :          2 :                 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
    1917                 :            :                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
    1918                 :            :                                                                 );
    1919         [ -  + ]:          2 :                 if ( ! (yy_buffer_stack) )
    1920                 :          0 :                         YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
    1921                 :            : 
    1922                 :          2 :                 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
    1923                 :            : 
    1924                 :          2 :                 (yy_buffer_stack_max) = num_to_alloc;
    1925                 :          2 :                 (yy_buffer_stack_top) = 0;
    1926                 :          2 :                 return;
    1927                 :            :         }
    1928                 :            : 
    1929         [ #  # ]:          0 :         if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
    1930                 :            : 
    1931                 :            :                 /* Increase the buffer to prepare for a possible push. */
    1932                 :          0 :                 yy_size_t grow_size = 8 /* arbitrary grow size */;
    1933                 :            : 
    1934                 :          0 :                 num_to_alloc = (yy_buffer_stack_max) + grow_size;
    1935                 :          0 :                 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
    1936                 :            :                                                                 ((yy_buffer_stack),
    1937                 :            :                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
    1938                 :            :                                                                 );
    1939         [ #  # ]:          0 :                 if ( ! (yy_buffer_stack) )
    1940                 :          0 :                         YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
    1941                 :            : 
    1942                 :            :                 /* zero only the new slots.*/
    1943                 :          0 :                 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
    1944                 :          0 :                 (yy_buffer_stack_max) = num_to_alloc;
    1945                 :            :         }
    1946                 :            : }
    1947                 :            : 
    1948                 :            : /** Setup the input buffer state to scan directly from a user-specified character buffer.
    1949                 :            :  * @param base the character buffer
    1950                 :            :  * @param size the size in bytes of the character buffer
    1951                 :            :  * 
    1952                 :            :  * @return the newly allocated buffer state object.
    1953                 :            :  */
    1954                 :          0 : YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
    1955                 :            : {
    1956                 :          0 :         YY_BUFFER_STATE b;
    1957                 :            :     
    1958         [ #  # ]:          0 :         if ( size < 2 ||
    1959         [ #  # ]:          0 :              base[size-2] != YY_END_OF_BUFFER_CHAR ||
    1960         [ #  # ]:          0 :              base[size-1] != YY_END_OF_BUFFER_CHAR )
    1961                 :            :                 /* They forgot to leave room for the EOB's. */
    1962                 :            :                 return NULL;
    1963                 :            : 
    1964                 :          0 :         b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state )  );
    1965         [ #  # ]:          0 :         if ( ! b )
    1966                 :          0 :                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
    1967                 :            : 
    1968                 :          0 :         b->yy_buf_size = (int) (size - 2);   /* "- 2" to take care of EOB's */
    1969                 :          0 :         b->yy_buf_pos = b->yy_ch_buf = base;
    1970                 :          0 :         b->yy_is_our_buffer = 0;
    1971                 :          0 :         b->yy_input_file = NULL;
    1972                 :          0 :         b->yy_n_chars = b->yy_buf_size;
    1973                 :          0 :         b->yy_is_interactive = 0;
    1974                 :          0 :         b->yy_at_bol = 1;
    1975                 :          0 :         b->yy_fill_buffer = 0;
    1976                 :          0 :         b->yy_buffer_status = YY_BUFFER_NEW;
    1977                 :            : 
    1978                 :          0 :         yy_switch_to_buffer( b  );
    1979                 :            : 
    1980                 :          0 :         return b;
    1981                 :            : }
    1982                 :            : 
    1983                 :            : /** Setup the input buffer state to scan a string. The next call to yylex() will
    1984                 :            :  * scan from a @e copy of @a str.
    1985                 :            :  * @param yystr a NUL-terminated string to scan
    1986                 :            :  * 
    1987                 :            :  * @return the newly allocated buffer state object.
    1988                 :            :  * @note If you want to scan bytes that may contain NUL values, then use
    1989                 :            :  *       yy_scan_bytes() instead.
    1990                 :            :  */
    1991                 :          0 : YY_BUFFER_STATE yy_scan_string (const char * yystr )
    1992                 :            : {
    1993                 :            :     
    1994                 :          0 :         return yy_scan_bytes( yystr, (int) strlen(yystr) );
    1995                 :            : }
    1996                 :            : 
    1997                 :            : /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
    1998                 :            :  * scan from a @e copy of @a bytes.
    1999                 :            :  * @param yybytes the byte buffer to scan
    2000                 :            :  * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
    2001                 :            :  * 
    2002                 :            :  * @return the newly allocated buffer state object.
    2003                 :            :  */
    2004                 :          0 : YY_BUFFER_STATE yy_scan_bytes  (const char * yybytes, int  _yybytes_len )
    2005                 :            : {
    2006                 :          0 :         YY_BUFFER_STATE b;
    2007                 :          0 :         char *buf;
    2008                 :          0 :         yy_size_t n;
    2009                 :          0 :         int i;
    2010                 :            :     
    2011                 :            :         /* Get memory for full buffer, including space for trailing EOB's. */
    2012                 :          0 :         n = (yy_size_t) (_yybytes_len + 2);
    2013                 :          0 :         buf = (char *) yyalloc( n  );
    2014         [ #  # ]:          0 :         if ( ! buf )
    2015                 :          0 :                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
    2016                 :            : 
    2017         [ #  # ]:          0 :         for ( i = 0; i < _yybytes_len; ++i )
    2018                 :          0 :                 buf[i] = yybytes[i];
    2019                 :            : 
    2020                 :          0 :         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
    2021                 :            : 
    2022                 :          0 :         b = yy_scan_buffer( buf, n );
    2023         [ #  # ]:          0 :         if ( ! b )
    2024                 :          0 :                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
    2025                 :            : 
    2026                 :            :         /* It's okay to grow etc. this buffer, and we should throw it
    2027                 :            :          * away when we're done.
    2028                 :            :          */
    2029                 :          0 :         b->yy_is_our_buffer = 1;
    2030                 :            : 
    2031                 :          0 :         return b;
    2032                 :            : }
    2033                 :            : 
    2034                 :            : #ifndef YY_EXIT_FAILURE
    2035                 :            : #define YY_EXIT_FAILURE 2
    2036                 :            : #endif
    2037                 :            : 
    2038                 :          0 : static void yynoreturn yy_fatal_error (const char* msg )
    2039                 :            : {
    2040                 :          0 :                         fprintf( stderr, "%s\n", msg );
    2041                 :          0 :         exit( YY_EXIT_FAILURE );
    2042                 :            : }
    2043                 :            : 
    2044                 :            : /* Redefine yyless() so it works in section 3 code. */
    2045                 :            : 
    2046                 :            : #undef yyless
    2047                 :            : #define yyless(n) \
    2048                 :            :         do \
    2049                 :            :                 { \
    2050                 :            :                 /* Undo effects of setting up yytext. */ \
    2051                 :            :         int yyless_macro_arg = (n); \
    2052                 :            :         YY_LESS_LINENO(yyless_macro_arg);\
    2053                 :            :                 yytext[yyleng] = (yy_hold_char); \
    2054                 :            :                 (yy_c_buf_p) = yytext + yyless_macro_arg; \
    2055                 :            :                 (yy_hold_char) = *(yy_c_buf_p); \
    2056                 :            :                 *(yy_c_buf_p) = '\0'; \
    2057                 :            :                 yyleng = yyless_macro_arg; \
    2058                 :            :                 } \
    2059                 :            :         while ( 0 )
    2060                 :            : 
    2061                 :            : /* Accessor  methods (get/set functions) to struct members. */
    2062                 :            : 
    2063                 :            : /** Get the current line number.
    2064                 :            :  * 
    2065                 :            :  */
    2066                 :          0 : int yyget_lineno  (void)
    2067                 :            : {
    2068                 :            :     
    2069                 :          0 :     return yylineno;
    2070                 :            : }
    2071                 :            : 
    2072                 :            : /** Get the input stream.
    2073                 :            :  * 
    2074                 :            :  */
    2075                 :          0 : FILE *yyget_in  (void)
    2076                 :            : {
    2077                 :          0 :         return yyin;
    2078                 :            : }
    2079                 :            : 
    2080                 :            : /** Get the output stream.
    2081                 :            :  * 
    2082                 :            :  */
    2083                 :          0 : FILE *yyget_out  (void)
    2084                 :            : {
    2085                 :          0 :         return yyout;
    2086                 :            : }
    2087                 :            : 
    2088                 :            : /** Get the length of the current token.
    2089                 :            :  * 
    2090                 :            :  */
    2091                 :          0 : int yyget_leng  (void)
    2092                 :            : {
    2093                 :          0 :         return yyleng;
    2094                 :            : }
    2095                 :            : 
    2096                 :            : /** Get the current token.
    2097                 :            :  * 
    2098                 :            :  */
    2099                 :            : 
    2100                 :          0 : char *yyget_text  (void)
    2101                 :            : {
    2102                 :          0 :         return yytext;
    2103                 :            : }
    2104                 :            : 
    2105                 :            : /** Set the current line number.
    2106                 :            :  * @param _line_number line number
    2107                 :            :  * 
    2108                 :            :  */
    2109                 :          0 : void yyset_lineno (int  _line_number )
    2110                 :            : {
    2111                 :            :     
    2112                 :          0 :     yylineno = _line_number;
    2113                 :          0 : }
    2114                 :            : 
    2115                 :            : /** Set the input stream. This does not discard the current
    2116                 :            :  * input buffer.
    2117                 :            :  * @param _in_str A readable stream.
    2118                 :            :  * 
    2119                 :            :  * @see yy_switch_to_buffer
    2120                 :            :  */
    2121                 :          0 : void yyset_in (FILE *  _in_str )
    2122                 :            : {
    2123                 :          0 :         yyin = _in_str ;
    2124                 :          0 : }
    2125                 :            : 
    2126                 :          0 : void yyset_out (FILE *  _out_str )
    2127                 :            : {
    2128                 :          0 :         yyout = _out_str ;
    2129                 :          0 : }
    2130                 :            : 
    2131                 :          0 : int yyget_debug  (void)
    2132                 :            : {
    2133                 :          0 :         return yy_flex_debug;
    2134                 :            : }
    2135                 :            : 
    2136                 :          0 : void yyset_debug (int  _bdebug )
    2137                 :            : {
    2138                 :          0 :         yy_flex_debug = _bdebug ;
    2139                 :          0 : }
    2140                 :            : 
    2141                 :          0 : static int yy_init_globals (void)
    2142                 :            : {
    2143                 :            :         /* Initialization is the same as for the non-reentrant scanner.
    2144                 :            :      * This function is called from yylex_destroy(), so don't allocate here.
    2145                 :            :      */
    2146                 :            : 
    2147                 :            :     /* We do not touch yylineno unless the option is enabled. */
    2148                 :          0 :     yylineno =  1;
    2149                 :            :     
    2150                 :          0 :     (yy_buffer_stack) = NULL;
    2151                 :          0 :     (yy_buffer_stack_top) = 0;
    2152                 :          0 :     (yy_buffer_stack_max) = 0;
    2153                 :          0 :     (yy_c_buf_p) = NULL;
    2154                 :          0 :     (yy_init) = 0;
    2155                 :          0 :     (yy_start) = 0;
    2156                 :            : 
    2157                 :            : /* Defined in main.c */
    2158                 :            : #ifdef YY_STDINIT
    2159                 :            :     yyin = stdin;
    2160                 :            :     yyout = stdout;
    2161                 :            : #else
    2162                 :          0 :     yyin = NULL;
    2163                 :          0 :     yyout = NULL;
    2164                 :            : #endif
    2165                 :            : 
    2166                 :            :     /* For future reference: Set errno on error, since we are called by
    2167                 :            :      * yylex_init()
    2168                 :            :      */
    2169                 :          0 :     return 0;
    2170                 :            : }
    2171                 :            : 
    2172                 :            : /* yylex_destroy is for both reentrant and non-reentrant scanners. */
    2173                 :          0 : int yylex_destroy  (void)
    2174                 :            : {
    2175                 :            :     
    2176                 :            :     /* Pop the buffer stack, destroying each element. */
    2177   [ #  #  #  # ]:          0 :         while(YY_CURRENT_BUFFER){
    2178                 :          0 :                 yy_delete_buffer( YY_CURRENT_BUFFER  );
    2179                 :          0 :                 YY_CURRENT_BUFFER_LVALUE = NULL;
    2180                 :          0 :                 yypop_buffer_state();
    2181                 :            :         }
    2182                 :            : 
    2183                 :            :         /* Destroy the stack itself. */
    2184                 :          0 :         yyfree((yy_buffer_stack) );
    2185                 :          0 :         (yy_buffer_stack) = NULL;
    2186                 :            : 
    2187                 :            :     /* Reset the globals. This is important in a non-reentrant scanner so the next time
    2188                 :            :      * yylex() is called, initialization will occur. */
    2189                 :          0 :     yy_init_globals( );
    2190                 :            : 
    2191                 :          0 :     return 0;
    2192                 :            : }
    2193                 :            : 
    2194                 :            : /*
    2195                 :            :  * Internal utility routines.
    2196                 :            :  */
    2197                 :            : 
    2198                 :            : #ifndef yytext_ptr
    2199                 :            : static void yy_flex_strncpy (char* s1, const char * s2, int n )
    2200                 :            : {
    2201                 :            :                 
    2202                 :            :         int i;
    2203                 :            :         for ( i = 0; i < n; ++i )
    2204                 :            :                 s1[i] = s2[i];
    2205                 :            : }
    2206                 :            : #endif
    2207                 :            : 
    2208                 :            : #ifdef YY_NEED_STRLEN
    2209                 :            : static int yy_flex_strlen (const char * s )
    2210                 :            : {
    2211                 :            :         int n;
    2212                 :            :         for ( n = 0; s[n]; ++n )
    2213                 :            :                 ;
    2214                 :            : 
    2215                 :            :         return n;
    2216                 :            : }
    2217                 :            : #endif
    2218                 :            : 
    2219                 :          6 : void *yyalloc (yy_size_t  size )
    2220                 :            : {
    2221                 :          6 :                         return malloc(size);
    2222                 :            : }
    2223                 :            : 
    2224                 :          0 : void *yyrealloc  (void * ptr, yy_size_t  size )
    2225                 :            : {
    2226                 :            :                 
    2227                 :            :         /* The cast to (char *) in the following accommodates both
    2228                 :            :          * implementations that use char* generic pointers, and those
    2229                 :            :          * that use void* generic pointers.  It works with the latter
    2230                 :            :          * because both ANSI C and C++ allow castless assignment from
    2231                 :            :          * any pointer type to void*, and deal with argument conversions
    2232                 :            :          * as though doing an assignment.
    2233                 :            :          */
    2234                 :          0 :         return realloc(ptr, size);
    2235                 :            : }
    2236                 :            : 
    2237                 :          0 : void yyfree (void * ptr )
    2238                 :            : {
    2239                 :          0 :                         free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
    2240                 :          0 : }
    2241                 :            : 
    2242                 :            : #define YYTABLES_NAME "yytables"
    2243                 :            : 
    2244                 :            : #line 103 "i386_lex.l"
    2245                 :            : 
    2246                 :            : 
    2247                 :            : static void
    2248                 :            : eat_to_eol (void)
    2249                 :            : {
    2250                 :            :   while (1)
    2251                 :            :     {
    2252                 :            :       int c = input ();
    2253                 :            : 
    2254                 :            :       if (c == EOF || c == '\n')
    2255                 :            :         break;
    2256                 :            :     }
    2257                 :            : }
    2258                 :            : 
    2259                 :            : static void
    2260                 :            : invalid_char (int ch)
    2261                 :            : {
    2262                 :            :   error (0, 0, (isascii (ch)
    2263                 :            :                 ? _("invalid character '%c' at line %d; ignored")
    2264                 :            :                 : _("invalid character '\\%o' at line %d; ignored")),
    2265                 :            :          ch, yylineno);
    2266                 :            : }
    2267                 :            : 
    2268                 :            : // Local Variables:
    2269                 :            : // mode: C
    2270                 :            : // End:
    2271                 :            : 

Generated by: LCOV version 1.16