Ignore:
Timestamp:
Aug 16, 2003, 6:59:22 PM (22 years ago)
Author:
bird
Message:

binutils v2.14 - offical sources.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/GNU/src/binutils/gas/itbl-lex.c

    • Property cvs2svn:cvs-rev changed from 1.1 to 1.1.1.2
    r608 r609  
     1
     2#line 3 "lex.yy.c"
     3
     4#define  YY_INT_ALIGNED short int
     5
    16/* A lexical scanner generated by flex */
    2 
    3 /* Scanner skeleton version:
    4  * $Header: /cvs/src/src/gas/Attic/itbl-lex.c,v 1.1.4.2 2001/06/10 15:37:28 pb Exp $
    5  */
    67
    78#define FLEX_SCANNER
    89#define YY_FLEX_MAJOR_VERSION 2
    910#define YY_FLEX_MINOR_VERSION 5
    10 
     11#define YY_FLEX_SUBMINOR_VERSION 31
     12#if YY_FLEX_SUBMINOR_VERSION > 0
     13#define FLEX_BETA
     14#endif
     15
     16/* First, we deal with  platform-specific or compiler-specific issues. */
     17
     18/* begin standard C headers. */
    1119#include <stdio.h>
    12 
    13 
    14 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
    15 #ifdef c_plusplus
    16 #ifndef __cplusplus
    17 #define __cplusplus
    18 #endif
    19 #endif
    20 
     20#include <string.h>
     21#include <errno.h>
     22#include <stdlib.h>
     23
     24/* end standard C headers. */
     25
     26/* flex integer type definitions */
     27
     28#ifndef FLEXINT_H
     29#define FLEXINT_H
     30
     31/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
     32
     33#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
     34#include <inttypes.h>
     35typedef int8_t flex_int8_t;
     36typedef uint8_t flex_uint8_t;
     37typedef int16_t flex_int16_t;
     38typedef uint16_t flex_uint16_t;
     39typedef int32_t flex_int32_t;
     40typedef uint32_t flex_uint32_t;
     41#else
     42typedef signed char flex_int8_t;
     43typedef short int flex_int16_t;
     44typedef int flex_int32_t;
     45typedef unsigned char flex_uint8_t;
     46typedef unsigned short int flex_uint16_t;
     47typedef unsigned int flex_uint32_t;
     48#endif /* ! C99 */
     49
     50/* Limits of integral types. */
     51#ifndef INT8_MIN
     52#define INT8_MIN               (-128)
     53#endif
     54#ifndef INT16_MIN
     55#define INT16_MIN              (-32767-1)
     56#endif
     57#ifndef INT32_MIN
     58#define INT32_MIN              (-2147483647-1)
     59#endif
     60#ifndef INT8_MAX
     61#define INT8_MAX               (127)
     62#endif
     63#ifndef INT16_MAX
     64#define INT16_MAX              (32767)
     65#endif
     66#ifndef INT32_MAX
     67#define INT32_MAX              (2147483647)
     68#endif
     69#ifndef UINT8_MAX
     70#define UINT8_MAX              (255U)
     71#endif
     72#ifndef UINT16_MAX
     73#define UINT16_MAX             (65535U)
     74#endif
     75#ifndef UINT32_MAX
     76#define UINT32_MAX             (4294967295U)
     77#endif
     78
     79#endif /* ! FLEXINT_H */
    2180
    2281#ifdef __cplusplus
    23 
    24 #include <stdlib.h>
    25 #include <unistd.h>
    26 
    27 /* Use prototypes in function declarations. */
    28 #define YY_USE_PROTOS
    2982
    3083/* The "const" storage-class-modifier is valid. */
    … …  
    3588#if __STDC__
    3689
    37 #define YY_USE_PROTOS
    3890#define YY_USE_CONST
    3991
    4092#endif  /* __STDC__ */
    4193#endif  /* ! __cplusplus */
    42 
    43 #ifdef __TURBOC__
    44  #pragma warn -rch
    45  #pragma warn -use
    46 #include <io.h>
    47 #include <stdlib.h>
    48 #define YY_USE_CONST
    49 #define YY_USE_PROTOS
    50 #endif
    5194
    5295#ifdef YY_USE_CONST
    … …  
    5699#endif
    57100
    58 
    59 #ifdef YY_USE_PROTOS
    60 #define YY_PROTO(proto) proto
    61 #else
    62 #define YY_PROTO(proto) ()
    63 #endif
    64 
    65101/* Returned upon end-of-file. */
    66102#define YY_NULL 0
    … …  
    77113 * definition of BEGIN.
    78114 */
    79 #define BEGIN yy_start = 1 + 2 *
     115#define BEGIN (yy_start) = 1 + 2 *
    80116
    81117/* Translate the current start state into a value that can be later handed
    … …  
    83119 * compatibility.
    84120 */
    85 #define YY_START ((yy_start - 1) / 2)
     121#define YY_START (((yy_start) - 1) / 2)
    86122#define YYSTATE YY_START
    87123
    … …  
    90126
    91127/* Special action meaning "start processing a new file". */
    92 #define YY_NEW_FILE yyrestart( yyin )
     128#define YY_NEW_FILE yyrestart(yyin )
    93129
    94130#define YY_END_OF_BUFFER_CHAR 0
    95131
    96132/* Size of default input buffer. */
     133#ifndef YY_BUF_SIZE
    97134#define YY_BUF_SIZE 16384
    98 
     135#endif
     136
     137#ifndef YY_TYPEDEF_YY_BUFFER_STATE
     138#define YY_TYPEDEF_YY_BUFFER_STATE
    99139typedef struct yy_buffer_state *YY_BUFFER_STATE;
     140#endif
    100141
    101142extern int yyleng;
     143
    102144extern FILE *yyin, *yyout;
    103145
    … …  
    106148#define EOB_ACT_LAST_MATCH 2
    107149
    108 /* The funky do-while in the following #define is used to turn the definition
    109  * int a single C statement (which needs a semi-colon terminator).  This
    110  * avoids problems with code like:
    111  *
    112  *      if ( condition_holds )
    113  *              yyless( 5 );
    114  *      else
    115  *              do_something_else();
    116  *
    117  * Prior to using the do-while the compiler would get upset at the
    118  * "else" because it interpreted the "if" statement as being all
    119  * done when it reached the ';' after the yyless() call.
    120  */
    121 
    122 /* Return all but the first 'n' matched characters back to the input stream. */
    123 
     150    #define YY_LESS_LINENO(n)
     151   
     152/* Return all but the first "n" matched characters back to the input stream. */
    124153#define yyless(n) \
    125154        do \
    126155                { \
    127156                /* Undo effects of setting up yytext. */ \
    128                 *yy_cp = yy_hold_char; \
     157        int yyless_macro_arg = (n); \
     158        YY_LESS_LINENO(yyless_macro_arg);\
     159                *yy_cp = (yy_hold_char); \
    129160                YY_RESTORE_YY_MORE_OFFSET \
    130                 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
     161                (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
    131162                YY_DO_BEFORE_ACTION; /* set up yytext again */ \
    132163                } \
    133164        while ( 0 )
    134165
    135 #define unput(c) yyunput( c, yytext_ptr )
     166#define unput(c) yyunput( c, (yytext_ptr) )
    136167
    137168/* The following is because we cannot portably get our hands on size_t
    … …  
    139170 * flex-generated scanners to compile on their own).
    140171 */
     172
     173#ifndef YY_TYPEDEF_YY_SIZE_T
     174#define YY_TYPEDEF_YY_SIZE_T
    141175typedef unsigned int yy_size_t;
    142 
    143 
     176#endif
     177
     178#ifndef YY_STRUCT_YY_BUFFER_STATE
     179#define YY_STRUCT_YY_BUFFER_STATE
    144180struct yy_buffer_state
    145181        {
    … …  
    178214        int yy_at_bol;
    179215
     216    int yy_bs_lineno; /**< The line count. */
     217    int yy_bs_column; /**< The column count. */
     218   
    180219        /* Whether to try to fill the input buffer when we reach the
    181220         * end of it.
    … …  
    184223
    185224        int yy_buffer_status;
     225
    186226#define YY_BUFFER_NEW 0
    187227#define YY_BUFFER_NORMAL 1
    … …  
    197237         */
    198238#define YY_BUFFER_EOF_PENDING 2
     239
    199240        };
    200 
    201 static YY_BUFFER_STATE yy_current_buffer = 0;
     241#endif /* !YY_STRUCT_YY_BUFFER_STATE */
     242
     243/* Stack of input buffers. */
     244static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
     245static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
     246static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
    202247
    203248/* We provide macros for accessing buffer states in case in the
    204249 * future we want to put the buffer states in a more general
    205250 * "scanner state".
    206  */
    207 #define YY_CURRENT_BUFFER yy_current_buffer
    208 
     251 *
     252 * Returns the top of the stack, or NULL.
     253 */
     254#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
     255                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
     256                          : NULL)
     257
     258/* Same as previous macro, but useful when we know that the buffer stack is not
     259 * NULL or when we need an lvalue. For internal use only.
     260 */
     261#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
    209262
    210263/* yy_hold_char holds the character lost when yytext is formed. */
    211264static char yy_hold_char;
    212 
    213265static int yy_n_chars;          /* number of characters read into yy_ch_buf */
    214 
    215 
    216266int yyleng;
    217267
    … …  
    226276static int yy_did_buffer_switch_on_eof;
    227277
    228 void yyrestart YY_PROTO(( FILE *input_file ));
    229 
    230 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
    231 void yy_load_buffer_state YY_PROTO(( void ));
    232 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
    233 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
    234 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
    235 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
    236 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
    237 
    238 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
    239 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
    240 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
    241 
    242 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
    243 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
    244 static void yy_flex_free YY_PROTO(( void * ));
     278void yyrestart (FILE *input_file  );
     279void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
     280YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
     281void yy_delete_buffer (YY_BUFFER_STATE b  );
     282void yy_flush_buffer (YY_BUFFER_STATE b  );
     283void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
     284void yypop_buffer_state (void );
     285
     286static void yyensure_buffer_stack (void );
     287static void yy_load_buffer_state (void );
     288static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
     289
     290#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
     291
     292YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
     293YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
     294YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );
     295
     296void *yyalloc (yy_size_t  );
     297void *yyrealloc (void *,yy_size_t  );
     298void yyfree (void *  );
    245299
    246300#define yy_new_buffer yy_create_buffer
    … …  
    248302#define yy_set_interactive(is_interactive) \
    249303        { \
    250         if ( ! yy_current_buffer ) \
    251                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
    252         yy_current_buffer->yy_is_interactive = is_interactive; \
     304        if ( ! YY_CURRENT_BUFFER ){ \
     305        yyensure_buffer_stack (); \
     306                YY_CURRENT_BUFFER_LVALUE =    \
     307            yy_create_buffer(yyin,YY_BUF_SIZE ); \
     308        } \
     309        YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
    253310        }
    254311
    255312#define yy_set_bol(at_bol) \
    256313        { \
    257         if ( ! yy_current_buffer ) \
    258                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
    259         yy_current_buffer->yy_at_bol = at_bol; \
     314        if ( ! YY_CURRENT_BUFFER ){\
     315        yyensure_buffer_stack (); \
     316                YY_CURRENT_BUFFER_LVALUE =    \
     317            yy_create_buffer(yyin,YY_BUF_SIZE ); \
     318        } \
     319        YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
    260320        }
    261321
    262 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
     322#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
     323
     324/* Begin user sect3 */
    263325
    264326typedef unsigned char YY_CHAR;
     327
    265328FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
     329
    266330typedef int yy_state_type;
     331
     332extern int yylineno;
     333
     334int yylineno = 1;
     335
    267336extern char *yytext;
    268337#define yytext_ptr yytext
    269338
    270 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
    271 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
    272 static int yy_get_next_buffer YY_PROTO(( void ));
    273 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
     339static yy_state_type yy_get_previous_state (void );
     340static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
     341static int yy_get_next_buffer (void );
     342static void yy_fatal_error (yyconst char msg[]  );
    274343
    275344/* Done after the current pattern has been matched and before the
    … …  
    277346 */
    278347#define YY_DO_BEFORE_ACTION \
    279         yytext_ptr = yy_bp; \
    280         yyleng = (int) (yy_cp - yy_bp); \
    281         yy_hold_char = *yy_cp; \
     348        (yytext_ptr) = yy_bp; \
     349        yyleng = (size_t) (yy_cp - yy_bp); \
     350        (yy_hold_char) = *yy_cp; \
    282351        *yy_cp = '\0'; \
    283         yy_c_buf_p = yy_cp;
     352        (yy_c_buf_p) = yy_cp;
    284353
    285354#define YY_NUM_RULES 15
    286355#define YY_END_OF_BUFFER 16
    287 static yyconst short int yy_accept[60] =
     356/* This struct is not used in this scanner,
     357   but its presence is necessary. */
     358struct yy_trans_info
     359        {
     360        flex_int32_t yy_verify;
     361        flex_int32_t yy_nxt;
     362        };
     363static yyconst flex_int16_t yy_accept[60] =
    288364    {   0,
    289365        0,    0,   16,   14,   13,   12,   11,    8,    8,   10,
    … …  
    295371    } ;
    296372
    297 static yyconst int yy_ec[256] =
     373static yyconst flex_int32_t yy_ec[256] =
    298374    {   0,
    299375        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
    … …  
    327403    } ;
    328404
    329 static yyconst int yy_meta[33] =
     405static yyconst flex_int32_t yy_meta[33] =
    330406    {   0,
    331407        1,    1,    1,    1,    1,    2,    2,    1,    2,    2,
    … …  
    335411    } ;
    336412
    337 static yyconst short int yy_base[62] =
     413static yyconst flex_int16_t yy_base[62] =
    338414    {   0,
    339415        0,    0,   83,   84,   84,   84,   84,   27,   29,   70,
    … …  
    346422    } ;
    347423
    348 static yyconst short int yy_def[62] =
     424static yyconst flex_int16_t yy_def[62] =
    349425    {   0,
    350426       59,    1,   59,   59,   59,   59,   59,   59,   59,   60,
    … …  
    357433    } ;
    358434
    359 static yyconst short int yy_nxt[117] =
     435static yyconst flex_int16_t yy_nxt[117] =
    360436    {   0,
    361437        4,    5,    6,    5,    7,    8,    9,    7,   10,   11,
    … …  
    374450    } ;
    375451
    376 static yyconst short int yy_chk[117] =
     452static yyconst flex_int16_t yy_chk[117] =
    377453    {   0,
    378454        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    … …  
    394470static char *yy_last_accepting_cpos;
    395471
     472extern int yy_flex_debug;
     473int yy_flex_debug = 0;
     474
    396475/* The intent behind this definition is that it'll catch
    397476 * any uses of REJECT which flex missed.
    … …  
    403482char *yytext;
    404483#line 1 "itbl-lex.l"
    405 #define INITIAL 0
    406484/* itbl-lex.l
    407    Copyright 1997, 1998 Free Software Foundation, Inc.
     485   Copyright 1997, 1998, 2001 Free Software Foundation, Inc.
    408486
    409487   This file is part of GAS, the GNU Assembler.
    … …  
    427505#include <string.h>
    428506#include <stdlib.h>
    429 #include <ctype.h>
    430 #include "itbl-parse.h"
     507
     508#include <itbl-parse.h>
    431509
    432510#ifdef DEBUG
    … …  
    439517
    440518int insntbl_line = 1;
    441 #line 442 "lex.yy.c"
     519#line 520 "lex.yy.c"
     520
     521#define INITIAL 0
     522
     523/* Special case for "unistd.h", since it is non-ANSI. We include it way
     524 * down here because we want the user's section 1 to have been scanned first.
     525 * The user has a chance to override it with an option.
     526 */
     527#include <unistd.h>
     528
     529#ifndef YY_EXTRA_TYPE
     530#define YY_EXTRA_TYPE void *
     531#endif
    442532
    443533/* Macros after this point can all be overridden by user definitions in
    … …  
    447537#ifndef YY_SKIP_YYWRAP
    448538#ifdef __cplusplus
    449 extern "C" int yywrap YY_PROTO(( void ));
     539extern "C" int yywrap (void );
    450540#else
    451 extern int yywrap YY_PROTO(( void ));
    452 #endif
    453 #endif
    454 
    455 #ifndef YY_NO_UNPUT
    456 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
    457 #endif
    458 
     541extern int yywrap (void );
     542#endif
     543#endif
     544
     545    static void yyunput (int c,char *buf_ptr  );
     546   
    459547#ifndef yytext_ptr
    460 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
     548static void yy_flex_strncpy (char *,yyconst char *,int );
    461549#endif
    462550
    463551#ifdef YY_NEED_STRLEN
    464 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
     552static int yy_flex_strlen (yyconst char * );
    465553#endif
    466554
    467555#ifndef YY_NO_INPUT
     556
    468557#ifdef __cplusplus
    469 static int yyinput YY_PROTO(( void ));
     558static int yyinput (void );
    470559#else
    471 static int input YY_PROTO(( void ));
    472 #endif
    473 #endif
    474 
    475 #if YY_STACK_USED
    476 static int yy_start_stack_ptr = 0;
    477 static int yy_start_stack_depth = 0;
    478 static int *yy_start_stack = 0;
    479 #ifndef YY_NO_PUSH_STATE
    480 static void yy_push_state YY_PROTO(( int new_state ));
    481 #endif
    482 #ifndef YY_NO_POP_STATE
    483 static void yy_pop_state YY_PROTO(( void ));
    484 #endif
    485 #ifndef YY_NO_TOP_STATE
    486 static int yy_top_state YY_PROTO(( void ));
    487 #endif
    488 
    489 #else
    490 #define YY_NO_PUSH_STATE 1
    491 #define YY_NO_POP_STATE 1
    492 #define YY_NO_TOP_STATE 1
    493 #endif
    494 
    495 #ifdef YY_MALLOC_DECL
    496 YY_MALLOC_DECL
    497 #else
    498 #if __STDC__
    499 #ifndef __cplusplus
    500 #include <stdlib.h>
    501 #endif
    502 #else
    503 /* Just try to get by without declaring the routines.  This will fail
    504  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
    505  * or sizeof(void*) != sizeof(int).
    506  */
    507 #endif
     560static int input (void );
     561#endif
     562
    508563#endif
    509564
    … …  
    514569
    515570/* Copy whatever the last rule matched to the standard output. */
    516 
    517571#ifndef ECHO
    518572/* This used to be an fputs(), but since the string might contain NUL's,
    … …  
    527581#ifndef YY_INPUT
    528582#define YY_INPUT(buf,result,max_size) \
    529         if ( yy_current_buffer->yy_is_interactive ) \
     583        if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
    530584                { \
    531                 int c = '*', n; \
     585                int c = '*'; \
     586                size_t n; \
    532587                for ( n = 0; n < max_size && \
    533588                             (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
    … …  
    539594                result = n; \
    540595                } \
    541         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
    542                   && ferror( yyin ) ) \
    543                 YY_FATAL_ERROR( "input in flex scanner failed" );
     596        else \
     597                { \
     598                errno=0; \
     599                while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
     600                        { \
     601                        if( errno != EINTR) \
     602                                { \
     603                                YY_FATAL_ERROR( "input in flex scanner failed" ); \
     604                                break; \
     605                                } \
     606                        errno=0; \
     607                        clearerr(yyin); \
     608                        } \
     609                }\
     610\
     611
    544612#endif
    545613
    … …  
    562630#endif
    563631
     632/* end tables serialization structures and prototypes */
     633
    564634/* Default declaration of generated scanner - a define so the user can
    565635 * easily add parameters.
    566636 */
    567637#ifndef YY_DECL
    568 #define YY_DECL int yylex YY_PROTO(( void ))
    569 #endif
     638#define YY_DECL_IS_OURS 1
     639
     640extern int yylex (void);
     641
     642#define YY_DECL int yylex (void)
     643#endif /* !YY_DECL */
    570644
    571645/* Code executed at the beginning of each rule, after yytext and yyleng
    … …  
    584658        YY_USER_ACTION
    585659
     660/** The main scanner function which does all the work.
     661 */
    586662YY_DECL
    587         {
     663{
    588664        register yy_state_type yy_current_state;
    589665        register char *yy_cp, *yy_bp;
    590666        register int yy_act;
    591 
     667   
    592668#line 44 "itbl-lex.l"
    593669
    594670
    595 #line 596 "lex.yy.c"
    596 
    597         if ( yy_init )
     671#line 672 "lex.yy.c"
     672
     673        if ( (yy_init) )
    598674                {
    599                 yy_init = 0;
     675                (yy_init) = 0;
    600676
    601677#ifdef YY_USER_INIT
    … …  
    603679#endif
    604680
    605                 if ( ! yy_start )
    606                         yy_start = 1;   /* first start state */
     681                if ( ! (yy_start) )
     682                        (yy_start) = 1; /* first start state */
    607683
    608684                if ( ! yyin )
    … …  
    612688                        yyout = stdout;
    613689
    614                 if ( ! yy_current_buffer )
    615                         yy_current_buffer =
    616                                 yy_create_buffer( yyin, YY_BUF_SIZE );
    617 
    618                 yy_load_buffer_state();
     690                if ( ! YY_CURRENT_BUFFER ) {
     691                        yyensure_buffer_stack ();
     692                        YY_CURRENT_BUFFER_LVALUE =
     693                                yy_create_buffer(yyin,YY_BUF_SIZE );
     694                }
     695
     696                yy_load_buffer_state( );
    619697                }
    620698
    621699        while ( 1 )             /* loops until end-of-file is reached */
    622700                {
    623                 yy_cp = yy_c_buf_p;
     701                yy_cp = (yy_c_buf_p);
    624702
    625703                /* Support of yytext. */
    626                 *yy_cp = yy_hold_char;
     704                *yy_cp = (yy_hold_char);
    627705
    628706                /* yy_bp points to the position in yy_ch_buf of the start of
    … …  
    631709                yy_bp = yy_cp;
    632710
    633                 yy_current_state = yy_start;
     711                yy_current_state = (yy_start);
    634712yy_match:
    635713                do
    … …  
    638716                        if ( yy_accept[yy_current_state] )
    639717                                {
    640                                 yy_last_accepting_state = yy_current_state;
    641                                 yy_last_accepting_cpos = yy_cp;
     718                                (yy_last_accepting_state) = yy_current_state;
     719                                (yy_last_accepting_cpos) = yy_cp;
    642720                                }
    643721                        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
    … …  
    656734                if ( yy_act == 0 )
    657735                        { /* have to back up */
    658                         yy_cp = yy_last_accepting_cpos;
    659                         yy_current_state = yy_last_accepting_state;
     736                        yy_cp = (yy_last_accepting_cpos);
     737                        yy_current_state = (yy_last_accepting_state);
    660738                        yy_act = yy_accept[yy_current_state];
    661739                        }
    … …  
    663741                YY_DO_BEFORE_ACTION;
    664742
    665 
    666743do_action:      /* This label is used only to access EOF actions. */
    667 
    668744
    669745                switch ( yy_act )
    … …  
    671747                        case 0: /* must back up */
    672748                        /* undo the effects of YY_DO_BEFORE_ACTION */
    673                         *yy_cp = yy_hold_char;
    674                         yy_cp = yy_last_accepting_cpos;
    675                         yy_current_state = yy_last_accepting_state;
     749                        *yy_cp = (yy_hold_char);
     750                        yy_cp = (yy_last_accepting_cpos);
     751                        yy_current_state = (yy_last_accepting_state);
    676752                        goto yy_find_action;
    677753
    … …  
    770846        YY_BREAK
    771847case 12:
     848/* rule 12 can match eol */
    772849YY_RULE_SETUP
    773850#line 95 "itbl-lex.l"
    … …  
    797874ECHO;
    798875        YY_BREAK
    799 #line 800 "lex.yy.c"
     876#line 877 "lex.yy.c"
    800877case YY_STATE_EOF(INITIAL):
    801878        yyterminate();
    … …  
    804881                {
    805882                /* Amount of text matched not including the EOB char. */
    806                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
     883                int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
    807884
    808885                /* Undo the effects of YY_DO_BEFORE_ACTION. */
    809                 *yy_cp = yy_hold_char;
     886                *yy_cp = (yy_hold_char);
    810887                YY_RESTORE_YY_MORE_OFFSET
    811888
    812                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
     889                if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
    813890                        {
    814891                        /* We're scanning a new file or input source.  It's
    … …  
    816893                         * just pointed yyin at a new source and called
    817894                         * yylex().  If so, then we have to assure
    818                          * consistency between yy_current_buffer and our
     895                         * consistency between YY_CURRENT_BUFFER and our
    819896                         * globals.  Here is the right place to do so, because
    820897                         * this is the first action (other than possibly a
    821898                         * back-up) that will match for the new input source.
    822899                         */
    823                         yy_n_chars = yy_current_buffer->yy_n_chars;
    824                         yy_current_buffer->yy_input_file = yyin;
    825                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
     900                        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
     901                        YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
     902                        YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
    826903                        }
    827904
    … …  
    833910                 * in input().
    834911                 */
    835                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
     912                if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
    836913                        { /* This was really a NUL. */
    837914                        yy_state_type yy_next_state;
    838915
    839                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
    840 
    841                         yy_current_state = yy_get_previous_state();
     916                        (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
     917
     918                        yy_current_state = yy_get_previous_state(  );
    842919
    843920                        /* Okay, we're now positioned to make the NUL
    … …  
    852929                        yy_next_state = yy_try_NUL_trans( yy_current_state );
    853930
    854                         yy_bp = yytext_ptr + YY_MORE_ADJ;
     931                        yy_bp = (yytext_ptr) + YY_MORE_ADJ;
    855932
    856933                        if ( yy_next_state )
    857934                                {
    858935                                /* Consume the NUL. */
    859                                 yy_cp = ++yy_c_buf_p;
     936                                yy_cp = ++(yy_c_buf_p);
    860937                                yy_current_state = yy_next_state;
    861938                                goto yy_match;
    … …  
    864941                        else
    865942                                {
    866                                 yy_cp = yy_c_buf_p;
     943                                yy_cp = (yy_c_buf_p);
    867944                                goto yy_find_action;
    868945                                }
    869946                        }
    870947
    871                 else switch ( yy_get_next_buffer() )
     948                else switch ( yy_get_next_buffer(  ) )
    872949                        {
    873950                        case EOB_ACT_END_OF_FILE:
    874951                                {
    875                                 yy_did_buffer_switch_on_eof = 0;
    876 
    877                                 if ( yywrap() )
     952                                (yy_did_buffer_switch_on_eof) = 0;
     953
     954                                if ( yywrap( ) )
    878955                                        {
    879956                                        /* Note: because we've taken care in
    … …  
    886963                                         * YY_NULL will get returned.
    887964                                         */
    888                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
     965                                        (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
    889966
    890967                                        yy_act = YY_STATE_EOF(YY_START);
    … …  
    894971                                else
    895972                                        {
    896                                         if ( ! yy_did_buffer_switch_on_eof )
     973                                        if ( ! (yy_did_buffer_switch_on_eof) )
    897974                                                YY_NEW_FILE;
    898975                                        }
    … …  
    901978
    902979                        case EOB_ACT_CONTINUE_SCAN:
    903                                 yy_c_buf_p =
    904                                         yytext_ptr + yy_amount_of_matched_text;
    905 
    906                                 yy_current_state = yy_get_previous_state();
    907 
    908                                 yy_cp = yy_c_buf_p;
    909                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
     980                                (yy_c_buf_p) =
     981                                        (yytext_ptr) + yy_amount_of_matched_text;
     982
     983                                yy_current_state = yy_get_previous_state(  );
     984
     985                                yy_cp = (yy_c_buf_p);
     986                                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
    910987                                goto yy_match;
    911988
    912989                        case EOB_ACT_LAST_MATCH:
    913                                 yy_c_buf_p =
    914                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
    915 
    916                                 yy_current_state = yy_get_previous_state();
    917 
    918                                 yy_cp = yy_c_buf_p;
    919                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
     990                                (yy_c_buf_p) =
     991                                &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
     992
     993                                yy_current_state = yy_get_previous_state(  );
     994
     995                                yy_cp = (yy_c_buf_p);
     996                                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
    920997                                goto yy_find_action;
    921998                        }
    … …  
    9281005        } /* end of action switch */
    9291006                } /* end of scanning one token */
    930         } /* end of yylex */
    931 
     1007} /* end of yylex */
    9321008
    9331009/* yy_get_next_buffer - try to read in a new buffer
    … …  
    9381014 *      EOB_ACT_END_OF_FILE - end of file
    9391015 */
    940 
    941 static int yy_get_next_buffer()
    942         {
    943         register char *dest = yy_current_buffer->yy_ch_buf;
    944         register char *source = yytext_ptr;
     1016static int yy_get_next_buffer (void)
     1017{
     1018        register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
     1019        register char *source = (yytext_ptr);
    9451020        register int number_to_move, i;
    9461021        int ret_val;
    9471022
    948         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
     1023        if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
    9491024                YY_FATAL_ERROR(
    9501025                "fatal flex scanner internal error--end of buffer missed" );
    9511026
    952         if ( yy_current_buffer->yy_fill_buffer == 0 )
     1027        if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
    9531028                { /* Don't try to fill the buffer, so this is an EOF. */
    954                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
     1029                if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
    9551030                        {
    9561031                        /* We matched a single character, the EOB, so
    … …  
    9721047
    9731048        /* First move last chars to start of buffer. */
    974         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
     1049        number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
    9751050
    9761051        for ( i = 0; i < number_to_move; ++i )
    9771052                *(dest++) = *(source++);
    9781053
    979         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
     1054        if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
    9801055                /* don't do the read, it's not guaranteed to return an EOF,
    9811056                 * just force an EOF
    9821057                 */
    983                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
     1058                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
    9841059
    9851060        else
    9861061                {
    987                 int num_to_read =
    988                         yy_current_buffer->yy_buf_size - number_to_move - 1;
     1062                        size_t num_to_read =
     1063                        YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
    9891064
    9901065                while ( num_to_read <= 0 )
    9911066                        { /* Not enough room in the buffer - grow it. */
    992 #ifdef YY_USES_REJECT
    993                         YY_FATAL_ERROR(
    994 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
    995 #else
    9961067
    9971068                        /* just a shorter name for the current buffer */
    998                         YY_BUFFER_STATE b = yy_current_buffer;
     1069                        YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
    9991070
    10001071                        int yy_c_buf_p_offset =
    1001                                 (int) (yy_c_buf_p - b->yy_ch_buf);
     1072                                (int) ((yy_c_buf_p) - b->yy_ch_buf);
    10021073
    10031074                        if ( b->yy_is_our_buffer )
    … …  
    10121083                                b->yy_ch_buf = (char *)
    10131084                                        /* Include room in for 2 EOB chars. */
    1014                                         yy_flex_realloc( (void *) b->yy_ch_buf,
    1015                                                          b->yy_buf_size + 2 );
     1085                                        yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
    10161086                                }
    10171087                        else
    … …  
    10231093                                "fatal error - scanner input buffer overflow" );
    10241094
    1025                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
    1026 
    1027                         num_to_read = yy_current_buffer->yy_buf_size -
     1095                        (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
     1096
     1097                        num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
    10281098                                                number_to_move - 1;
    1029 #endif
     1099
    10301100                        }
    10311101
    … …  
    10341104
    10351105                /* Read in more data. */
    1036                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
    1037                         yy_n_chars, num_to_read );
    1038 
    1039                 yy_current_buffer->yy_n_chars = yy_n_chars;
     1106                YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
     1107                        (yy_n_chars), num_to_read );
     1108
     1109                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
    10401110                }
    10411111
    1042         if ( yy_n_chars == 0 )
     1112        if ( (yy_n_chars) == 0 )
    10431113                {
    10441114                if ( number_to_move == YY_MORE_ADJ )
    10451115                        {
    10461116                        ret_val = EOB_ACT_END_OF_FILE;
    1047                         yyrestart( yyin );
     1117                        yyrestart(yyin );
    10481118                        }
    10491119
    … …  
    10511121                        {
    10521122                        ret_val = EOB_ACT_LAST_MATCH;
    1053                         yy_current_buffer->yy_buffer_status =
     1123                        YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
    10541124                                YY_BUFFER_EOF_PENDING;
    10551125                        }
    … …  
    10591129                ret_val = EOB_ACT_CONTINUE_SCAN;
    10601130
    1061         yy_n_chars += number_to_move;
    1062         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
    1063         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
    1064 
    1065         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
     1131        (yy_n_chars) += number_to_move;
     1132        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
     1133        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
     1134
     1135        (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
    10661136
    10671137        return ret_val;
    1068         }
    1069 
     1138}
    10701139
    10711140/* yy_get_previous_state - get the state just before the EOB char was reached */
    10721141
    1073 static yy_state_type yy_get_previous_state()
    1074         {
     1142    static yy_state_type yy_get_previous_state (void)
     1143{
    10751144        register yy_state_type yy_current_state;
    10761145        register char *yy_cp;
    1077 
    1078         yy_current_state = yy_start;
    1079 
    1080         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
     1146   
     1147        yy_current_state = (yy_start);
     1148
     1149        for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
    10811150                {
    10821151                register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
    10831152                if ( yy_accept[yy_current_state] )
    10841153                        {
    1085                         yy_last_accepting_state = yy_current_state;
    1086                         yy_last_accepting_cpos = yy_cp;
     1154                        (yy_last_accepting_state) = yy_current_state;
     1155                        (yy_last_accepting_cpos) = yy_cp;
    10871156                        }
    10881157                while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
    … …  
    10961165
    10971166        return yy_current_state;
    1098         }
    1099 
     1167}
    11001168
    11011169/* yy_try_NUL_trans - try to make a transition on the NUL character
    … …  
    11041172 *      next_state = yy_try_NUL_trans( current_state );
    11051173 */
    1106 
    1107 #ifdef YY_USE_PROTOS
    1108 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
    1109 #else
    1110 static yy_state_type yy_try_NUL_trans( yy_current_state )
    1111 yy_state_type yy_current_state;
    1112 #endif
    1113         {
     1174    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
     1175{
    11141176        register int yy_is_jam;
    1115         register char *yy_cp = yy_c_buf_p;
     1177        register char *yy_cp = (yy_c_buf_p);
    11161178
    11171179        register YY_CHAR yy_c = 1;
    11181180        if ( yy_accept[yy_current_state] )
    11191181                {
    1120                 yy_last_accepting_state = yy_current_state;
    1121                 yy_last_accepting_cpos = yy_cp;
     1182                (yy_last_accepting_state) = yy_current_state;
     1183                (yy_last_accepting_cpos) = yy_cp;
    11221184                }
    11231185        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
    … …  
    11311193
    11321194        return yy_is_jam ? 0 : yy_current_state;
    1133         }
    1134 
    1135 
    1136 #ifndef YY_NO_UNPUT
    1137 #ifdef YY_USE_PROTOS
    1138 static void yyunput( int c, register char *yy_bp )
    1139 #else
    1140 static void yyunput( c, yy_bp )
    1141 int c;
    1142 register char *yy_bp;
    1143 #endif
    1144         {
    1145         register char *yy_cp = yy_c_buf_p;
     1195}
     1196
     1197    static void yyunput (int c, register char * yy_bp )
     1198{
     1199        register char *yy_cp;
     1200   
     1201    yy_cp = (yy_c_buf_p);
    11461202
    11471203        /* undo effects of setting up yytext */
    1148         *yy_cp = yy_hold_char;
    1149 
    1150         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
     1204        *yy_cp = (yy_hold_char);
     1205
     1206        if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
    11511207                { /* need to shift things up to make room */
    11521208                /* +2 for EOB chars. */
    1153                 register int number_to_move = yy_n_chars + 2;
    1154                 register char *dest = &yy_current_buffer->yy_ch_buf[
    1155                                         yy_current_buffer->yy_buf_size + 2];
     1209                register int number_to_move = (yy_n_chars) + 2;
     1210                register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
     1211                                        YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
    11561212                register char *source =
    1157                                 &yy_current_buffer->yy_ch_buf[number_to_move];
    1158 
    1159                 while ( source > yy_current_buffer->yy_ch_buf )
     1213                                &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
     1214
     1215                while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
    11601216                        *--dest = *--source;
    11611217
    11621218                yy_cp += (int) (dest - source);
    11631219                yy_bp += (int) (dest - source);
    1164                 yy_current_buffer->yy_n_chars =
    1165                         yy_n_chars = yy_current_buffer->yy_buf_size;
    1166 
    1167                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
     1220                YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
     1221                        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
     1222
     1223                if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
    11681224                        YY_FATAL_ERROR( "flex scanner push-back overflow" );
    11691225                }
    … …  
    11711227        *--yy_cp = (char) c;
    11721228
    1173 
    1174         yytext_ptr = yy_bp;
    1175         yy_hold_char = *yy_cp;
    1176         yy_c_buf_p = yy_cp;
    1177         }
    1178 #endif  /* ifndef YY_NO_UNPUT */
    1179 
    1180 
     1229        (yytext_ptr) = yy_bp;
     1230        (yy_hold_char) = *yy_cp;
     1231        (yy_c_buf_p) = yy_cp;
     1232}
     1233
     1234#ifndef YY_NO_INPUT
    11811235#ifdef __cplusplus
    1182 static int yyinput()
     1236    static int yyinput (void)
    11831237#else
    1184 static int input()
    1185 #endif
    1186         {
     1238    static int input  (void)
     1239#endif
     1240
     1241{
    11871242        int c;
    1188 
    1189         *yy_c_buf_p = yy_hold_char;
    1190 
    1191         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
     1243   
     1244        *(yy_c_buf_p) = (yy_hold_char);
     1245
     1246        if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
    11921247                {
    11931248                /* yy_c_buf_p now points to the character we want to return.
    … …  
    11951250                 * valid NUL; if not, then we've hit the end of the buffer.
    11961251                 */
    1197                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
     1252                if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
    11981253                        /* This was really a NUL. */
    1199                         *yy_c_buf_p = '\0';
     1254                        *(yy_c_buf_p) = '\0';
    12001255
    12011256                else
    12021257                        { /* need more input */
    1203                         int offset = yy_c_buf_p - yytext_ptr;
    1204                         ++yy_c_buf_p;
    1205 
    1206                         switch ( yy_get_next_buffer() )
     1258                        int offset = (yy_c_buf_p) - (yytext_ptr);
     1259                        ++(yy_c_buf_p);
     1260
     1261                        switch ( yy_get_next_buffer(  ) )
    12071262                                {
    12081263                                case EOB_ACT_LAST_MATCH:
    … …  
    12181273
    12191274                                        /* Reset buffer status. */
    1220                                         yyrestart( yyin );
    1221 
    1222                                         /* fall through */
     1275                                        yyrestart(yyin );
     1276
     1277                                        /*FALLTHROUGH*/
    12231278
    12241279                                case EOB_ACT_END_OF_FILE:
    12251280                                        {
    1226                                         if ( yywrap() )
     1281                                        if ( yywrap( ) )
    12271282                                                return EOF;
    12281283
    1229                                         if ( ! yy_did_buffer_switch_on_eof )
     1284                                        if ( ! (yy_did_buffer_switch_on_eof) )
    12301285                                                YY_NEW_FILE;
    12311286#ifdef __cplusplus
    … …  
    12371292
    12381293                                case EOB_ACT_CONTINUE_SCAN:
    1239                                         yy_c_buf_p = yytext_ptr + offset;
     1294                                        (yy_c_buf_p) = (yytext_ptr) + offset;
    12401295                                        break;
    12411296                                }
    … …  
    12431298                }
    12441299
    1245         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
    1246         *yy_c_buf_p = '\0';     /* preserve yytext */
    1247         yy_hold_char = *++yy_c_buf_p;
    1248 
     1300        c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
     1301        *(yy_c_buf_p) = '\0';   /* preserve yytext */
     1302        (yy_hold_char) = *++(yy_c_buf_p);
    12491303
    12501304        return c;
     1305}
     1306#endif  /* ifndef YY_NO_INPUT */
     1307
     1308/** Immediately switch to a different input stream.
     1309 * @param input_file A readable stream.
     1310 *
     1311 * @note This function does not reset the start condition to @c INITIAL .
     1312 */
     1313    void yyrestart  (FILE * input_file )
     1314{
     1315   
     1316        if ( ! YY_CURRENT_BUFFER ){
     1317        yyensure_buffer_stack ();
     1318                YY_CURRENT_BUFFER_LVALUE =
     1319            yy_create_buffer(yyin,YY_BUF_SIZE );
    12511320        }
    12521321
    1253 
    1254 #ifdef YY_USE_PROTOS
    1255 void yyrestart( FILE *input_file )
    1256 #else
    1257 void yyrestart( input_file )
    1258 FILE *input_file;
    1259 #endif
    1260         {
    1261         if ( ! yy_current_buffer )
    1262                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
    1263 
    1264         yy_init_buffer( yy_current_buffer, input_file );
    1265         yy_load_buffer_state();
    1266         }
    1267 
    1268 
    1269 #ifdef YY_USE_PROTOS
    1270 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
    1271 #else
    1272 void yy_switch_to_buffer( new_buffer )
    1273 YY_BUFFER_STATE new_buffer;
    1274 #endif
    1275         {
    1276         if ( yy_current_buffer == new_buffer )
     1322        yy_init_buffer(YY_CURRENT_BUFFER,input_file );
     1323        yy_load_buffer_state( );
     1324}
     1325
     1326/** Switch to a different input buffer.
     1327 * @param new_buffer The new input buffer.
     1328 *
     1329 */
     1330    void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
     1331{
     1332   
     1333        /* TODO. We should be able to replace this entire function body
     1334         * with
     1335         *              yypop_buffer_state();
     1336         *              yypush_buffer_state(new_buffer);
     1337     */
     1338        yyensure_buffer_stack ();
     1339        if ( YY_CURRENT_BUFFER == new_buffer )
    12771340                return;
    12781341
    1279         if ( yy_current_buffer )
     1342        if ( YY_CURRENT_BUFFER )
    12801343                {
    12811344                /* Flush out information for old buffer. */
    1282                 *yy_c_buf_p = yy_hold_char;
    1283                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
    1284                 yy_current_buffer->yy_n_chars = yy_n_chars;
     1345                *(yy_c_buf_p) = (yy_hold_char);
     1346                YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
     1347                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
    12851348                }
    12861349
    1287         yy_current_buffer = new_buffer;
    1288         yy_load_buffer_state();
     1350        YY_CURRENT_BUFFER_LVALUE = new_buffer;
     1351        yy_load_buffer_state( );
    12891352
    12901353        /* We don't actually know whether we did this switch during
    … …  
    12931356         * to go ahead and always set it.
    12941357         */
    1295         yy_did_buffer_switch_on_eof = 1;
    1296         }
    1297 
    1298 
    1299 #ifdef YY_USE_PROTOS
    1300 void yy_load_buffer_state( void )
    1301 #else
    1302 void yy_load_buffer_state()
    1303 #endif
    1304         {
    1305         yy_n_chars = yy_current_buffer->yy_n_chars;
    1306         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
    1307         yyin = yy_current_buffer->yy_input_file;
    1308         yy_hold_char = *yy_c_buf_p;
    1309         }
    1310 
    1311 
    1312 #ifdef YY_USE_PROTOS
    1313 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
    1314 #else
    1315 YY_BUFFER_STATE yy_create_buffer( file, size )
    1316 FILE *file;
    1317 int size;
    1318 #endif
    1319         {
     1358        (yy_did_buffer_switch_on_eof) = 1;
     1359}
     1360
     1361static void yy_load_buffer_state  (void)
     1362{
     1363        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
     1364        (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
     1365        yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
     1366        (yy_hold_char) = *(yy_c_buf_p);
     1367}
     1368
     1369/** Allocate and initialize an input buffer state.
     1370 * @param file A readable stream.
     1371 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
     1372 *
     1373 * @return the allocated buffer state.
     1374 */
     1375    YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
     1376{
    13201377        YY_BUFFER_STATE b;
    1321 
    1322         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
     1378   
     1379        b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
    13231380        if ( ! b )
    13241381                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
    … …  
    13291386         * we need to put in 2 end-of-buffer characters.
    13301387         */
    1331         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
     1388        b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 );
    13321389        if ( ! b->yy_ch_buf )
    13331390                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
    … …  
    13351392        b->yy_is_our_buffer = 1;
    13361393
    1337         yy_init_buffer( b, file );
     1394        yy_init_buffer(b,file );
    13381395
    13391396        return b;
    1340         }
    1341 
    1342 
    1343 #ifdef YY_USE_PROTOS
    1344 void yy_delete_buffer( YY_BUFFER_STATE b )
    1345 #else
    1346 void yy_delete_buffer( b )
    1347 YY_BUFFER_STATE b;
    1348 #endif
    1349         {
     1397}
     1398
     1399/** Destroy the buffer.
     1400 * @param b a buffer created with yy_create_buffer()
     1401 *
     1402 */
     1403    void yy_delete_buffer (YY_BUFFER_STATE  b )
     1404{
     1405   
    13501406        if ( ! b )
    13511407                return;
    13521408
    1353         if ( b == yy_current_buffer )
    1354                 yy_current_buffer = (YY_BUFFER_STATE) 0;
     1409        if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
     1410                YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
    13551411
    13561412        if ( b->yy_is_our_buffer )
    1357                 yy_flex_free( (void *) b->yy_ch_buf );
    1358 
    1359         yy_flex_free( (void *) b );
    1360         }
    1361 
    1362 
    1363 #ifndef YY_ALWAYS_INTERACTIVE
    1364 #ifndef YY_NEVER_INTERACTIVE
    1365 extern int isatty YY_PROTO(( int ));
    1366 #endif
    1367 #endif
    1368 
    1369 #ifdef YY_USE_PROTOS
    1370 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
    1371 #else
    1372 void yy_init_buffer( b, file )
    1373 YY_BUFFER_STATE b;
    1374 FILE *file;
    1375 #endif
    1376 
    1377 
    1378         {
    1379         yy_flush_buffer( b );
     1413                yyfree((void *) b->yy_ch_buf  );
     1414
     1415        yyfree((void *) b  );
     1416}
     1417
     1418#ifndef __cplusplus
     1419extern int isatty (int );
     1420#endif /* __cplusplus */
     1421   
     1422/* Initializes or reinitializes a buffer.
     1423 * This function is sometimes called more than once on the same buffer,
     1424 * such as during a yyrestart() or at EOF.
     1425 */
     1426    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
     1427
     1428{
     1429        int oerrno = errno;
     1430   
     1431        yy_flush_buffer(b );
    13801432
    13811433        b->yy_input_file = file;
    13821434        b->yy_fill_buffer = 1;
    13831435
    1384 #if YY_ALWAYS_INTERACTIVE
    1385         b->yy_is_interactive = 1;
    1386 #else
    1387 #if YY_NEVER_INTERACTIVE
    1388         b->yy_is_interactive = 0;
    1389 #else
    1390         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
    1391 #endif
    1392 #endif
    1393         }
    1394 
    1395 
    1396 #ifdef YY_USE_PROTOS
    1397 void yy_flush_buffer( YY_BUFFER_STATE b )
    1398 #else
    1399 void yy_flush_buffer( b )
    1400 YY_BUFFER_STATE b;
    1401 #endif
    1402 
    1403         {
    1404         if ( ! b )
     1436    /* If b is the current buffer, then yy_init_buffer was _probably_
     1437     * called from yyrestart() or through yy_get_next_buffer.
     1438     * In that case, we don't want to reset the lineno or column.
     1439     */
     1440    if (b != YY_CURRENT_BUFFER){
     1441        b->yy_bs_lineno = 1;
     1442        b->yy_bs_column = 0;
     1443    }
     1444
     1445        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
     1446   
     1447        errno = oerrno;
     1448}
     1449
     1450/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
     1451 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
     1452 *
     1453 */
     1454    void yy_flush_buffer (YY_BUFFER_STATE  b )
     1455{
     1456        if ( ! b )
    14051457                return;
    14061458
    … …  
    14191471        b->yy_buffer_status = YY_BUFFER_NEW;
    14201472
    1421         if ( b == yy_current_buffer )
    1422                 yy_load_buffer_state();
     1473        if ( b == YY_CURRENT_BUFFER )
     1474                yy_load_buffer_state( );
     1475}
     1476
     1477/** Pushes the new state onto the stack. The new state becomes
     1478 *  the current state. This function will allocate the stack
     1479 *  if necessary.
     1480 *  @param new_buffer The new state.
     1481 * 
     1482 */
     1483void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
     1484{
     1485        if (new_buffer == NULL)
     1486                return;
     1487
     1488        yyensure_buffer_stack();
     1489
     1490        /* This block is copied from yy_switch_to_buffer. */
     1491        if ( YY_CURRENT_BUFFER )
     1492                {
     1493                /* Flush out information for old buffer. */
     1494                *(yy_c_buf_p) = (yy_hold_char);
     1495                YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
     1496                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
     1497                }
     1498
     1499        /* Only push if top exists. Otherwise, replace top. */
     1500        if (YY_CURRENT_BUFFER)
     1501                (yy_buffer_stack_top)++;
     1502        YY_CURRENT_BUFFER_LVALUE = new_buffer;
     1503
     1504        /* copied from yy_switch_to_buffer. */
     1505        yy_load_buffer_state( );
     1506        (yy_did_buffer_switch_on_eof) = 1;
     1507}
     1508
     1509/** Removes and deletes the top of the stack, if present.
     1510 *  The next element becomes the new top.
     1511 * 
     1512 */
     1513void yypop_buffer_state (void)
     1514{
     1515        if (!YY_CURRENT_BUFFER)
     1516                return;
     1517
     1518        yy_delete_buffer(YY_CURRENT_BUFFER );
     1519        YY_CURRENT_BUFFER_LVALUE = NULL;
     1520        if ((yy_buffer_stack_top) > 0)
     1521                --(yy_buffer_stack_top);
     1522
     1523        if (YY_CURRENT_BUFFER) {
     1524                yy_load_buffer_state( );
     1525                (yy_did_buffer_switch_on_eof) = 1;
    14231526        }
    1424 
    1425 
    1426 #ifndef YY_NO_SCAN_BUFFER
    1427 #ifdef YY_USE_PROTOS
    1428 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
    1429 #else
    1430 YY_BUFFER_STATE yy_scan_buffer( base, size )
    1431 char *base;
    1432 yy_size_t size;
    1433 #endif
    1434         {
     1527}
     1528
     1529/* Allocates the stack if it does not exist.
     1530 *  Guarantees space for at least one push.
     1531 */
     1532static void yyensure_buffer_stack (void)
     1533{
     1534        int num_to_alloc;
     1535   
     1536        if (!(yy_buffer_stack)) {
     1537
     1538                /* First allocation is just for 2 elements, since we don't know if this
     1539                 * scanner will even need a stack. We use 2 instead of 1 to avoid an
     1540                 * immediate realloc on the next call.
     1541         */
     1542                num_to_alloc = 1;
     1543                (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
     1544                                                                (num_to_alloc * sizeof(struct yy_buffer_state*)
     1545                                                                );
     1546               
     1547                memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
     1548                               
     1549                (yy_buffer_stack_max) = num_to_alloc;
     1550                (yy_buffer_stack_top) = 0;
     1551                return;
     1552        }
     1553
     1554        if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
     1555
     1556                /* Increase the buffer to prepare for a possible push. */
     1557                int grow_size = 8 /* arbitrary grow size */;
     1558
     1559                num_to_alloc = (yy_buffer_stack_max) + grow_size;
     1560                (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
     1561                                                                ((yy_buffer_stack),
     1562                                                                num_to_alloc * sizeof(struct yy_buffer_state*)
     1563                                                                );
     1564
     1565                /* zero only the new slots.*/
     1566                memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
     1567                (yy_buffer_stack_max) = num_to_alloc;
     1568        }
     1569}
     1570
     1571/** Setup the input buffer state to scan directly from a user-specified character buffer.
     1572 * @param base the character buffer
     1573 * @param size the size in bytes of the character buffer
     1574 *
     1575 * @return the newly allocated buffer state object.
     1576 */
     1577YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
     1578{
    14351579        YY_BUFFER_STATE b;
    1436 
     1580   
    14371581        if ( size < 2 ||
    14381582             base[size-2] != YY_END_OF_BUFFER_CHAR ||
    … …  
    14411585                return 0;
    14421586
    1443         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
     1587        b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
    14441588        if ( ! b )
    14451589                YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
    … …  
    14551599        b->yy_buffer_status = YY_BUFFER_NEW;
    14561600
    1457         yy_switch_to_buffer( b );
     1601        yy_switch_to_buffer(b );
    14581602
    14591603        return b;
    1460         }
    1461 #endif
    1462 
    1463 
    1464 #ifndef YY_NO_SCAN_STRING
    1465 #ifdef YY_USE_PROTOS
    1466 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
    1467 #else
    1468 YY_BUFFER_STATE yy_scan_string( yy_str )
    1469 yyconst char *yy_str;
    1470 #endif
    1471         {
    1472         int len;
    1473         for ( len = 0; yy_str[len]; ++len )
    1474                 ;
    1475 
    1476         return yy_scan_bytes( yy_str, len );
    1477         }
    1478 #endif
    1479 
    1480 
    1481 #ifndef YY_NO_SCAN_BYTES
    1482 #ifdef YY_USE_PROTOS
    1483 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
    1484 #else
    1485 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
    1486 yyconst char *bytes;
    1487 int len;
    1488 #endif
    1489         {
     1604}
     1605
     1606/** Setup the input buffer state to scan a string. The next call to yylex() will
     1607 * scan from a @e copy of @a str.
     1608 * @param str a NUL-terminated string to scan
     1609 *
     1610 * @return the newly allocated buffer state object.
     1611 * @note If you want to scan bytes that may contain NUL values, then use
     1612 *       yy_scan_bytes() instead.
     1613 */
     1614YY_BUFFER_STATE yy_scan_string (yyconst char * str )
     1615{
     1616   
     1617        return yy_scan_bytes(str,strlen(str) );
     1618}
     1619
     1620/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
     1621 * scan from a @e copy of @a bytes.
     1622 * @param bytes the byte buffer to scan
     1623 * @param len the number of bytes in the buffer pointed to by @a bytes.
     1624 *
     1625 * @return the newly allocated buffer state object.
     1626 */
     1627YY_BUFFER_STATE yy_scan_bytes  (yyconst char * bytes, int  len )
     1628{
    14901629        YY_BUFFER_STATE b;
    14911630        char *buf;
    14921631        yy_size_t n;
    14931632        int i;
    1494 
     1633   
    14951634        /* Get memory for full buffer, including space for trailing EOB's. */
    14961635        n = len + 2;
    1497         buf = (char *) yy_flex_alloc( n );
     1636        buf = (char *) yyalloc(n );
    14981637        if ( ! buf )
    14991638                YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
    … …  
    15041643        buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
    15051644
    1506         b = yy_scan_buffer( buf, n );
     1645        b = yy_scan_buffer(buf,n );
    15071646        if ( ! b )
    15081647                YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
    … …  
    15141653
    15151654        return b;
    1516         }
    1517 #endif
    1518 
    1519 
    1520 #ifndef YY_NO_PUSH_STATE
    1521 #ifdef YY_USE_PROTOS
    1522 static void yy_push_state( int new_state )
    1523 #else
    1524 static void yy_push_state( new_state )
    1525 int new_state;
    1526 #endif
    1527         {
    1528         if ( yy_start_stack_ptr >= yy_start_stack_depth )
    1529                 {
    1530                 yy_size_t new_size;
    1531 
    1532                 yy_start_stack_depth += YY_START_STACK_INCR;
    1533                 new_size = yy_start_stack_depth * sizeof( int );
    1534 
    1535                 if ( ! yy_start_stack )
    1536                         yy_start_stack = (int *) yy_flex_alloc( new_size );
    1537 
    1538                 else
    1539                         yy_start_stack = (int *) yy_flex_realloc(
    1540                                         (void *) yy_start_stack, new_size );
    1541 
    1542                 if ( ! yy_start_stack )
    1543                         YY_FATAL_ERROR(
    1544                         "out of memory expanding start-condition stack" );
    1545                 }
    1546 
    1547         yy_start_stack[yy_start_stack_ptr++] = YY_START;
    1548 
    1549         BEGIN(new_state);
    1550         }
    1551 #endif
    1552 
    1553 
    1554 #ifndef YY_NO_POP_STATE
    1555 static void yy_pop_state()
    1556         {
    1557         if ( --yy_start_stack_ptr < 0 )
    1558                 YY_FATAL_ERROR( "start-condition stack underflow" );
    1559 
    1560         BEGIN(yy_start_stack[yy_start_stack_ptr]);
    1561         }
    1562 #endif
    1563 
    1564 
    1565 #ifndef YY_NO_TOP_STATE
    1566 static int yy_top_state()
    1567         {
    1568         return yy_start_stack[yy_start_stack_ptr - 1];
    1569         }
    1570 #endif
     1655}
    15711656
    15721657#ifndef YY_EXIT_FAILURE
    … …  
    15741659#endif
    15751660
    1576 #ifdef YY_USE_PROTOS
    1577 static void yy_fatal_error( yyconst char msg[] )
    1578 #else
    1579 static void yy_fatal_error( msg )
    1580 char msg[];
    1581 #endif
    1582         {
    1583         (void) fprintf( stderr, "%s\n", msg );
     1661static void yy_fatal_error (yyconst char* msg )
     1662{
     1663        (void) fprintf( stderr, "%s\n", msg );
    15841664        exit( YY_EXIT_FAILURE );
    1585         }
    1586 
    1587 
     1665}
    15881666
    15891667/* Redefine yyless() so it works in section 3 code. */
    … …  
    15941672                { \
    15951673                /* Undo effects of setting up yytext. */ \
    1596                 yytext[yyleng] = yy_hold_char; \
    1597                 yy_c_buf_p = yytext + n; \
    1598                 yy_hold_char = *yy_c_buf_p; \
    1599                 *yy_c_buf_p = '\0'; \
    1600                 yyleng = n; \
     1674        int yyless_macro_arg = (n); \
     1675        YY_LESS_LINENO(yyless_macro_arg);\
     1676                yytext[yyleng] = (yy_hold_char); \
     1677                (yy_c_buf_p) = yytext + yyless_macro_arg; \
     1678                (yy_hold_char) = *(yy_c_buf_p); \
     1679                *(yy_c_buf_p) = '\0'; \
     1680                yyleng = yyless_macro_arg; \
    16011681                } \
    16021682        while ( 0 )
    16031683
    1604 
    1605 /* Internal utility routines. */
     1684/* Accessor  methods (get/set functions) to struct members. */
     1685
     1686/** Get the current line number.
     1687 *
     1688 */
     1689int yyget_lineno  (void)
     1690{
     1691       
     1692    return yylineno;
     1693}
     1694
     1695/** Get the input stream.
     1696 *
     1697 */
     1698FILE *yyget_in  (void)
     1699{
     1700        return yyin;
     1701}
     1702
     1703/** Get the output stream.
     1704 *
     1705 */
     1706FILE *yyget_out  (void)
     1707{
     1708        return yyout;
     1709}
     1710
     1711/** Get the length of the current token.
     1712 *
     1713 */
     1714int yyget_leng  (void)
     1715{
     1716        return yyleng;
     1717}
     1718
     1719/** Get the current token.
     1720 *
     1721 */
     1722
     1723char *yyget_text  (void)
     1724{
     1725        return yytext;
     1726}
     1727
     1728/** Set the current line number.
     1729 * @param line_number
     1730 *
     1731 */
     1732void yyset_lineno (int  line_number )
     1733{
     1734   
     1735    yylineno = line_number;
     1736}
     1737
     1738/** Set the input stream. This does not discard the current
     1739 * input buffer.
     1740 * @param in_str A readable stream.
     1741 *
     1742 * @see yy_switch_to_buffer
     1743 */
     1744void yyset_in (FILE *  in_str )
     1745{
     1746        yyin = in_str ;
     1747}
     1748
     1749void yyset_out (FILE *  out_str )
     1750{
     1751        yyout = out_str ;
     1752}
     1753
     1754int yyget_debug  (void)
     1755{
     1756        return yy_flex_debug;
     1757}
     1758
     1759void yyset_debug (int  bdebug )
     1760{
     1761        yy_flex_debug = bdebug ;
     1762}
     1763
     1764/* yylex_destroy is for both reentrant and non-reentrant scanners. */
     1765int yylex_destroy  (void)
     1766{
     1767   
     1768    /* Pop the buffer stack, destroying each element. */
     1769        while(YY_CURRENT_BUFFER){
     1770                yy_delete_buffer(YY_CURRENT_BUFFER  );
     1771                YY_CURRENT_BUFFER_LVALUE = NULL;
     1772                yypop_buffer_state();
     1773        }
     1774
     1775        /* Destroy the stack itself. */
     1776        yyfree((yy_buffer_stack) );
     1777        (yy_buffer_stack) = NULL;
     1778
     1779    return 0;
     1780}
     1781
     1782/*
     1783 * Internal utility routines.
     1784 */
    16061785
    16071786#ifndef yytext_ptr
    1608 #ifdef YY_USE_PROTOS
    1609 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
    1610 #else
    1611 static void yy_flex_strncpy( s1, s2, n )
    1612 char *s1;
    1613 yyconst char *s2;
    1614 int n;
    1615 #endif
    1616         {
     1787static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
     1788{
    16171789        register int i;
    1618         for ( i = 0; i < n; ++i )
     1790        for ( i = 0; i < n; ++i )
    16191791                s1[i] = s2[i];
    1620         }
     1792}
    16211793#endif
    16221794
    16231795#ifdef YY_NEED_STRLEN
    1624 #ifdef YY_USE_PROTOS
    1625 static int yy_flex_strlen( yyconst char *s )
    1626 #else
    1627 static int yy_flex_strlen( s )
    1628 yyconst char *s;
    1629 #endif
    1630         {
     1796static int yy_flex_strlen (yyconst char * s )
     1797{
    16311798        register int n;
    1632         for ( n = 0; s[n]; ++n )
     1799        for ( n = 0; s[n]; ++n )
    16331800                ;
    16341801
    16351802        return n;
    1636         }
    1637 #endif
    1638 
    1639 
    1640 #ifdef YY_USE_PROTOS
    1641 static void *yy_flex_alloc( yy_size_t size )
    1642 #else
    1643 static void *yy_flex_alloc( size )
    1644 yy_size_t size;
    1645 #endif
    1646         {
     1803}
     1804#endif
     1805
     1806void *yyalloc (yy_size_t  size )
     1807{
    16471808        return (void *) malloc( size );
    1648         }
    1649 
    1650 #ifdef YY_USE_PROTOS
    1651 static void *yy_flex_realloc( void *ptr, yy_size_t size )
    1652 #else
    1653 static void *yy_flex_realloc( ptr, size )
    1654 void *ptr;
    1655 yy_size_t size;
    1656 #endif
    1657         {
     1809}
     1810
     1811void *yyrealloc  (void * ptr, yy_size_t  size )
     1812{
    16581813        /* The cast to (char *) in the following accommodates both
    16591814         * implementations that use char* generic pointers, and those
    … …  
    16641819         */
    16651820        return (void *) realloc( (char *) ptr, size );
    1666         }
    1667 
    1668 #ifdef YY_USE_PROTOS
    1669 static void yy_flex_free( void *ptr )
    1670 #else
    1671 static void yy_flex_free( ptr )
    1672 void *ptr;
    1673 #endif
    1674         {
    1675         free( ptr );
    1676         }
    1677 
    1678 #if YY_MAIN
    1679 int main()
    1680         {
    1681         yylex();
    1682         return 0;
    1683         }
     1821}
     1822
     1823void yyfree (void * ptr )
     1824{
     1825        free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
     1826}
     1827
     1828#define YYTABLES_NAME "yytables"
     1829
     1830#undef YY_NEW_FILE
     1831#undef YY_FLUSH_BUFFER
     1832#undef yy_set_bol
     1833#undef yy_new_buffer
     1834#undef yy_set_interactive
     1835#undef yytext_ptr
     1836#undef YY_DO_BEFORE_ACTION
     1837
     1838#ifdef YY_DECL_IS_OURS
     1839#undef YY_DECL_IS_OURS
     1840#undef YY_DECL
    16841841#endif
    16851842#line 106 "itbl-lex.l"
     1843
    16861844
    16871845
    … …  
    16931851  }
    16941852#endif
     1853
Note: See TracChangeset for help on using the changeset viewer.