Ignore:
Timestamp:
Oct 8, 2007, 2:24:31 AM (18 years ago)
Author:
bird
Message:

more fixes - it all compiles now (linking fails of course).

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kash/generated/arith_lex.c

    r631 r1222  
    1 #line 2 "/home/bird/Coding/kBuild/svn/trunk/out/linux.x86/debug/obj/src/ash/arith_lex.c"
     1#line 2 "/home/bird/vax/gdrive/coding/kbuild/svn/trunk/out/linux.x86/release/obj/src/kash/arith_lex.c"
     2
     3#line 4 "/home/bird/vax/gdrive/coding/kbuild/svn/trunk/out/linux.x86/release/obj/src/kash/arith_lex.c"
     4
     5#define  YY_INT_ALIGNED short int
     6
    27/* A lexical scanner generated by flex */
    3 
    4 /* Scanner skeleton version:
    5  * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $
    6  */
    78
    89#define FLEX_SCANNER
    910#define YY_FLEX_MAJOR_VERSION 2
    1011#define YY_FLEX_MINOR_VERSION 5
    11 
     12#define YY_FLEX_SUBMINOR_VERSION 33
     13#if YY_FLEX_SUBMINOR_VERSION > 0
     14#define FLEX_BETA
     15#endif
     16
     17/* First, we deal with  platform-specific or compiler-specific issues. */
     18
     19/* begin standard C headers. */
    1220#include <stdio.h>
    13 #include <unistd.h>
    14 
    15 
    16 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
    17 #ifdef c_plusplus
    18 #ifndef __cplusplus
    19 #define __cplusplus
    20 #endif
    21 #endif
    22 
     21#include <string.h>
     22#include <errno.h>
     23#include <stdlib.h>
     24
     25/* end standard C headers. */
     26
     27/* flex integer type definitions */
     28
     29#ifndef FLEXINT_H
     30#define FLEXINT_H
     31
     32/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
     33
     34#if __STDC_VERSION__ >= 199901L
     35
     36/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
     37 * if you want the limit (max/min) macros for int types.
     38 */
     39#ifndef __STDC_LIMIT_MACROS
     40#define __STDC_LIMIT_MACROS 1
     41#endif
     42
     43#include <inttypes.h>
     44typedef int8_t flex_int8_t;
     45typedef uint8_t flex_uint8_t;
     46typedef int16_t flex_int16_t;
     47typedef uint16_t flex_uint16_t;
     48typedef int32_t flex_int32_t;
     49typedef uint32_t flex_uint32_t;
     50#else
     51typedef signed char flex_int8_t;
     52typedef short int flex_int16_t;
     53typedef int flex_int32_t;
     54typedef unsigned char flex_uint8_t;
     55typedef unsigned short int flex_uint16_t;
     56typedef unsigned int flex_uint32_t;
     57#endif /* ! C99 */
     58
     59/* Limits of integral types. */
     60#ifndef INT8_MIN
     61#define INT8_MIN               (-128)
     62#endif
     63#ifndef INT16_MIN
     64#define INT16_MIN              (-32767-1)
     65#endif
     66#ifndef INT32_MIN
     67#define INT32_MIN              (-2147483647-1)
     68#endif
     69#ifndef INT8_MAX
     70#define INT8_MAX               (127)
     71#endif
     72#ifndef INT16_MAX
     73#define INT16_MAX              (32767)
     74#endif
     75#ifndef INT32_MAX
     76#define INT32_MAX              (2147483647)
     77#endif
     78#ifndef UINT8_MAX
     79#define UINT8_MAX              (255U)
     80#endif
     81#ifndef UINT16_MAX
     82#define UINT16_MAX             (65535U)
     83#endif
     84#ifndef UINT32_MAX
     85#define UINT32_MAX             (4294967295U)
     86#endif
     87
     88#endif /* ! FLEXINT_H */
    2389
    2490#ifdef __cplusplus
    25 
    26 #include <stdlib.h>
    27 
    28 /* Use prototypes in function declarations. */
    29 #define YY_USE_PROTOS
    3091
    3192/* The "const" storage-class-modifier is valid. */
    … …  
    3697#if __STDC__
    3798
    38 #define YY_USE_PROTOS
    3999#define YY_USE_CONST
    40100
    41101#endif  /* __STDC__ */
    42102#endif  /* ! __cplusplus */
    43 
    44 #ifdef __TURBOC__
    45  #pragma warn -rch
    46  #pragma warn -use
    47 #include <io.h>
    48 #include <stdlib.h>
    49 #define YY_USE_CONST
    50 #define YY_USE_PROTOS
    51 #endif
    52103
    53104#ifdef YY_USE_CONST
    … …  
    57108#endif
    58109
    59 
    60 #ifdef YY_USE_PROTOS
    61 #define YY_PROTO(proto) proto
    62 #else
    63 #define YY_PROTO(proto) ()
    64 #endif
    65 
    66110/* Returned upon end-of-file. */
    67111#define YY_NULL 0
    … …  
    78122 * definition of BEGIN.
    79123 */
    80 #define BEGIN yy_start = 1 + 2 *
     124#define BEGIN (yy_start) = 1 + 2 *
    81125
    82126/* Translate the current start state into a value that can be later handed
    … …  
    84128 * compatibility.
    85129 */
    86 #define YY_START ((yy_start - 1) / 2)
     130#define YY_START (((yy_start) - 1) / 2)
    87131#define YYSTATE YY_START
    88132
    … …  
    91135
    92136/* Special action meaning "start processing a new file". */
    93 #define YY_NEW_FILE yyrestart( yyin )
     137#define YY_NEW_FILE yyrestart(yyin )
    94138
    95139#define YY_END_OF_BUFFER_CHAR 0
    96140
    97141/* Size of default input buffer. */
     142#ifndef YY_BUF_SIZE
    98143#define YY_BUF_SIZE 16384
    99 
     144#endif
     145
     146/* The state buf must be large enough to hold one state per character in the main buffer.
     147 */
     148#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
     149
     150#ifndef YY_TYPEDEF_YY_BUFFER_STATE
     151#define YY_TYPEDEF_YY_BUFFER_STATE
    100152typedef struct yy_buffer_state *YY_BUFFER_STATE;
     153#endif
    101154
    102155extern int yyleng;
     156
    103157extern FILE *yyin, *yyout;
    104158
    … …  
    107161#define EOB_ACT_LAST_MATCH 2
    108162
    109 /* The funky do-while in the following #define is used to turn the definition
    110  * int a single C statement (which needs a semi-colon terminator).  This
    111  * avoids problems with code like:
    112  *
    113  *      if ( condition_holds )
    114  *              yyless( 5 );
    115  *      else
    116  *              do_something_else();
    117  *
    118  * Prior to using the do-while the compiler would get upset at the
    119  * "else" because it interpreted the "if" statement as being all
    120  * done when it reached the ';' after the yyless() call.
    121  */
    122 
    123 /* Return all but the first 'n' matched characters back to the input stream. */
    124 
     163    #define YY_LESS_LINENO(n)
     164   
     165/* Return all but the first "n" matched characters back to the input stream. */
    125166#define yyless(n) \
    126167        do \
    127168                { \
    128169                /* Undo effects of setting up yytext. */ \
    129                 *yy_cp = yy_hold_char; \
     170        int yyless_macro_arg = (n); \
     171        YY_LESS_LINENO(yyless_macro_arg);\
     172                *yy_cp = (yy_hold_char); \
    130173                YY_RESTORE_YY_MORE_OFFSET \
    131                 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
     174                (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
    132175                YY_DO_BEFORE_ACTION; /* set up yytext again */ \
    133176                } \
    134177        while ( 0 )
    135178
    136 #define unput(c) yyunput( c, yytext_ptr )
     179#define unput(c) yyunput( c, (yytext_ptr) )
    137180
    138181/* The following is because we cannot portably get our hands on size_t
    … …  
    140183 * flex-generated scanners to compile on their own).
    141184 */
     185
     186#ifndef YY_TYPEDEF_YY_SIZE_T
     187#define YY_TYPEDEF_YY_SIZE_T
    142188typedef unsigned int yy_size_t;
    143 
    144 
     189#endif
     190
     191#ifndef YY_STRUCT_YY_BUFFER_STATE
     192#define YY_STRUCT_YY_BUFFER_STATE
    145193struct yy_buffer_state
    146194        {
    … …  
    179227        int yy_at_bol;
    180228
     229    int yy_bs_lineno; /**< The line count. */
     230    int yy_bs_column; /**< The column count. */
     231   
    181232        /* Whether to try to fill the input buffer when we reach the
    182233         * end of it.
    … …  
    185236
    186237        int yy_buffer_status;
     238
    187239#define YY_BUFFER_NEW 0
    188240#define YY_BUFFER_NORMAL 1
    … …  
    198250         */
    199251#define YY_BUFFER_EOF_PENDING 2
     252
    200253        };
    201 
    202 static YY_BUFFER_STATE yy_current_buffer = 0;
     254#endif /* !YY_STRUCT_YY_BUFFER_STATE */
     255
     256/* Stack of input buffers. */
     257static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
     258static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
     259static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
    203260
    204261/* We provide macros for accessing buffer states in case in the
    205262 * future we want to put the buffer states in a more general
    206263 * "scanner state".
    207  */
    208 #define YY_CURRENT_BUFFER yy_current_buffer
    209 
     264 *
     265 * Returns the top of the stack, or NULL.
     266 */
     267#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
     268                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
     269                          : NULL)
     270
     271/* Same as previous macro, but useful when we know that the buffer stack is not
     272 * NULL or when we need an lvalue. For internal use only.
     273 */
     274#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
    210275
    211276/* yy_hold_char holds the character lost when yytext is formed. */
    212277static char yy_hold_char;
    213 
    214278static int yy_n_chars;          /* number of characters read into yy_ch_buf */
    215 
    216 
    217279int yyleng;
    218280
    219281/* Points to current character in buffer. */
    220282static char *yy_c_buf_p = (char *) 0;
    221 static int yy_init = 1;         /* whether we need to initialize */
     283static int yy_init = 0;         /* whether we need to initialize */
    222284static int yy_start = 0;        /* start state number */
    223285
    … …  
    227289static int yy_did_buffer_switch_on_eof;
    228290
    229 void yyrestart YY_PROTO(( FILE *input_file ));
    230 
    231 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
    232 void yy_load_buffer_state YY_PROTO(( void ));
    233 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
    234 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
    235 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
    236 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
    237 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
    238 
    239 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
    240 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
    241 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
    242 
    243 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
    244 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
    245 static void yy_flex_free YY_PROTO(( void * ));
     291void yyrestart (FILE *input_file  );
     292void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
     293YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
     294void yy_delete_buffer (YY_BUFFER_STATE b  );
     295void yy_flush_buffer (YY_BUFFER_STATE b  );
     296void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
     297void yypop_buffer_state (void );
     298
     299static void yyensure_buffer_stack (void );
     300static void yy_load_buffer_state (void );
     301static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
     302
     303#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
     304
     305YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
     306YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
     307YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );
     308
     309void *yyalloc (yy_size_t  );
     310void *yyrealloc (void *,yy_size_t  );
     311void yyfree (void *  );
    246312
    247313#define yy_new_buffer yy_create_buffer
    … …  
    249315#define yy_set_interactive(is_interactive) \
    250316        { \
    251         if ( ! yy_current_buffer ) \
    252                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
    253         yy_current_buffer->yy_is_interactive = is_interactive; \
     317        if ( ! YY_CURRENT_BUFFER ){ \
     318        yyensure_buffer_stack (); \
     319                YY_CURRENT_BUFFER_LVALUE =    \
     320            yy_create_buffer(yyin,YY_BUF_SIZE ); \
     321        } \
     322        YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
    254323        }
    255324
    256325#define yy_set_bol(at_bol) \
    257326        { \
    258         if ( ! yy_current_buffer ) \
    259                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
    260         yy_current_buffer->yy_at_bol = at_bol; \
     327        if ( ! YY_CURRENT_BUFFER ){\
     328        yyensure_buffer_stack (); \
     329                YY_CURRENT_BUFFER_LVALUE =    \
     330            yy_create_buffer(yyin,YY_BUF_SIZE ); \
     331        } \
     332        YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
    261333        }
    262334
    263 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
    264 
    265 
    266 #define yywrap() 1
     335#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
     336
     337/* Begin user sect3 */
     338
     339#define yywrap(n) 1
    267340#define YY_SKIP_YYWRAP
     341
    268342typedef unsigned char YY_CHAR;
     343
    269344FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
     345
    270346typedef int yy_state_type;
     347
     348extern int yylineno;
     349
     350int yylineno = 1;
     351
    271352extern char *yytext;
    272353#define yytext_ptr yytext
    273354
    274 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
    275 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
    276 static int yy_get_next_buffer YY_PROTO(( void ));
    277 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
     355static yy_state_type yy_get_previous_state (void );
     356static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
     357static int yy_get_next_buffer (void );
     358static void yy_fatal_error (yyconst char msg[]  );
    278359
    279360/* Done after the current pattern has been matched and before the
    … …  
    281362 */
    282363#define YY_DO_BEFORE_ACTION \
    283         yytext_ptr = yy_bp; \
    284         yyleng = (int) (yy_cp - yy_bp); \
    285         yy_hold_char = *yy_cp; \
     364        (yytext_ptr) = yy_bp; \
     365        yyleng = (size_t) (yy_cp - yy_bp); \
     366        (yy_hold_char) = *yy_cp; \
    286367        *yy_cp = '\0'; \
    287         yy_c_buf_p = yy_cp;
     368        (yy_c_buf_p) = yy_cp;
    288369
    289370#define YY_NUM_RULES 29
    290371#define YY_END_OF_BUFFER 30
    291 static yyconst short int yy_accept[39] =
     372/* This struct is not used in this scanner,
     373   but its presence is necessary. */
     374struct yy_trans_info
     375        {
     376        flex_int32_t yy_verify;
     377        flex_int32_t yy_nxt;
     378        };
     379static yyconst flex_int16_t yy_accept[39] =
    292380    {   0,
    293381        0,    0,   30,   28,    1,    1,   27,   23,   12,    6,
    … …  
    297385    } ;
    298386
    299 static yyconst int yy_ec[256] =
     387static yyconst flex_int32_t yy_ec[256] =
    300388    {   0,
    301389        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
    … …  
    329417    } ;
    330418
    331 static yyconst int yy_meta[25] =
     419static yyconst flex_int32_t yy_meta[25] =
    332420    {   0,
    333421        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    … …  
    336424    } ;
    337425
    338 static yyconst short int yy_base[41] =
     426static yyconst flex_int16_t yy_base[41] =
    339427    {   0,
    340428        0,    0,   47,   48,   48,   48,   29,   48,   39,   48,
    … …  
    344432    } ;
    345433
    346 static yyconst short int yy_def[41] =
     434static yyconst flex_int16_t yy_def[41] =
    347435    {   0,
    348436       38,    1,   38,   38,   38,   38,   38,   38,   38,   38,
    … …  
    352440    } ;
    353441
    354 static yyconst short int yy_nxt[73] =
     442static yyconst flex_int16_t yy_nxt[73] =
    355443    {   0,
    356444        4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
    … …  
    364452    } ;
    365453
    366 static yyconst short int yy_chk[73] =
     454static yyconst flex_int16_t yy_chk[73] =
    367455    {   0,
    368456        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    … …  
    379467static char *yy_last_accepting_cpos;
    380468
     469extern int yy_flex_debug;
     470int yy_flex_debug = 0;
     471
    381472/* The intent behind this definition is that it'll catch
    382473 * any uses of REJECT which flex missed.
    … …  
    388479char *yytext;
    389480#line 1 "arith_lex.l"
    390 #define INITIAL 0
    391481#line 3 "arith_lex.l"
    392482/*      $NetBSD: arith_lex.l,v 1.13 2005/03/21 22:37:09 dsl Exp $       */
    … …  
    424514 */
    425515
    426 #include <sys/cdefs.h>
     516#if 0
    427517#ifndef lint
    428 #if 0
    429518static char sccsid[] = "@(#)arith_lex.l 8.3 (Berkeley) 5/4/95";
    430519#else
    431520__RCSID("$NetBSD: arith_lex.l,v 1.13 2005/03/21 22:37:09 dsl Exp $");
    432 #endif
    433521#endif /* not lint */
    434 
    435 #include <unistd.h>
     522#endif
     523
    436524#include "arith.h"
    437525#include "error.h"
    438526#include "expand.h"
    439527#include "var.h"
     528#include "shinstance.h"
    440529
    441530extern int yylval;
     531extern shinstance *arith_psh;
    442532extern char *arith_buf, *arith_startbuf;
    443533#undef YY_INPUT
    … …  
    445535        result = (*buf = *arith_buf++) ? 1 : YY_NULL;
    446536#define YY_NO_UNPUT
    447 #line 448 "/home/bird/Coding/kBuild/svn/trunk/out/linux.x86/debug/obj/src/ash/arith_lex.c"
     537#line 538 "/home/bird/vax/gdrive/coding/kbuild/svn/trunk/out/linux.x86/release/obj/src/kash/arith_lex.c"
     538
     539#define INITIAL 0
     540
     541#ifndef YY_NO_UNISTD_H
     542/* Special case for "unistd.h", since it is non-ANSI. We include it way
     543 * down here because we want the user's section 1 to have been scanned first.
     544 * The user has a chance to override it with an option.
     545 */
     546#include <unistd.h>
     547#endif
     548
     549#ifndef YY_EXTRA_TYPE
     550#define YY_EXTRA_TYPE void *
     551#endif
     552
     553static int yy_init_globals (void );
    448554
    449555/* Macros after this point can all be overridden by user definitions in
    … …  
    453559#ifndef YY_SKIP_YYWRAP
    454560#ifdef __cplusplus
    455 extern "C" int yywrap YY_PROTO(( void ));
     561extern "C" int yywrap (void );
    456562#else
    457 extern int yywrap YY_PROTO(( void ));
    458 #endif
    459 #endif
    460 
    461 #ifndef YY_NO_UNPUT
    462 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
    463 #endif
    464 
     563extern int yywrap (void );
     564#endif
     565#endif
     566
     567    static void yyunput (int c,char *buf_ptr  );
     568   
    465569#ifndef yytext_ptr
    466 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
     570static void yy_flex_strncpy (char *,yyconst char *,int );
    467571#endif
    468572
    469573#ifdef YY_NEED_STRLEN
    470 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
     574static int yy_flex_strlen (yyconst char * );
    471575#endif
    472576
    473577#ifndef YY_NO_INPUT
     578
    474579#ifdef __cplusplus
    475 static int yyinput YY_PROTO(( void ));
     580static int yyinput (void );
    476581#else
    477 static int input YY_PROTO(( void ));
    478 #endif
    479 #endif
    480 
    481 #if YY_STACK_USED
    482 static int yy_start_stack_ptr = 0;
    483 static int yy_start_stack_depth = 0;
    484 static int *yy_start_stack = 0;
    485 #ifndef YY_NO_PUSH_STATE
    486 static void yy_push_state YY_PROTO(( int new_state ));
    487 #endif
    488 #ifndef YY_NO_POP_STATE
    489 static void yy_pop_state YY_PROTO(( void ));
    490 #endif
    491 #ifndef YY_NO_TOP_STATE
    492 static int yy_top_state YY_PROTO(( void ));
    493 #endif
    494 
    495 #else
    496 #define YY_NO_PUSH_STATE 1
    497 #define YY_NO_POP_STATE 1
    498 #define YY_NO_TOP_STATE 1
    499 #endif
    500 
    501 #ifdef YY_MALLOC_DECL
    502 YY_MALLOC_DECL
    503 #else
    504 #if __STDC__
    505 #ifndef __cplusplus
    506 #include <stdlib.h>
    507 #endif
    508 #else
    509 /* Just try to get by without declaring the routines.  This will fail
    510  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
    511  * or sizeof(void*) != sizeof(int).
    512  */
    513 #endif
     582static int input (void );
     583#endif
     584
    514585#endif
    515586
    … …  
    520591
    521592/* Copy whatever the last rule matched to the standard output. */
    522 
    523593#ifndef ECHO
    524594/* This used to be an fputs(), but since the string might contain NUL's,
    … …  
    533603#ifndef YY_INPUT
    534604#define YY_INPUT(buf,result,max_size) \
    535         if ( yy_current_buffer->yy_is_interactive ) \
     605        if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
    536606                { \
    537                 int c = '*', n; \
     607                int c = '*'; \
     608                size_t n; \
    538609                for ( n = 0; n < max_size && \
    539610                             (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
    … …  
    545616                result = n; \
    546617                } \
    547         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
    548                   && ferror( yyin ) ) \
    549                 YY_FATAL_ERROR( "input in flex scanner failed" );
     618        else \
     619                { \
     620                errno=0; \
     621                while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
     622                        { \
     623                        if( errno != EINTR) \
     624                                { \
     625                                YY_FATAL_ERROR( "input in flex scanner failed" ); \
     626                                break; \
     627                                } \
     628                        errno=0; \
     629                        clearerr(yyin); \
     630                        } \
     631                }\
     632\
     633
    550634#endif
    551635
    … …  
    568652#endif
    569653
     654/* end tables serialization structures and prototypes */
     655
    570656/* Default declaration of generated scanner - a define so the user can
    571657 * easily add parameters.
    572658 */
    573659#ifndef YY_DECL
    574 #define YY_DECL int yylex YY_PROTO(( void ))
    575 #endif
     660#define YY_DECL_IS_OURS 1
     661
     662extern int yylex (void);
     663
     664#define YY_DECL int yylex (void)
     665#endif /* !YY_DECL */
    576666
    577667/* Code executed at the beginning of each rule, after yytext and yyleng
    … …  
    590680        YY_USER_ACTION
    591681
     682/** The main scanner function which does all the work.
     683 */
    592684YY_DECL
    593         {
     685{
    594686        register yy_state_type yy_current_state;
    595         register char *yy_cp = NULL, *yy_bp = NULL;
     687        register char *yy_cp, *yy_bp;
    596688        register int yy_act;
    597 
     689   
    598690#line 60 "arith_lex.l"
    599691
    600 #line 601 "/home/bird/Coding/kBuild/svn/trunk/out/linux.x86/debug/obj/src/ash/arith_lex.c"
    601 
    602         if ( yy_init )
     692#line 693 "/home/bird/vax/gdrive/coding/kbuild/svn/trunk/out/linux.x86/release/obj/src/kash/arith_lex.c"
     693
     694        if ( !(yy_init) )
    603695                {
    604                 yy_init = 0;
     696                (yy_init) = 1;
    605697
    606698#ifdef YY_USER_INIT
    … …  
    608700#endif
    609701
    610                 if ( ! yy_start )
    611                         yy_start = 1;   /* first start state */
     702                if ( ! (yy_start) )
     703                        (yy_start) = 1; /* first start state */
    612704
    613705                if ( ! yyin )
    … …  
    617709                        yyout = stdout;
    618710
    619                 if ( ! yy_current_buffer )
    620                         yy_current_buffer =
    621                                 yy_create_buffer( yyin, YY_BUF_SIZE );
    622 
    623                 yy_load_buffer_state();
     711                if ( ! YY_CURRENT_BUFFER ) {
     712                        yyensure_buffer_stack ();
     713                        YY_CURRENT_BUFFER_LVALUE =
     714                                yy_create_buffer(yyin,YY_BUF_SIZE );
     715                }
     716
     717                yy_load_buffer_state( );
    624718                }
    625719
    626720        while ( 1 )             /* loops until end-of-file is reached */
    627721                {
    628                 yy_cp = yy_c_buf_p;
     722                yy_cp = (yy_c_buf_p);
    629723
    630724                /* Support of yytext. */
    631                 *yy_cp = yy_hold_char;
     725                *yy_cp = (yy_hold_char);
    632726
    633727                /* yy_bp points to the position in yy_ch_buf of the start of
    … …  
    636730                yy_bp = yy_cp;
    637731
    638                 yy_current_state = yy_start;
     732                yy_current_state = (yy_start);
    639733yy_match:
    640734                do
    … …  
    643737                        if ( yy_accept[yy_current_state] )
    644738                                {
    645                                 yy_last_accepting_state = yy_current_state;
    646                                 yy_last_accepting_cpos = yy_cp;
     739                                (yy_last_accepting_state) = yy_current_state;
     740                                (yy_last_accepting_cpos) = yy_cp;
    647741                                }
    648742                        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
    … …  
    661755                if ( yy_act == 0 )
    662756                        { /* have to back up */
    663                         yy_cp = yy_last_accepting_cpos;
    664                         yy_current_state = yy_last_accepting_state;
     757                        yy_cp = (yy_last_accepting_cpos);
     758                        yy_current_state = (yy_last_accepting_state);
    665759                        yy_act = yy_accept[yy_current_state];
    666760                        }
    … …  
    668762                YY_DO_BEFORE_ACTION;
    669763
    670 
    671764do_action:      /* This label is used only to access EOF actions. */
    672 
    673765
    674766                switch ( yy_act )
    … …  
    676768                        case 0: /* must back up */
    677769                        /* undo the effects of YY_DO_BEFORE_ACTION */
    678                         *yy_cp = yy_hold_char;
    679                         yy_cp = yy_last_accepting_cpos;
    680                         yy_current_state = yy_last_accepting_state;
     770                        *yy_cp = (yy_hold_char);
     771                        yy_cp = (yy_last_accepting_cpos);
     772                        yy_current_state = (yy_last_accepting_state);
    681773                        goto yy_find_action;
    682774
    683775case 1:
     776/* rule 1 can match eol */
    684777YY_RULE_SETUP
    685778#line 61 "arith_lex.l"
    … …  
    704797YY_RULE_SETUP
    705798#line 65 "arith_lex.l"
    706 { char *v = lookupvar(yytext);
     799{ char *v = lookupvar(arith_psh, yytext);
    707800                        if (v) {
    708801                                yylval = strtol(v, &v, 0);
    … …  
    710803                                        return ARITH_NUM;
    711804                        }
    712                         error("arith: syntax error: \"%s\"", arith_startbuf);
     805                        error(arith_psh, "arith: syntax error: \"%s\"", arith_startbuf);
    713806                }
    714807        YY_BREAK
    … …  
    826919YY_RULE_SETUP
    827920#line 95 "arith_lex.l"
    828 { error("arith: syntax error: \"%s\"", arith_startbuf); }
     921{ error(arith_psh, "arith: syntax error: \"%s\"", arith_startbuf); }
    829922        YY_BREAK
    830923case 29:
    … …  
    833926ECHO;
    834927        YY_BREAK
    835 #line 836 "/home/bird/Coding/kBuild/svn/trunk/out/linux.x86/debug/obj/src/ash/arith_lex.c"
     928#line 929 "/home/bird/vax/gdrive/coding/kbuild/svn/trunk/out/linux.x86/release/obj/src/kash/arith_lex.c"
    836929case YY_STATE_EOF(INITIAL):
    837930        yyterminate();
    … …  
    840933                {
    841934                /* Amount of text matched not including the EOB char. */
    842                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
     935                int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
    843936
    844937                /* Undo the effects of YY_DO_BEFORE_ACTION. */
    845                 *yy_cp = yy_hold_char;
     938                *yy_cp = (yy_hold_char);
    846939                YY_RESTORE_YY_MORE_OFFSET
    847940
    848                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
     941                if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
    849942                        {
    850943                        /* We're scanning a new file or input source.  It's
    … …  
    852945                         * just pointed yyin at a new source and called
    853946                         * yylex().  If so, then we have to assure
    854                          * consistency between yy_current_buffer and our
     947                         * consistency between YY_CURRENT_BUFFER and our
    855948                         * globals.  Here is the right place to do so, because
    856949                         * this is the first action (other than possibly a
    857950                         * back-up) that will match for the new input source.
    858951                         */
    859                         yy_n_chars = yy_current_buffer->yy_n_chars;
    860                         yy_current_buffer->yy_input_file = yyin;
    861                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
     952                        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
     953                        YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
     954                        YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
    862955                        }
    863956
    … …  
    869962                 * in input().
    870963                 */
    871                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
     964                if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
    872965                        { /* This was really a NUL. */
    873966                        yy_state_type yy_next_state;
    874967
    875                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
    876 
    877                         yy_current_state = yy_get_previous_state();
     968                        (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
     969
     970                        yy_current_state = yy_get_previous_state(  );
    878971
    879972                        /* Okay, we're now positioned to make the NUL
    … …  
    888981                        yy_next_state = yy_try_NUL_trans( yy_current_state );
    889982
    890                         yy_bp = yytext_ptr + YY_MORE_ADJ;
     983                        yy_bp = (yytext_ptr) + YY_MORE_ADJ;
    891984
    892985                        if ( yy_next_state )
    893986                                {
    894987                                /* Consume the NUL. */
    895                                 yy_cp = ++yy_c_buf_p;
     988                                yy_cp = ++(yy_c_buf_p);
    896989                                yy_current_state = yy_next_state;
    897990                                goto yy_match;
    … …  
    900993                        else
    901994                                {
    902                                 yy_cp = yy_c_buf_p;
     995                                yy_cp = (yy_c_buf_p);
    903996                                goto yy_find_action;
    904997                                }
    905998                        }
    906999
    907                 else switch ( yy_get_next_buffer() )
     1000                else switch ( yy_get_next_buffer(  ) )
    9081001                        {
    9091002                        case EOB_ACT_END_OF_FILE:
    9101003                                {
    911                                 yy_did_buffer_switch_on_eof = 0;
    912 
    913                                 if ( yywrap() )
     1004                                (yy_did_buffer_switch_on_eof) = 0;
     1005
     1006                                if ( yywrap( ) )
    9141007                                        {
    9151008                                        /* Note: because we've taken care in
    … …  
    9221015                                         * YY_NULL will get returned.
    9231016                                         */
    924                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
     1017                                        (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
    9251018
    9261019                                        yy_act = YY_STATE_EOF(YY_START);
    … …  
    9301023                                else
    9311024                                        {
    932                                         if ( ! yy_did_buffer_switch_on_eof )
     1025                                        if ( ! (yy_did_buffer_switch_on_eof) )
    9331026                                                YY_NEW_FILE;
    9341027                                        }
    … …  
    9371030
    9381031                        case EOB_ACT_CONTINUE_SCAN:
    939                                 yy_c_buf_p =
    940                                         yytext_ptr + yy_amount_of_matched_text;
    941 
    942                                 yy_current_state = yy_get_previous_state();
    943 
    944                                 yy_cp = yy_c_buf_p;
    945                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
     1032                                (yy_c_buf_p) =
     1033                                        (yytext_ptr) + yy_amount_of_matched_text;
     1034
     1035                                yy_current_state = yy_get_previous_state(  );
     1036
     1037                                yy_cp = (yy_c_buf_p);
     1038                                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
    9461039                                goto yy_match;
    9471040
    9481041                        case EOB_ACT_LAST_MATCH:
    949                                 yy_c_buf_p =
    950                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
    951 
    952                                 yy_current_state = yy_get_previous_state();
    953 
    954                                 yy_cp = yy_c_buf_p;
    955                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
     1042                                (yy_c_buf_p) =
     1043                                &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
     1044
     1045                                yy_current_state = yy_get_previous_state(  );
     1046
     1047                                yy_cp = (yy_c_buf_p);
     1048                                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
    9561049                                goto yy_find_action;
    9571050                        }
    … …  
    9641057        } /* end of action switch */
    9651058                } /* end of scanning one token */
    966         } /* end of yylex */
    967 
     1059} /* end of yylex */
    9681060
    9691061/* yy_get_next_buffer - try to read in a new buffer
    … …  
    9741066 *      EOB_ACT_END_OF_FILE - end of file
    9751067 */
    976 
    977 static int yy_get_next_buffer()
    978         {
    979         register char *dest = yy_current_buffer->yy_ch_buf;
    980         register char *source = yytext_ptr;
     1068static int yy_get_next_buffer (void)
     1069{
     1070        register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
     1071        register char *source = (yytext_ptr);
    9811072        register int number_to_move, i;
    9821073        int ret_val;
    9831074
    984         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
     1075        if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
    9851076                YY_FATAL_ERROR(
    9861077                "fatal flex scanner internal error--end of buffer missed" );
    9871078
    988         if ( yy_current_buffer->yy_fill_buffer == 0 )
     1079        if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
    9891080                { /* Don't try to fill the buffer, so this is an EOF. */
    990                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
     1081                if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
    9911082                        {
    9921083                        /* We matched a single character, the EOB, so
    … …  
    10081099
    10091100        /* First move last chars to start of buffer. */
    1010         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
     1101        number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
    10111102
    10121103        for ( i = 0; i < number_to_move; ++i )
    10131104                *(dest++) = *(source++);
    10141105
    1015         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
     1106        if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
    10161107                /* don't do the read, it's not guaranteed to return an EOF,
    10171108                 * just force an EOF
    10181109                 */
    1019                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
     1110                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
    10201111
    10211112        else
    10221113                {
    1023                 int num_to_read =
    1024                         yy_current_buffer->yy_buf_size - number_to_move - 1;
     1114                        int num_to_read =
     1115                        YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
    10251116
    10261117                while ( num_to_read <= 0 )
    10271118                        { /* Not enough room in the buffer - grow it. */
    1028 #ifdef YY_USES_REJECT
    1029                         YY_FATAL_ERROR(
    1030 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
    1031 #else
    10321119
    10331120                        /* just a shorter name for the current buffer */
    1034                         YY_BUFFER_STATE b = yy_current_buffer;
     1121                        YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
    10351122
    10361123                        int yy_c_buf_p_offset =
    1037                                 (int) (yy_c_buf_p - b->yy_ch_buf);
     1124                                (int) ((yy_c_buf_p) - b->yy_ch_buf);
    10381125
    10391126                        if ( b->yy_is_our_buffer )
    … …  
    10481135                                b->yy_ch_buf = (char *)
    10491136                                        /* Include room in for 2 EOB chars. */
    1050                                         yy_flex_realloc( (void *) b->yy_ch_buf,
    1051                                                          b->yy_buf_size + 2 );
     1137                                        yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
    10521138                                }
    10531139                        else
    … …  
    10591145                                "fatal error - scanner input buffer overflow" );
    10601146
    1061                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
    1062 
    1063                         num_to_read = yy_current_buffer->yy_buf_size -
     1147                        (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
     1148
     1149                        num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
    10641150                                                number_to_move - 1;
    1065 #endif
     1151
    10661152                        }
    10671153
    … …  
    10701156
    10711157                /* Read in more data. */
    1072                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
    1073                         yy_n_chars, num_to_read );
    1074 
    1075                 yy_current_buffer->yy_n_chars = yy_n_chars;
     1158                YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
     1159                        (yy_n_chars), num_to_read );
     1160
     1161                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
    10761162                }
    10771163
    1078         if ( yy_n_chars == 0 )
     1164        if ( (yy_n_chars) == 0 )
    10791165                {
    10801166                if ( number_to_move == YY_MORE_ADJ )
    10811167                        {
    10821168                        ret_val = EOB_ACT_END_OF_FILE;
    1083                         yyrestart( yyin );
     1169                        yyrestart(yyin );
    10841170                        }
    10851171
    … …  
    10871173                        {
    10881174                        ret_val = EOB_ACT_LAST_MATCH;
    1089                         yy_current_buffer->yy_buffer_status =
     1175                        YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
    10901176                                YY_BUFFER_EOF_PENDING;
    10911177                        }
    … …  
    10951181                ret_val = EOB_ACT_CONTINUE_SCAN;
    10961182
    1097         yy_n_chars += number_to_move;
    1098         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
    1099         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
    1100 
    1101         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
     1183        (yy_n_chars) += number_to_move;
     1184        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
     1185        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
     1186
     1187        (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
    11021188
    11031189        return ret_val;
    1104         }
    1105 
     1190}
    11061191
    11071192/* yy_get_previous_state - get the state just before the EOB char was reached */
    11081193
    1109 static yy_state_type yy_get_previous_state()
    1110         {
     1194    static yy_state_type yy_get_previous_state (void)
     1195{
    11111196        register yy_state_type yy_current_state;
    11121197        register char *yy_cp;
    1113 
    1114         yy_current_state = yy_start;
    1115 
    1116         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
     1198   
     1199        yy_current_state = (yy_start);
     1200
     1201        for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
    11171202                {
    11181203                register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
    11191204                if ( yy_accept[yy_current_state] )
    11201205                        {
    1121                         yy_last_accepting_state = yy_current_state;
    1122                         yy_last_accepting_cpos = yy_cp;
     1206                        (yy_last_accepting_state) = yy_current_state;
     1207                        (yy_last_accepting_cpos) = yy_cp;
    11231208                        }
    11241209                while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
    … …  
    11321217
    11331218        return yy_current_state;
    1134         }
    1135 
     1219}
    11361220
    11371221/* yy_try_NUL_trans - try to make a transition on the NUL character
    … …  
    11401224 *      next_state = yy_try_NUL_trans( current_state );
    11411225 */
    1142 
    1143 #ifdef YY_USE_PROTOS
    1144 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
    1145 #else
    1146 static yy_state_type yy_try_NUL_trans( yy_current_state )
    1147 yy_state_type yy_current_state;
    1148 #endif
    1149         {
     1226    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
     1227{
    11501228        register int yy_is_jam;
    1151         register char *yy_cp = yy_c_buf_p;
     1229        register char *yy_cp = (yy_c_buf_p);
    11521230
    11531231        register YY_CHAR yy_c = 1;
    11541232        if ( yy_accept[yy_current_state] )
    11551233                {
    1156                 yy_last_accepting_state = yy_current_state;
    1157                 yy_last_accepting_cpos = yy_cp;
     1234                (yy_last_accepting_state) = yy_current_state;
     1235                (yy_last_accepting_cpos) = yy_cp;
    11581236                }
    11591237        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
    … …  
    11671245
    11681246        return yy_is_jam ? 0 : yy_current_state;
    1169         }
    1170 
    1171 
    1172 #ifndef YY_NO_UNPUT
    1173 #ifdef YY_USE_PROTOS
    1174 static void yyunput( int c, register char *yy_bp )
    1175 #else
    1176 static void yyunput( c, yy_bp )
    1177 int c;
    1178 register char *yy_bp;
    1179 #endif
    1180         {
    1181         register char *yy_cp = yy_c_buf_p;
     1247}
     1248
     1249    static void yyunput (int c, register char * yy_bp )
     1250{
     1251        register char *yy_cp;
     1252   
     1253    yy_cp = (yy_c_buf_p);
    11821254
    11831255        /* undo effects of setting up yytext */
    1184         *yy_cp = yy_hold_char;
    1185 
    1186         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
     1256        *yy_cp = (yy_hold_char);
     1257
     1258        if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
    11871259                { /* need to shift things up to make room */
    11881260                /* +2 for EOB chars. */
    1189                 register int number_to_move = yy_n_chars + 2;
    1190                 register char *dest = &yy_current_buffer->yy_ch_buf[
    1191                                         yy_current_buffer->yy_buf_size + 2];
     1261                register int number_to_move = (yy_n_chars) + 2;
     1262                register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
     1263                                        YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
    11921264                register char *source =
    1193                                 &yy_current_buffer->yy_ch_buf[number_to_move];
    1194 
    1195                 while ( source > yy_current_buffer->yy_ch_buf )
     1265                                &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
     1266
     1267                while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
    11961268                        *--dest = *--source;
    11971269
    11981270                yy_cp += (int) (dest - source);
    11991271                yy_bp += (int) (dest - source);
    1200                 yy_current_buffer->yy_n_chars =
    1201                         yy_n_chars = yy_current_buffer->yy_buf_size;
    1202 
    1203                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
     1272                YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
     1273                        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
     1274
     1275                if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
    12041276                        YY_FATAL_ERROR( "flex scanner push-back overflow" );
    12051277                }
    … …  
    12071279        *--yy_cp = (char) c;
    12081280
    1209 
    1210         yytext_ptr = yy_bp;
    1211         yy_hold_char = *yy_cp;
    1212         yy_c_buf_p = yy_cp;
    1213         }
    1214 #endif  /* ifndef YY_NO_UNPUT */
    1215 
    1216 
     1281        (yytext_ptr) = yy_bp;
     1282        (yy_hold_char) = *yy_cp;
     1283        (yy_c_buf_p) = yy_cp;
     1284}
     1285
     1286#ifndef YY_NO_INPUT
    12171287#ifdef __cplusplus
    1218 static int yyinput()
     1288    static int yyinput (void)
    12191289#else
    1220 static int input()
    1221 #endif
    1222         {
     1290    static int input  (void)
     1291#endif
     1292
     1293{
    12231294        int c;
    1224 
    1225         *yy_c_buf_p = yy_hold_char;
    1226 
    1227         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
     1295   
     1296        *(yy_c_buf_p) = (yy_hold_char);
     1297
     1298        if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
    12281299                {
    12291300                /* yy_c_buf_p now points to the character we want to return.
    … …  
    12311302                 * valid NUL; if not, then we've hit the end of the buffer.
    12321303                 */
    1233                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
     1304                if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
    12341305                        /* This was really a NUL. */
    1235                         *yy_c_buf_p = '\0';
     1306                        *(yy_c_buf_p) = '\0';
    12361307
    12371308                else
    12381309                        { /* need more input */
    1239                         int offset = yy_c_buf_p - yytext_ptr;
    1240                         ++yy_c_buf_p;
    1241 
    1242                         switch ( yy_get_next_buffer() )
     1310                        int offset = (yy_c_buf_p) - (yytext_ptr);
     1311                        ++(yy_c_buf_p);
     1312
     1313                        switch ( yy_get_next_buffer(  ) )
    12431314                                {
    12441315                                case EOB_ACT_LAST_MATCH:
    … …  
    12541325
    12551326                                        /* Reset buffer status. */
    1256                                         yyrestart( yyin );
    1257 
    1258                                         /* fall through */
     1327                                        yyrestart(yyin );
     1328
     1329                                        /*FALLTHROUGH*/
    12591330
    12601331                                case EOB_ACT_END_OF_FILE:
    12611332                                        {
    1262                                         if ( yywrap() )
     1333                                        if ( yywrap( ) )
    12631334                                                return EOF;
    12641335
    1265                                         if ( ! yy_did_buffer_switch_on_eof )
     1336                                        if ( ! (yy_did_buffer_switch_on_eof) )
    12661337                                                YY_NEW_FILE;
    12671338#ifdef __cplusplus
    … …  
    12731344
    12741345                                case EOB_ACT_CONTINUE_SCAN:
    1275                                         yy_c_buf_p = yytext_ptr + offset;
     1346                                        (yy_c_buf_p) = (yytext_ptr) + offset;
    12761347                                        break;
    12771348                                }
    … …  
    12791350                }
    12801351
    1281         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
    1282         *yy_c_buf_p = '\0';     /* preserve yytext */
    1283         yy_hold_char = *++yy_c_buf_p;
    1284 
     1352        c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
     1353        *(yy_c_buf_p) = '\0';   /* preserve yytext */
     1354        (yy_hold_char) = *++(yy_c_buf_p);
    12851355
    12861356        return c;
     1357}
     1358#endif  /* ifndef YY_NO_INPUT */
     1359
     1360/** Immediately switch to a different input stream.
     1361 * @param input_file A readable stream.
     1362 *
     1363 * @note This function does not reset the start condition to @c INITIAL .
     1364 */
     1365    void yyrestart  (FILE * input_file )
     1366{
     1367   
     1368        if ( ! YY_CURRENT_BUFFER ){
     1369        yyensure_buffer_stack ();
     1370                YY_CURRENT_BUFFER_LVALUE =
     1371            yy_create_buffer(yyin,YY_BUF_SIZE );
    12871372        }
    12881373
    1289 
    1290 #ifdef YY_USE_PROTOS
    1291 void yyrestart( FILE *input_file )
    1292 #else
    1293 void yyrestart( input_file )
    1294 FILE *input_file;
    1295 #endif
    1296         {
    1297         if ( ! yy_current_buffer )
    1298                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
    1299 
    1300         yy_init_buffer( yy_current_buffer, input_file );
    1301         yy_load_buffer_state();
    1302         }
    1303 
    1304 
    1305 #ifdef YY_USE_PROTOS
    1306 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
    1307 #else
    1308 void yy_switch_to_buffer( new_buffer )
    1309 YY_BUFFER_STATE new_buffer;
    1310 #endif
    1311         {
    1312         if ( yy_current_buffer == new_buffer )
     1374        yy_init_buffer(YY_CURRENT_BUFFER,input_file );
     1375        yy_load_buffer_state( );
     1376}
     1377
     1378/** Switch to a different input buffer.
     1379 * @param new_buffer The new input buffer.
     1380 *
     1381 */
     1382    void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
     1383{
     1384   
     1385        /* TODO. We should be able to replace this entire function body
     1386         * with
     1387         *              yypop_buffer_state();
     1388         *              yypush_buffer_state(new_buffer);
     1389     */
     1390        yyensure_buffer_stack ();
     1391        if ( YY_CURRENT_BUFFER == new_buffer )
    13131392                return;
    13141393
    1315         if ( yy_current_buffer )
     1394        if ( YY_CURRENT_BUFFER )
    13161395                {
    13171396                /* Flush out information for old buffer. */
    1318                 *yy_c_buf_p = yy_hold_char;
    1319                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
    1320                 yy_current_buffer->yy_n_chars = yy_n_chars;
     1397                *(yy_c_buf_p) = (yy_hold_char);
     1398                YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
     1399                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
    13211400                }
    13221401
    1323         yy_current_buffer = new_buffer;
    1324         yy_load_buffer_state();
     1402        YY_CURRENT_BUFFER_LVALUE = new_buffer;
     1403        yy_load_buffer_state( );
    13251404
    13261405        /* We don't actually know whether we did this switch during
    … …  
    13291408         * to go ahead and always set it.
    13301409         */
    1331         yy_did_buffer_switch_on_eof = 1;
    1332         }
    1333 
    1334 
    1335 #ifdef YY_USE_PROTOS
    1336 void yy_load_buffer_state( void )
    1337 #else
    1338 void yy_load_buffer_state()
    1339 #endif
    1340         {
    1341         yy_n_chars = yy_current_buffer->yy_n_chars;
    1342         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
    1343         yyin = yy_current_buffer->yy_input_file;
    1344         yy_hold_char = *yy_c_buf_p;
    1345         }
    1346 
    1347 
    1348 #ifdef YY_USE_PROTOS
    1349 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
    1350 #else
    1351 YY_BUFFER_STATE yy_create_buffer( file, size )
    1352 FILE *file;
    1353 int size;
    1354 #endif
    1355         {
     1410        (yy_did_buffer_switch_on_eof) = 1;
     1411}
     1412
     1413static void yy_load_buffer_state  (void)
     1414{
     1415        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
     1416        (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
     1417        yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
     1418        (yy_hold_char) = *(yy_c_buf_p);
     1419}
     1420
     1421/** Allocate and initialize an input buffer state.
     1422 * @param file A readable stream.
     1423 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
     1424 *
     1425 * @return the allocated buffer state.
     1426 */
     1427    YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
     1428{
    13561429        YY_BUFFER_STATE b;
    1357 
    1358         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
     1430   
     1431        b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
    13591432        if ( ! b )
    13601433                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
    … …  
    13651438         * we need to put in 2 end-of-buffer characters.
    13661439         */
    1367         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
     1440        b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 );
    13681441        if ( ! b->yy_ch_buf )
    13691442                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
    … …  
    13711444        b->yy_is_our_buffer = 1;
    13721445
    1373         yy_init_buffer( b, file );
     1446        yy_init_buffer(b,file );
    13741447
    13751448        return b;
    1376         }
    1377 
    1378 
    1379 #ifdef YY_USE_PROTOS
    1380 void yy_delete_buffer( YY_BUFFER_STATE b )
    1381 #else
    1382 void yy_delete_buffer( b )
    1383 YY_BUFFER_STATE b;
    1384 #endif
    1385         {
     1449}
     1450
     1451/** Destroy the buffer.
     1452 * @param b a buffer created with yy_create_buffer()
     1453 *
     1454 */
     1455    void yy_delete_buffer (YY_BUFFER_STATE  b )
     1456{
     1457   
    13861458        if ( ! b )
    13871459                return;
    13881460
    1389         if ( b == yy_current_buffer )
    1390                 yy_current_buffer = (YY_BUFFER_STATE) 0;
     1461        if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
     1462                YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
    13911463
    13921464        if ( b->yy_is_our_buffer )
    1393                 yy_flex_free( (void *) b->yy_ch_buf );
    1394 
    1395         yy_flex_free( (void *) b );
    1396         }
    1397 
    1398 
    1399 
    1400 #ifdef YY_USE_PROTOS
    1401 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
     1465                yyfree((void *) b->yy_ch_buf  );
     1466
     1467        yyfree((void *) b  );
     1468}
     1469
     1470#ifndef _UNISTD_H /* assume unistd.h has isatty() for us */
     1471#ifdef __cplusplus
     1472extern "C" {
     1473#endif
     1474#ifdef __THROW /* this is a gnuism */
     1475extern int isatty (int ) __THROW;
    14021476#else
    1403 void yy_init_buffer( b, file )
    1404 YY_BUFFER_STATE b;
    1405 FILE *file;
    1406 #endif
    1407 
    1408 
    1409         {
    1410         yy_flush_buffer( b );
     1477extern int isatty (int );
     1478#endif
     1479#ifdef __cplusplus
     1480}
     1481#endif
     1482#endif
     1483   
     1484/* Initializes or reinitializes a buffer.
     1485 * This function is sometimes called more than once on the same buffer,
     1486 * such as during a yyrestart() or at EOF.
     1487 */
     1488    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
     1489
     1490{
     1491        int oerrno = errno;
     1492   
     1493        yy_flush_buffer(b );
    14111494
    14121495        b->yy_input_file = file;
    14131496        b->yy_fill_buffer = 1;
    14141497
    1415 #if YY_ALWAYS_INTERACTIVE
    1416         b->yy_is_interactive = 1;
    1417 #else
    1418 #if YY_NEVER_INTERACTIVE
    1419         b->yy_is_interactive = 0;
    1420 #else
    1421         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
    1422 #endif
    1423 #endif
    1424         }
    1425 
    1426 
    1427 #ifdef YY_USE_PROTOS
    1428 void yy_flush_buffer( YY_BUFFER_STATE b )
    1429 #else
    1430 void yy_flush_buffer( b )
    1431 YY_BUFFER_STATE b;
    1432 #endif
    1433 
    1434         {
    1435         if ( ! b )
     1498    /* If b is the current buffer, then yy_init_buffer was _probably_
     1499     * called from yyrestart() or through yy_get_next_buffer.
     1500     * In that case, we don't want to reset the lineno or column.
     1501     */
     1502    if (b != YY_CURRENT_BUFFER){
     1503        b->yy_bs_lineno = 1;
     1504        b->yy_bs_column = 0;
     1505    }
     1506
     1507        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
     1508   
     1509        errno = oerrno;
     1510}
     1511
     1512/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
     1513 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
     1514 *
     1515 */
     1516    void yy_flush_buffer (YY_BUFFER_STATE  b )
     1517{
     1518        if ( ! b )
    14361519                return;
    14371520
    … …  
    14501533        b->yy_buffer_status = YY_BUFFER_NEW;
    14511534
    1452         if ( b == yy_current_buffer )
    1453                 yy_load_buffer_state();
     1535        if ( b == YY_CURRENT_BUFFER )
     1536                yy_load_buffer_state( );
     1537}
     1538
     1539/** Pushes the new state onto the stack. The new state becomes
     1540 *  the current state. This function will allocate the stack
     1541 *  if necessary.
     1542 *  @param new_buffer The new state.
     1543 * 
     1544 */
     1545void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
     1546{
     1547        if (new_buffer == NULL)
     1548                return;
     1549
     1550        yyensure_buffer_stack();
     1551
     1552        /* This block is copied from yy_switch_to_buffer. */
     1553        if ( YY_CURRENT_BUFFER )
     1554                {
     1555                /* Flush out information for old buffer. */
     1556                *(yy_c_buf_p) = (yy_hold_char);
     1557                YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
     1558                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
     1559                }
     1560
     1561        /* Only push if top exists. Otherwise, replace top. */
     1562        if (YY_CURRENT_BUFFER)
     1563                (yy_buffer_stack_top)++;
     1564        YY_CURRENT_BUFFER_LVALUE = new_buffer;
     1565
     1566        /* copied from yy_switch_to_buffer. */
     1567        yy_load_buffer_state( );
     1568        (yy_did_buffer_switch_on_eof) = 1;
     1569}
     1570
     1571/** Removes and deletes the top of the stack, if present.
     1572 *  The next element becomes the new top.
     1573 * 
     1574 */
     1575void yypop_buffer_state (void)
     1576{
     1577        if (!YY_CURRENT_BUFFER)
     1578                return;
     1579
     1580        yy_delete_buffer(YY_CURRENT_BUFFER );
     1581        YY_CURRENT_BUFFER_LVALUE = NULL;
     1582        if ((yy_buffer_stack_top) > 0)
     1583                --(yy_buffer_stack_top);
     1584
     1585        if (YY_CURRENT_BUFFER) {
     1586                yy_load_buffer_state( );
     1587                (yy_did_buffer_switch_on_eof) = 1;
    14541588        }
    1455 
    1456 
    1457 #ifndef YY_NO_SCAN_BUFFER
    1458 #ifdef YY_USE_PROTOS
    1459 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
    1460 #else
    1461 YY_BUFFER_STATE yy_scan_buffer( base, size )
    1462 char *base;
    1463 yy_size_t size;
    1464 #endif
    1465         {
     1589}
     1590
     1591/* Allocates the stack if it does not exist.
     1592 *  Guarantees space for at least one push.
     1593 */
     1594static void yyensure_buffer_stack (void)
     1595{
     1596        int num_to_alloc;
     1597   
     1598        if (!(yy_buffer_stack)) {
     1599
     1600                /* First allocation is just for 2 elements, since we don't know if this
     1601                 * scanner will even need a stack. We use 2 instead of 1 to avoid an
     1602                 * immediate realloc on the next call.
     1603         */
     1604                num_to_alloc = 1;
     1605                (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
     1606                                                                (num_to_alloc * sizeof(struct yy_buffer_state*)
     1607                                                                );
     1608               
     1609                memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
     1610                               
     1611                (yy_buffer_stack_max) = num_to_alloc;
     1612                (yy_buffer_stack_top) = 0;
     1613                return;
     1614        }
     1615
     1616        if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
     1617
     1618                /* Increase the buffer to prepare for a possible push. */
     1619                int grow_size = 8 /* arbitrary grow size */;
     1620
     1621                num_to_alloc = (yy_buffer_stack_max) + grow_size;
     1622                (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
     1623                                                                ((yy_buffer_stack),
     1624                                                                num_to_alloc * sizeof(struct yy_buffer_state*)
     1625                                                                );
     1626
     1627                /* zero only the new slots.*/
     1628                memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
     1629                (yy_buffer_stack_max) = num_to_alloc;
     1630        }
     1631}
     1632
     1633/** Setup the input buffer state to scan directly from a user-specified character buffer.
     1634 * @param base the character buffer
     1635 * @param size the size in bytes of the character buffer
     1636 *
     1637 * @return the newly allocated buffer state object.
     1638 */
     1639YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
     1640{
    14661641        YY_BUFFER_STATE b;
    1467 
     1642   
    14681643        if ( size < 2 ||
    14691644             base[size-2] != YY_END_OF_BUFFER_CHAR ||
    … …  
    14721647                return 0;
    14731648
    1474         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
     1649        b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
    14751650        if ( ! b )
    14761651                YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
    … …  
    14861661        b->yy_buffer_status = YY_BUFFER_NEW;
    14871662
    1488         yy_switch_to_buffer( b );
     1663        yy_switch_to_buffer(b );
    14891664
    14901665        return b;
    1491         }
    1492 #endif
    1493 
    1494 
    1495 #ifndef YY_NO_SCAN_STRING
    1496 #ifdef YY_USE_PROTOS
    1497 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
    1498 #else
    1499 YY_BUFFER_STATE yy_scan_string( yy_str )
    1500 yyconst char *yy_str;
    1501 #endif
    1502         {
    1503         int len;
    1504         for ( len = 0; yy_str[len]; ++len )
    1505                 ;
    1506 
    1507         return yy_scan_bytes( yy_str, len );
    1508         }
    1509 #endif
    1510 
    1511 
    1512 #ifndef YY_NO_SCAN_BYTES
    1513 #ifdef YY_USE_PROTOS
    1514 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
    1515 #else
    1516 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
    1517 yyconst char *bytes;
    1518 int len;
    1519 #endif
    1520         {
     1666}
     1667
     1668/** Setup the input buffer state to scan a string. The next call to yylex() will
     1669 * scan from a @e copy of @a str.
     1670 * @param str a NUL-terminated string to scan
     1671 *
     1672 * @return the newly allocated buffer state object.
     1673 * @note If you want to scan bytes that may contain NUL values, then use
     1674 *       yy_scan_bytes() instead.
     1675 */
     1676YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
     1677{
     1678   
     1679        return yy_scan_bytes(yystr,strlen(yystr) );
     1680}
     1681
     1682/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
     1683 * scan from a @e copy of @a bytes.
     1684 * @param bytes the byte buffer to scan
     1685 * @param len the number of bytes in the buffer pointed to by @a bytes.
     1686 *
     1687 * @return the newly allocated buffer state object.
     1688 */
     1689YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
     1690{
    15211691        YY_BUFFER_STATE b;
    15221692        char *buf;
    15231693        yy_size_t n;
    15241694        int i;
    1525 
     1695   
    15261696        /* Get memory for full buffer, including space for trailing EOB's. */
    1527         n = len + 2;
    1528         buf = (char *) yy_flex_alloc( n );
     1697        n = _yybytes_len + 2;
     1698        buf = (char *) yyalloc(n );
    15291699        if ( ! buf )
    15301700                YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
    15311701
    1532         for ( i = 0; i < len; ++i )
    1533                 buf[i] = bytes[i];
    1534 
    1535         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
    1536 
    1537         b = yy_scan_buffer( buf, n );
     1702        for ( i = 0; i < _yybytes_len; ++i )
     1703                buf[i] = yybytes[i];
     1704
     1705        buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
     1706
     1707        b = yy_scan_buffer(buf,n );
    15381708        if ( ! b )
    15391709                YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
    … …  
    15451715
    15461716        return b;
    1547         }
    1548 #endif
    1549 
    1550 
    1551 #ifndef YY_NO_PUSH_STATE
    1552 #ifdef YY_USE_PROTOS
    1553 static void yy_push_state( int new_state )
    1554 #else
    1555 static void yy_push_state( new_state )
    1556 int new_state;
    1557 #endif
    1558         {
    1559         if ( yy_start_stack_ptr >= yy_start_stack_depth )
    1560                 {
    1561                 yy_size_t new_size;
    1562 
    1563                 yy_start_stack_depth += YY_START_STACK_INCR;
    1564                 new_size = yy_start_stack_depth * sizeof( int );
    1565 
    1566                 if ( ! yy_start_stack )
    1567                         yy_start_stack = (int *) yy_flex_alloc( new_size );
    1568 
    1569                 else
    1570                         yy_start_stack = (int *) yy_flex_realloc(
    1571                                         (void *) yy_start_stack, new_size );
    1572 
    1573                 if ( ! yy_start_stack )
    1574                         YY_FATAL_ERROR(
    1575                         "out of memory expanding start-condition stack" );
    1576                 }
    1577 
    1578         yy_start_stack[yy_start_stack_ptr++] = YY_START;
    1579 
    1580         BEGIN(new_state);
    1581         }
    1582 #endif
    1583 
    1584 
    1585 #ifndef YY_NO_POP_STATE
    1586 static void yy_pop_state()
    1587         {
    1588         if ( --yy_start_stack_ptr < 0 )
    1589                 YY_FATAL_ERROR( "start-condition stack underflow" );
    1590 
    1591         BEGIN(yy_start_stack[yy_start_stack_ptr]);
    1592         }
    1593 #endif
    1594 
    1595 
    1596 #ifndef YY_NO_TOP_STATE
    1597 static int yy_top_state()
    1598         {
    1599         return yy_start_stack[yy_start_stack_ptr - 1];
    1600         }
    1601 #endif
     1717}
    16021718
    16031719#ifndef YY_EXIT_FAILURE
    … …  
    16051721#endif
    16061722
    1607 #ifdef YY_USE_PROTOS
    1608 static void yy_fatal_error( yyconst char msg[] )
    1609 #else
    1610 static void yy_fatal_error( msg )
    1611 char msg[];
    1612 #endif
    1613         {
    1614         (void) fprintf( stderr, "%s\n", msg );
     1723static void yy_fatal_error (yyconst char* msg )
     1724{
     1725        (void) fprintf( stderr, "%s\n", msg );
    16151726        exit( YY_EXIT_FAILURE );
    1616         }
    1617 
    1618 
     1727}
    16191728
    16201729/* Redefine yyless() so it works in section 3 code. */
    … …  
    16251734                { \
    16261735                /* Undo effects of setting up yytext. */ \
    1627                 yytext[yyleng] = yy_hold_char; \
    1628                 yy_c_buf_p = yytext + n; \
    1629                 yy_hold_char = *yy_c_buf_p; \
    1630                 *yy_c_buf_p = '\0'; \
    1631                 yyleng = n; \
     1736        int yyless_macro_arg = (n); \
     1737        YY_LESS_LINENO(yyless_macro_arg);\
     1738                yytext[yyleng] = (yy_hold_char); \
     1739                (yy_c_buf_p) = yytext + yyless_macro_arg; \
     1740                (yy_hold_char) = *(yy_c_buf_p); \
     1741                *(yy_c_buf_p) = '\0'; \
     1742                yyleng = yyless_macro_arg; \
    16321743                } \
    16331744        while ( 0 )
    16341745
    1635 
    1636 /* Internal utility routines. */
     1746/* Accessor  methods (get/set functions) to struct members. */
     1747
     1748/** Get the current line number.
     1749 *
     1750 */
     1751int yyget_lineno  (void)
     1752{
     1753       
     1754    return yylineno;
     1755}
     1756
     1757/** Get the input stream.
     1758 *
     1759 */
     1760FILE *yyget_in  (void)
     1761{
     1762        return yyin;
     1763}
     1764
     1765/** Get the output stream.
     1766 *
     1767 */
     1768FILE *yyget_out  (void)
     1769{
     1770        return yyout;
     1771}
     1772
     1773/** Get the length of the current token.
     1774 *
     1775 */
     1776int yyget_leng  (void)
     1777{
     1778        return yyleng;
     1779}
     1780
     1781/** Get the current token.
     1782 *
     1783 */
     1784
     1785char *yyget_text  (void)
     1786{
     1787        return yytext;
     1788}
     1789
     1790/** Set the current line number.
     1791 * @param line_number
     1792 *
     1793 */
     1794void yyset_lineno (int  line_number )
     1795{
     1796   
     1797    yylineno = line_number;
     1798}
     1799
     1800/** Set the input stream. This does not discard the current
     1801 * input buffer.
     1802 * @param in_str A readable stream.
     1803 *
     1804 * @see yy_switch_to_buffer
     1805 */
     1806void yyset_in (FILE *  in_str )
     1807{
     1808        yyin = in_str ;
     1809}
     1810
     1811void yyset_out (FILE *  out_str )
     1812{
     1813        yyout = out_str ;
     1814}
     1815
     1816int yyget_debug  (void)
     1817{
     1818        return yy_flex_debug;
     1819}
     1820
     1821void yyset_debug (int  bdebug )
     1822{
     1823        yy_flex_debug = bdebug ;
     1824}
     1825
     1826static int yy_init_globals (void)
     1827{
     1828        /* Initialization is the same as for the non-reentrant scanner.
     1829     * This function is called from yylex_destroy(), so don't allocate here.
     1830     */
     1831
     1832    (yy_buffer_stack) = 0;
     1833    (yy_buffer_stack_top) = 0;
     1834    (yy_buffer_stack_max) = 0;
     1835    (yy_c_buf_p) = (char *) 0;
     1836    (yy_init) = 0;
     1837    (yy_start) = 0;
     1838
     1839/* Defined in main.c */
     1840#ifdef YY_STDINIT
     1841    yyin = stdin;
     1842    yyout = stdout;
     1843#else
     1844    yyin = (FILE *) 0;
     1845    yyout = (FILE *) 0;
     1846#endif
     1847
     1848    /* For future reference: Set errno on error, since we are called by
     1849     * yylex_init()
     1850     */
     1851    return 0;
     1852}
     1853
     1854/* yylex_destroy is for both reentrant and non-reentrant scanners. */
     1855int yylex_destroy  (void)
     1856{
     1857   
     1858    /* Pop the buffer stack, destroying each element. */
     1859        while(YY_CURRENT_BUFFER){
     1860                yy_delete_buffer(YY_CURRENT_BUFFER  );
     1861                YY_CURRENT_BUFFER_LVALUE = NULL;
     1862                yypop_buffer_state();
     1863        }
     1864
     1865        /* Destroy the stack itself. */
     1866        yyfree((yy_buffer_stack) );
     1867        (yy_buffer_stack) = NULL;
     1868
     1869    /* Reset the globals. This is important in a non-reentrant scanner so the next time
     1870     * yylex() is called, initialization will occur. */
     1871    yy_init_globals( );
     1872
     1873    return 0;
     1874}
     1875
     1876/*
     1877 * Internal utility routines.
     1878 */
    16371879
    16381880#ifndef yytext_ptr
    1639 #ifdef YY_USE_PROTOS
    1640 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
    1641 #else
    1642 static void yy_flex_strncpy( s1, s2, n )
    1643 char *s1;
    1644 yyconst char *s2;
    1645 int n;
    1646 #endif
    1647         {
     1881static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
     1882{
    16481883        register int i;
    16491884        for ( i = 0; i < n; ++i )
    16501885                s1[i] = s2[i];
    1651         }
     1886}
    16521887#endif
    16531888
    16541889#ifdef YY_NEED_STRLEN
    1655 #ifdef YY_USE_PROTOS
    1656 static int yy_flex_strlen( yyconst char *s )
    1657 #else
    1658 static int yy_flex_strlen( s )
    1659 yyconst char *s;
    1660 #endif
    1661         {
     1890static int yy_flex_strlen (yyconst char * s )
     1891{
    16621892        register int n;
    16631893        for ( n = 0; s[n]; ++n )
    … …  
    16651895
    16661896        return n;
    1667         }
    1668 #endif
    1669 
    1670 
    1671 #ifdef YY_USE_PROTOS
    1672 static void *yy_flex_alloc( yy_size_t size )
    1673 #else
    1674 static void *yy_flex_alloc( size )
    1675 yy_size_t size;
    1676 #endif
    1677         {
     1897}
     1898#endif
     1899
     1900void *yyalloc (yy_size_t  size )
     1901{
    16781902        return (void *) malloc( size );
    1679         }
    1680 
    1681 #ifdef YY_USE_PROTOS
    1682 static void *yy_flex_realloc( void *ptr, yy_size_t size )
    1683 #else
    1684 static void *yy_flex_realloc( ptr, size )
    1685 void *ptr;
    1686 yy_size_t size;
    1687 #endif
    1688         {
     1903}
     1904
     1905void *yyrealloc  (void * ptr, yy_size_t  size )
     1906{
    16891907        /* The cast to (char *) in the following accommodates both
    16901908         * implementations that use char* generic pointers, and those
    … …  
    16951913         */
    16961914        return (void *) realloc( (char *) ptr, size );
    1697         }
    1698 
    1699 #ifdef YY_USE_PROTOS
    1700 static void yy_flex_free( void *ptr )
    1701 #else
    1702 static void yy_flex_free( ptr )
    1703 void *ptr;
    1704 #endif
    1705         {
    1706         free( ptr );
    1707         }
    1708 
    1709 #if YY_MAIN
    1710 int main()
    1711         {
    1712         yylex();
    1713         return 0;
    1714         }
    1715 #endif
     1915}
     1916
     1917void yyfree (void * ptr )
     1918{
     1919        free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
     1920}
     1921
     1922#define YYTABLES_NAME "yytables"
     1923
    17161924#line 96 "arith_lex.l"
     1925
    17171926
    17181927
    … …  
    17231932#endif
    17241933}
     1934
Note: See TracChangeset for help on using the changeset viewer.