Changeset 6753dda in freewrt


Ignore:
Timestamp:
Jul 27, 2006, 3:11:13 PM (19 years ago)
Author:
Thorsten Glaser <tg@…>
Branches:
freewrt_1_0, freewrt_2_0
Children:
5dcd6404
Parents:
4e0f7fd
Message:

regenerate these files with current flex and bison
verified to still work

git-svn-id: ​svn://www.freewrt.org/trunk/freewrt@445 afb5a338-a214-0410-bd46-81f09a774fd1

Location:
package/config
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • package/config/lex.zconf.c_shipped

    r4e0f7fd r6753dda  
    1 
    2 #line 3 "lex.zconf.c"
    3 
    4 #define  YY_INT_ALIGNED short int
    5 
     1#define yy_create_buffer zconf_create_buffer
     2#define yy_delete_buffer zconf_delete_buffer
     3#define yy_scan_buffer zconf_scan_buffer
     4#define yy_scan_string zconf_scan_string
     5#define yy_scan_bytes zconf_scan_bytes
     6#define yy_flex_debug zconf_flex_debug
     7#define yy_init_buffer zconf_init_buffer
     8#define yy_flush_buffer zconf_flush_buffer
     9#define yy_load_buffer_state zconf_load_buffer_state
     10#define yy_switch_to_buffer zconf_switch_to_buffer
     11#define yyin zconfin
     12#define yyleng zconfleng
     13#define yylex zconflex
     14#define yyout zconfout
     15#define yyrestart zconfrestart
     16#define yytext zconftext
     17
     18#line 19 "lex.zconf.c"
    619/* A lexical scanner generated by flex */
     20
     21/* Scanner skeleton version:
     22 * $MirOS: src/usr.bin/lex/flex.skl,v 1.2 2005/10/21 10:39:48 tg Exp $
     23 * $Header: /cvs/src/usr.bin/lex/flex.skl,v 1.8 2004/02/09 11:38:31 espie Exp $
     24 */
    725
    826#define FLEX_SCANNER
    927#define YY_FLEX_MAJOR_VERSION 2
    1028#define YY_FLEX_MINOR_VERSION 5
    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. */
     29
    1930#include <stdio.h>
    20 #include <string.h>
    2131#include <errno.h>
     32
     33
     34/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
     35#ifdef c_plusplus
     36#ifndef __cplusplus
     37#define __cplusplus
     38#endif
     39#endif
     40
     41
     42#ifdef __cplusplus
     43
    2244#include <stdlib.h>
    23 #include <glob.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 defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
    35 #include <inttypes.h>
    36 typedef int8_t flex_int8_t;
    37 typedef uint8_t flex_uint8_t;
    38 typedef int16_t flex_int16_t;
    39 typedef uint16_t flex_uint16_t;
    40 typedef int32_t flex_int32_t;
    41 typedef uint32_t flex_uint32_t;
    42 #else
    43 typedef signed char flex_int8_t;
    44 typedef short int flex_int16_t;
    45 typedef int flex_int32_t;
    46 typedef unsigned char flex_uint8_t;
    47 typedef unsigned short int flex_uint16_t;
    48 typedef unsigned int flex_uint32_t;
    49 #endif /* ! C99 */
    50 
    51 /* Limits of integral types. */
    52 #ifndef INT8_MIN
    53 #define INT8_MIN               (-128)
    54 #endif
    55 #ifndef INT16_MIN
    56 #define INT16_MIN              (-32767-1)
    57 #endif
    58 #ifndef INT32_MIN
    59 #define INT32_MIN              (-2147483647-1)
    60 #endif
    61 #ifndef INT8_MAX
    62 #define INT8_MAX               (127)
    63 #endif
    64 #ifndef INT16_MAX
    65 #define INT16_MAX              (32767)
    66 #endif
    67 #ifndef INT32_MAX
    68 #define INT32_MAX              (2147483647)
    69 #endif
    70 #ifndef UINT8_MAX
    71 #define UINT8_MAX              (255U)
    72 #endif
    73 #ifndef UINT16_MAX
    74 #define UINT16_MAX             (65535U)
    75 #endif
    76 #ifndef UINT32_MAX
    77 #define UINT32_MAX             (4294967295U)
    78 #endif
    79 
    80 #endif /* ! FLEXINT_H */
    81 
    82 #ifdef __cplusplus
     45#include <unistd.h>
     46
     47/* Use prototypes in function declarations. */
     48#define YY_USE_PROTOS
    8349
    8450/* The "const" storage-class-modifier is valid. */
    … …  
    8753#else   /* ! __cplusplus */
    8854
    89 #if __STDC__
    90 
     55#ifdef __STDC__
     56
     57#define YY_USE_PROTOS
    9158#define YY_USE_CONST
    9259
    9360#endif  /* __STDC__ */
    9461#endif  /* ! __cplusplus */
     62
     63#ifdef __TURBOC__
     64 #pragma warn -rch
     65 #pragma warn -use
     66#include <io.h>
     67#include <stdlib.h>
     68#define YY_USE_CONST
     69#define YY_USE_PROTOS
     70#endif
    9571
    9672#ifdef YY_USE_CONST
    … …  
    9874#else
    9975#define yyconst
     76#endif
     77
     78
     79#ifdef YY_USE_PROTOS
     80#define YY_PROTO(proto) proto
     81#else
     82#define YY_PROTO(proto) ()
    10083#endif
    10184
    … …  
    11497 * definition of BEGIN.
    11598 */
    116 #define BEGIN (yy_start) = 1 + 2 *
     99#define BEGIN yy_start = 1 + 2 *
    117100
    118101/* Translate the current start state into a value that can be later handed
    … …  
    120103 * compatibility.
    121104 */
    122 #define YY_START (((yy_start) - 1) / 2)
     105#define YY_START ((yy_start - 1) / 2)
    123106#define YYSTATE YY_START
    124107
    … …  
    127110
    128111/* Special action meaning "start processing a new file". */
    129 #define YY_NEW_FILE zconfrestart(zconfin )
     112#define YY_NEW_FILE yyrestart( yyin )
    130113
    131114#define YY_END_OF_BUFFER_CHAR 0
    132115
    133116/* Size of default input buffer. */
    134 #ifndef YY_BUF_SIZE
    135117#define YY_BUF_SIZE 16384
    136 #endif
    137 
    138 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
    139 #define YY_TYPEDEF_YY_BUFFER_STATE
     118
    140119typedef struct yy_buffer_state *YY_BUFFER_STATE;
    141 #endif
    142 
    143 extern int zconfleng;
    144 
    145 extern FILE *zconfin, *zconfout;
     120
     121extern int yyleng;
     122extern FILE *yyin, *yyout;
    146123
    147124#define EOB_ACT_CONTINUE_SCAN 0
    … …  
    149126#define EOB_ACT_LAST_MATCH 2
    150127
    151     #define YY_LESS_LINENO(n)
    152 
    153 /* Return all but the first "n" matched characters back to the input stream. */
     128/* The funky do-while in the following #define is used to turn the definition
     129 * int a single C statement (which needs a semi-colon terminator).  This
     130 * avoids problems with code like:
     131 *
     132 *      if ( condition_holds )
     133 *              yyless( 5 );
     134 *      else
     135 *              do_something_else();
     136 *
     137 * Prior to using the do-while the compiler would get upset at the
     138 * "else" because it interpreted the "if" statement as being all
     139 * done when it reached the ';' after the yyless() call.
     140 */
     141
     142/* Return all but the first 'n' matched characters back to the input stream. */
     143
    154144#define yyless(n) \
    155145        do \
    156146                { \
    157                 /* Undo effects of setting up zconftext. */ \
    158         int yyless_macro_arg = (n); \
    159         YY_LESS_LINENO(yyless_macro_arg);\
    160                 *yy_cp = (yy_hold_char); \
     147                /* Undo effects of setting up yytext. */ \
     148                *yy_cp = yy_hold_char; \
    161149                YY_RESTORE_YY_MORE_OFFSET \
    162                 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
    163                 YY_DO_BEFORE_ACTION; /* set up zconftext again */ \
     150                yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
     151                YY_DO_BEFORE_ACTION; /* set up yytext again */ \
    164152                } \
    165153        while ( 0 )
    166154
    167 #define unput(c) yyunput( c, (yytext_ptr) )
     155#define unput(c) yyunput( c, yytext_ptr )
    168156
    169157/* The following is because we cannot portably get our hands on size_t
    … …  
    171159 * flex-generated scanners to compile on their own).
    172160 */
    173 
    174 #ifndef YY_TYPEDEF_YY_SIZE_T
    175 #define YY_TYPEDEF_YY_SIZE_T
    176161typedef unsigned int yy_size_t;
    177 #endif
    178 
    179 #ifndef YY_STRUCT_YY_BUFFER_STATE
    180 #define YY_STRUCT_YY_BUFFER_STATE
     162
     163
    181164struct yy_buffer_state
    182165        {
    … …  
    215198        int yy_at_bol;
    216199
    217     int yy_bs_lineno; /**< The line count. */
    218     int yy_bs_column; /**< The column count. */
    219 
    220200        /* Whether to try to fill the input buffer when we reach the
    221201         * end of it.
    … …  
    224204
    225205        int yy_buffer_status;
    226 
    227206#define YY_BUFFER_NEW 0
    228207#define YY_BUFFER_NORMAL 1
    … …  
    234213         *
    235214         * When we actually see the EOF, we change the status to "new"
    236          * (via zconfrestart()), so that the user can continue scanning by
    237          * just pointing zconfin at a new input file.
     215         * (via yyrestart()), so that the user can continue scanning by
     216         * just pointing yyin at a new input file.
    238217         */
    239218#define YY_BUFFER_EOF_PENDING 2
    240 
    241219        };
    242 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
    243 
    244 /* Stack of input buffers. */
    245 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
    246 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
    247 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
     220
     221static YY_BUFFER_STATE yy_current_buffer = 0;
    248222
    249223/* We provide macros for accessing buffer states in case in the
    250224 * future we want to put the buffer states in a more general
    251225 * "scanner state".
    252  *
    253  * Returns the top of the stack, or NULL.
    254226 */
    255 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
    256                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
    257                           : NULL)
    258 
    259 /* Same as previous macro, but useful when we know that the buffer stack is not
    260  * NULL or when we need an lvalue. For internal use only.
    261  */
    262 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
    263 
    264 /* yy_hold_char holds the character lost when zconftext is formed. */
     227#define YY_CURRENT_BUFFER yy_current_buffer
     228
     229
     230/* yy_hold_char holds the character lost when yytext is formed. */
    265231static char yy_hold_char;
     232
    266233static int yy_n_chars;          /* number of characters read into yy_ch_buf */
    267 int zconfleng;
     234
     235
     236int yyleng;
    268237
    269238/* Points to current character in buffer. */
    … …  
    272241static int yy_start = 0;        /* start state number */
    273242
    274 /* Flag which is used to allow zconfwrap()'s to do buffer switches
    275  * instead of setting up a fresh zconfin.  A bit of a hack ...
     243/* Flag which is used to allow yywrap()'s to do buffer switches
     244 * instead of setting up a fresh yyin.  A bit of a hack ...
    276245 */
    277246static int yy_did_buffer_switch_on_eof;
    278247
    279 void zconfrestart (FILE *input_file  );
    280 void zconf_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
    281 YY_BUFFER_STATE zconf_create_buffer (FILE *file,int size  );
    282 void zconf_delete_buffer (YY_BUFFER_STATE b  );
    283 void zconf_flush_buffer (YY_BUFFER_STATE b  );
    284 void zconfpush_buffer_state (YY_BUFFER_STATE new_buffer  );
    285 void zconfpop_buffer_state (void );
    286 
    287 static void zconfensure_buffer_stack (void );
    288 static void zconf_load_buffer_state (void );
    289 static void zconf_init_buffer (YY_BUFFER_STATE b,FILE *file  );
    290 
    291 #define YY_FLUSH_BUFFER zconf_flush_buffer(YY_CURRENT_BUFFER )
    292 
    293 YY_BUFFER_STATE zconf_scan_buffer (char *base,yy_size_t size  );
    294 YY_BUFFER_STATE zconf_scan_string (yyconst char *yy_str  );
    295 YY_BUFFER_STATE zconf_scan_bytes (yyconst char *bytes,int len  );
    296 
    297 void *zconfalloc (yy_size_t  );
    298 void *zconfrealloc (void *,yy_size_t  );
    299 void zconffree (void *  );
    300 
    301 #define yy_new_buffer zconf_create_buffer
     248void yyrestart YY_PROTO(( FILE *input_file ));
     249
     250void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
     251void yy_load_buffer_state YY_PROTO(( void ));
     252YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
     253void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
     254void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
     255void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
     256#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
     257
     258YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
     259YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
     260YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
     261
     262static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
     263static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
     264static void yy_flex_free YY_PROTO(( void * ));
     265
     266#define yy_new_buffer yy_create_buffer
    302267
    303268#define yy_set_interactive(is_interactive) \
    304269        { \
    305         if ( ! YY_CURRENT_BUFFER ){ \
    306         zconfensure_buffer_stack (); \
    307                 YY_CURRENT_BUFFER_LVALUE =    \
    308             zconf_create_buffer(zconfin,YY_BUF_SIZE ); \
    309         } \
    310         YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
     270        if ( ! yy_current_buffer ) \
     271                yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
     272        yy_current_buffer->yy_is_interactive = is_interactive; \
    311273        }
    312274
    313275#define yy_set_bol(at_bol) \
    314276        { \
    315         if ( ! YY_CURRENT_BUFFER ){\
    316         zconfensure_buffer_stack (); \
    317                 YY_CURRENT_BUFFER_LVALUE =    \
    318             zconf_create_buffer(zconfin,YY_BUF_SIZE ); \
    319         } \
    320         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
    321         }
    322 
    323 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
    324 
    325 /* Begin user sect3 */
    326 
    327 #define zconfwrap(n) 1
     277        if ( ! yy_current_buffer ) \
     278                yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
     279        yy_current_buffer->yy_at_bol = at_bol; \
     280        }
     281
     282#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
     283
     284
     285#define yywrap() 1
    328286#define YY_SKIP_YYWRAP
    329 
    330287typedef unsigned char YY_CHAR;
    331 
    332 FILE *zconfin = (FILE *) 0, *zconfout = (FILE *) 0;
    333 
     288FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
    334289typedef int yy_state_type;
    335 
    336 extern int zconflineno;
    337 
    338 int zconflineno = 1;
    339 
    340 extern char *zconftext;
    341 #define yytext_ptr zconftext
    342 static yyconst flex_int16_t yy_nxt[][38] =
     290extern char *yytext;
     291#define yytext_ptr yytext
     292static yyconst short yy_nxt[][38] =
    343293    {
    344294    {
    … …  
    19051855    } ;
    19061856
    1907 static yy_state_type yy_get_previous_state (void );
    1908 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
    1909 static int yy_get_next_buffer (void );
    1910 static void yy_fatal_error (yyconst char msg[]  );
     1857
     1858static yy_state_type yy_get_previous_state YY_PROTO(( void ));
     1859static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
     1860static int yy_get_next_buffer YY_PROTO(( void ));
     1861static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
    19111862
    19121863/* Done after the current pattern has been matched and before the
    1913  * corresponding action - sets up zconftext.
     1864 * corresponding action - sets up yytext.
    19141865 */
    19151866#define YY_DO_BEFORE_ACTION \
    1916         (yytext_ptr) = yy_bp; \
    1917         zconfleng = (size_t) (yy_cp - yy_bp); \
    1918         (yy_hold_char) = *yy_cp; \
     1867        yytext_ptr = yy_bp; \
     1868        yyleng = (int) (yy_cp - yy_bp); \
     1869        yy_hold_char = *yy_cp; \
    19191870        *yy_cp = '\0'; \
    1920         (yy_c_buf_p) = yy_cp;
     1871        yy_c_buf_p = yy_cp;
    19211872
    19221873#define YY_NUM_RULES 64
    19231874#define YY_END_OF_BUFFER 65
    1924 /* This struct is not used in this scanner,
    1925    but its presence is necessary. */
    1926 struct yy_trans_info
    1927         {
    1928         flex_int32_t yy_verify;
    1929         flex_int32_t yy_nxt;
    1930         };
    1931 static yyconst flex_int16_t yy_accept[211] =
     1875static yyconst short int yy_accept[211] =
    19321876    {   0,
    19331877        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    … …  
    19561900    } ;
    19571901
    1958 static yyconst flex_int32_t yy_ec[256] =
     1902static yyconst int yy_ec[256] =
    19591903    {   0,
    19601904        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
    … …  
    19881932    } ;
    19891933
    1990 extern int zconf_flex_debug;
    1991 int zconf_flex_debug = 0;
    1992 
    19931934/* The intent behind this definition is that it'll catch
    19941935 * any uses of REJECT which flex missed.
    … …  
    19981939#define YY_MORE_ADJ 0
    19991940#define YY_RESTORE_YY_MORE_OFFSET
    2000 char *zconftext;
    2001 
     1941char *yytext;
     1942#line 1 "zconf.l"
     1943#define INITIAL 0
     1944#define YY_NEVER_INTERACTIVE 1
     1945#define COMMAND 1
     1946#define HELP 2
     1947#define STRING 3
     1948#define PARAM 4
     1949
     1950#line 5 "zconf.l"
    20021951/*
    20031952 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
    … …  
    20101959#include <string.h>
    20111960#include <unistd.h>
     1961#include <glob.h>
    20121962
    20131963#define LKC_DIRECT_LINK
    … …  
    20612011        text[size] = 0;
    20622012}
    2063 
    2064 #define INITIAL 0
    2065 #define COMMAND 1
    2066 #define HELP 2
    2067 #define STRING 3
    2068 #define PARAM 4
    2069 
    2070 /* Special case for "unistd.h", since it is non-ANSI. We include it way
    2071  * down here because we want the user's section 1 to have been scanned first.
    2072  * The user has a chance to override it with an option.
    2073  */
    2074 #include <unistd.h>
    2075 
    2076 #ifndef YY_EXTRA_TYPE
    2077 #define YY_EXTRA_TYPE void *
    2078 #endif
     2013#line 2014 "lex.zconf.c"
    20792014
    20802015/* Macros after this point can all be overridden by user definitions in
    … …  
    20842019#ifndef YY_SKIP_YYWRAP
    20852020#ifdef __cplusplus
    2086 extern "C" int zconfwrap (void );
     2021extern "C" int yywrap YY_PROTO(( void ));
    20872022#else
    2088 extern int zconfwrap (void );
    2089 #endif
    2090 #endif
    2091 
    2092     static void yyunput (int c,char *buf_ptr  );
     2023extern int yywrap YY_PROTO(( void ));
     2024#endif
     2025#endif
     2026
     2027#ifndef YY_NO_UNPUT
     2028static void yyunput YY_PROTO(( int c, char *buf_ptr ));
     2029#endif
    20932030
    20942031#ifndef yytext_ptr
    2095 static void yy_flex_strncpy (char *,yyconst char *,int );
     2032static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
    20962033#endif
    20972034
    20982035#ifdef YY_NEED_STRLEN
    2099 static int yy_flex_strlen (yyconst char * );
     2036static int yy_flex_strlen YY_PROTO(( yyconst char * ));
    21002037#endif
    21012038
    21022039#ifndef YY_NO_INPUT
    2103 
    21042040#ifdef __cplusplus
    2105 static int yyinput (void );
     2041static int yyinput YY_PROTO(( void ));
    21062042#else
    2107 static int input (void );
    2108 #endif
    2109 
     2043static int input YY_PROTO(( void ));
     2044#endif
     2045#endif
     2046
     2047#if YY_STACK_USED
     2048static int yy_start_stack_ptr = 0;
     2049static int yy_start_stack_depth = 0;
     2050static int *yy_start_stack = 0;
     2051#ifndef YY_NO_PUSH_STATE
     2052static void yy_push_state YY_PROTO(( int new_state ));
     2053#endif
     2054#ifndef YY_NO_POP_STATE
     2055static void yy_pop_state YY_PROTO(( void ));
     2056#endif
     2057#ifndef YY_NO_TOP_STATE
     2058static int yy_top_state YY_PROTO(( void ));
     2059#endif
     2060
     2061#else
     2062#define YY_NO_PUSH_STATE 1
     2063#define YY_NO_POP_STATE 1
     2064#define YY_NO_TOP_STATE 1
     2065#endif
     2066
     2067#ifdef YY_MALLOC_DECL
     2068YY_MALLOC_DECL
     2069#else
     2070#ifdef __STDC__
     2071#ifndef __cplusplus
     2072#include <stdlib.h>
     2073#endif
     2074#else
     2075/* Just try to get by without declaring the routines.  This will fail
     2076 * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
     2077 * or sizeof(void*) != sizeof(int).
     2078 */
     2079#endif
    21102080#endif
    21112081
    … …  
    21162086
    21172087/* Copy whatever the last rule matched to the standard output. */
     2088
    21182089#ifndef ECHO
    21192090/* This used to be an fputs(), but since the string might contain NUL's,
    21202091 * we now use fwrite().
    21212092 */
    2122 #define ECHO (void) fwrite( zconftext, zconfleng, 1, zconfout )
     2093#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
    21232094#endif
    21242095
    … …  
    21282099#ifndef YY_INPUT
    21292100#define YY_INPUT(buf,result,max_size) \
    2130         errno=0; \
    2131         while ( (result = read( fileno(zconfin), (char *) buf, max_size )) < 0 ) \
    2132         { \
    2133                 if( errno != EINTR) \
    2134                 { \
    2135                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
    2136                         break; \
    2137                 } \
    2138                 errno=0; \
    2139                 clearerr(zconfin); \
    2140         }\
    2141 \
    2142 
     2101        if ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \
     2102                YY_FATAL_ERROR( "input in flex scanner failed" );
    21432103#endif
    21442104
    … …  
    21612121#endif
    21622122
    2163 /* end tables serialization structures and prototypes */
    2164 
    21652123/* Default declaration of generated scanner - a define so the user can
    21662124 * easily add parameters.
    21672125 */
    21682126#ifndef YY_DECL
    2169 #define YY_DECL_IS_OURS 1
    2170 
    2171 extern int zconflex (void);
    2172 
    2173 #define YY_DECL int zconflex (void)
    2174 #endif /* !YY_DECL */
    2175 
    2176 /* Code executed at the beginning of each rule, after zconftext and zconfleng
     2127#define YY_DECL int yylex YY_PROTO(( void ))
     2128#endif
     2129
     2130/* Code executed at the beginning of each rule, after yytext and yyleng
    21772131 * have been set up.
    21782132 */
    … …  
    21892143        YY_USER_ACTION
    21902144
    2191 /** The main scanner function which does all the work.
    2192  */
    21932145YY_DECL
    2194 {
     2146        {
    21952147        register yy_state_type yy_current_state;
    21962148        register char *yy_cp, *yy_bp;
    21972149        register int yy_act;
    21982150
     2151#line 72 "zconf.l"
     2152
    21992153        int str = 0;
    22002154        int ts, i;
    22012155
    2202         if ( (yy_init) )
     2156#line 2157 "lex.zconf.c"
     2157
     2158        if ( yy_init )
    22032159                {
    2204                 (yy_init) = 0;
     2160                yy_init = 0;
    22052161
    22062162#ifdef YY_USER_INIT
    … …  
    22082164#endif
    22092165
    2210                 if ( ! (yy_start) )
    2211                         (yy_start) = 1; /* first start state */
    2212 
    2213                 if ( ! zconfin )
    2214                         zconfin = stdin;
    2215 
    2216                 if ( ! zconfout )
    2217                         zconfout = stdout;
    2218 
    2219                 if ( ! YY_CURRENT_BUFFER ) {
    2220                         zconfensure_buffer_stack ();
    2221                         YY_CURRENT_BUFFER_LVALUE =
    2222                                 zconf_create_buffer(zconfin,YY_BUF_SIZE );
    2223                 }
    2224 
    2225                 zconf_load_buffer_state( );
     2166                if ( ! yy_start )
     2167                        yy_start = 1;   /* first start state */
     2168
     2169                if ( ! yyin )
     2170                        yyin = stdin;
     2171
     2172                if ( ! yyout )
     2173                        yyout = stdout;
     2174
     2175                if ( ! yy_current_buffer )
     2176                        yy_current_buffer =
     2177                                yy_create_buffer( yyin, YY_BUF_SIZE );
     2178
     2179                yy_load_buffer_state();
    22262180                }
    22272181
    22282182        while ( 1 )             /* loops until end-of-file is reached */
    22292183                {
    2230                 yy_cp = (yy_c_buf_p);
    2231 
    2232                 /* Support of zconftext. */
    2233                 *yy_cp = (yy_hold_char);
     2184                yy_cp = yy_c_buf_p;
     2185
     2186                /* Support of yytext. */
     2187                *yy_cp = yy_hold_char;
    22342188
    22352189                /* yy_bp points to the position in yy_ch_buf of the start of
    … …  
    22382192                yy_bp = yy_cp;
    22392193
    2240                 yy_current_state = (yy_start);
     2194                yy_current_state = yy_start;
    22412195yy_match:
    2242                 while ( (yy_current_state = yy_nxt[yy_current_state][ yy_ec[YY_SC_TO_UI(*yy_cp)]  ]) > 0 )
     2196                while ( (yy_current_state = yy_nxt[yy_current_state][yy_ec[YY_SC_TO_UI(*yy_cp)]]) > 0 )
    22432197                        ++yy_cp;
    22442198
    … …  
    22502204                YY_DO_BEFORE_ACTION;
    22512205
     2206
    22522207do_action:      /* This label is used only to access EOF actions. */
     2208
    22532209
    22542210                switch ( yy_act )
    22552211        { /* beginning of action switch */
    22562212case 1:
    2257 /* rule 1 can match eol */
    2258 YY_RULE_SETUP
     2213YY_RULE_SETUP
     2214#line 76 "zconf.l"
    22592215current_file->lineno++;
    22602216        YY_BREAK
    22612217case 2:
    22622218YY_RULE_SETUP
     2219#line 77 "zconf.l"
    22632220
    22642221        YY_BREAK
    22652222case 3:
    2266 /* rule 3 can match eol */
    2267 YY_RULE_SETUP
     2223YY_RULE_SETUP
     2224#line 79 "zconf.l"
    22682225current_file->lineno++; return T_EOL;
    22692226        YY_BREAK
    22702227case 4:
    22712228YY_RULE_SETUP
     2229#line 81 "zconf.l"
    22722230{
    22732231        BEGIN(COMMAND);
    … …  
    22762234case 5:
    22772235YY_RULE_SETUP
     2236#line 85 "zconf.l"
    22782237{
    2279         unput(zconftext[0]);
     2238        unput(yytext[0]);
    22802239        BEGIN(COMMAND);
    22812240}
    … …  
    22842243case 6:
    22852244YY_RULE_SETUP
     2245#line 92 "zconf.l"
    22862246BEGIN(PARAM); return T_MAINMENU;
    22872247        YY_BREAK
    22882248case 7:
    22892249YY_RULE_SETUP
     2250#line 93 "zconf.l"
    22902251BEGIN(PARAM); return T_MENU;
    22912252        YY_BREAK
    22922253case 8:
    22932254YY_RULE_SETUP
     2255#line 94 "zconf.l"
    22942256BEGIN(PARAM); return T_ENDMENU;
    22952257        YY_BREAK
    22962258case 9:
    22972259YY_RULE_SETUP
     2260#line 95 "zconf.l"
    22982261BEGIN(PARAM); return T_SOURCE;
    22992262        YY_BREAK
    23002263case 10:
    23012264YY_RULE_SETUP
     2265#line 96 "zconf.l"
    23022266BEGIN(PARAM); return T_CHOICE;
    23032267        YY_BREAK
    23042268case 11:
    23052269YY_RULE_SETUP
     2270#line 97 "zconf.l"
    23062271BEGIN(PARAM); return T_ENDCHOICE;
    23072272        YY_BREAK
    23082273case 12:
    23092274YY_RULE_SETUP
     2275#line 98 "zconf.l"
    23102276BEGIN(PARAM); return T_COMMENT;
    23112277        YY_BREAK
    23122278case 13:
    23132279YY_RULE_SETUP
     2280#line 99 "zconf.l"
    23142281BEGIN(PARAM); return T_CONFIG;
    23152282        YY_BREAK
    23162283case 14:
    23172284YY_RULE_SETUP
     2285#line 100 "zconf.l"
    23182286BEGIN(PARAM); return T_MENUCONFIG;
    23192287        YY_BREAK
    23202288case 15:
    23212289YY_RULE_SETUP
     2290#line 101 "zconf.l"
    23222291BEGIN(PARAM); return T_HELP;
    23232292        YY_BREAK
    23242293case 16:
    23252294YY_RULE_SETUP
     2295#line 102 "zconf.l"
    23262296BEGIN(PARAM); return T_IF;
    23272297        YY_BREAK
    23282298case 17:
    23292299YY_RULE_SETUP
     2300#line 103 "zconf.l"
    23302301BEGIN(PARAM); return T_ENDIF;
    23312302        YY_BREAK
    23322303case 18:
    23332304YY_RULE_SETUP
     2305#line 104 "zconf.l"
    23342306BEGIN(PARAM); return T_DEPENDS;
    23352307        YY_BREAK
    23362308case 19:
    23372309YY_RULE_SETUP
     2310#line 105 "zconf.l"
    23382311BEGIN(PARAM); return T_REQUIRES;
    23392312        YY_BREAK
    23402313case 20:
    23412314YY_RULE_SETUP
     2315#line 106 "zconf.l"
    23422316BEGIN(PARAM); return T_OPTIONAL;
    23432317        YY_BREAK
    23442318case 21:
    23452319YY_RULE_SETUP
     2320#line 107 "zconf.l"
    23462321BEGIN(PARAM); return T_DEFAULT;
    23472322        YY_BREAK
    23482323case 22:
    23492324YY_RULE_SETUP
     2325#line 108 "zconf.l"
    23502326BEGIN(PARAM); return T_PROMPT;
    23512327        YY_BREAK
    23522328case 23:
    23532329YY_RULE_SETUP
     2330#line 109 "zconf.l"
    23542331BEGIN(PARAM); return T_TRISTATE;
    23552332        YY_BREAK
    23562333case 24:
    23572334YY_RULE_SETUP
     2335#line 110 "zconf.l"
    23582336BEGIN(PARAM); return T_DEF_TRISTATE;
    23592337        YY_BREAK
    23602338case 25:
    23612339YY_RULE_SETUP
     2340#line 111 "zconf.l"
    23622341BEGIN(PARAM); return T_BOOLEAN;
    23632342        YY_BREAK
    23642343case 26:
    23652344YY_RULE_SETUP
     2345#line 112 "zconf.l"
    23662346BEGIN(PARAM); return T_BOOLEAN;
    23672347        YY_BREAK
    23682348case 27:
    23692349YY_RULE_SETUP
     2350#line 113 "zconf.l"
    23702351BEGIN(PARAM); return T_DEF_BOOLEAN;
    23712352        YY_BREAK
    23722353case 28:
    23732354YY_RULE_SETUP
     2355#line 114 "zconf.l"
    23742356BEGIN(PARAM); return T_DEF_BOOLEAN;
    23752357        YY_BREAK
    23762358case 29:
    23772359YY_RULE_SETUP
     2360#line 115 "zconf.l"
    23782361BEGIN(PARAM); return T_INT;
    23792362        YY_BREAK
    23802363case 30:
    23812364YY_RULE_SETUP
     2365#line 116 "zconf.l"
    23822366BEGIN(PARAM); return T_HEX;
    23832367        YY_BREAK
    23842368case 31:
    23852369YY_RULE_SETUP
     2370#line 117 "zconf.l"
    23862371BEGIN(PARAM); return T_STRING;
    23872372        YY_BREAK
    23882373case 32:
    23892374YY_RULE_SETUP
     2375#line 118 "zconf.l"
    23902376BEGIN(PARAM); return T_SELECT;
    23912377        YY_BREAK
    23922378case 33:
    23932379YY_RULE_SETUP
     2380#line 119 "zconf.l"
    23942381BEGIN(PARAM); return T_SELECT;
    23952382        YY_BREAK
    23962383case 34:
    23972384YY_RULE_SETUP
     2385#line 120 "zconf.l"
    23982386BEGIN(PARAM); return T_RANGE;
    23992387        YY_BREAK
    24002388case 35:
    24012389YY_RULE_SETUP
     2390#line 121 "zconf.l"
    24022391{
    2403                 alloc_string(zconftext, zconfleng);
     2392                alloc_string(yytext, yyleng);
    24042393                zconflval.string = text;
    24052394                return T_WORD;
    … …  
    24082397case 36:
    24092398YY_RULE_SETUP
     2399#line 126 "zconf.l"
    24102400
    24112401        YY_BREAK
    24122402case 37:
    2413 /* rule 37 can match eol */
    2414 YY_RULE_SETUP
     2403YY_RULE_SETUP
     2404#line 127 "zconf.l"
    24152405current_file->lineno++; BEGIN(INITIAL);
    24162406        YY_BREAK
    24172407
     2408
    24182409case 38:
    24192410YY_RULE_SETUP
     2411#line 131 "zconf.l"
    24202412return T_AND;
    24212413        YY_BREAK
    24222414case 39:
    24232415YY_RULE_SETUP
     2416#line 132 "zconf.l"
    24242417return T_OR;
    24252418        YY_BREAK
    24262419case 40:
    24272420YY_RULE_SETUP
     2421#line 133 "zconf.l"
    24282422return T_OPEN_PAREN;
    24292423        YY_BREAK
    24302424case 41:
    24312425YY_RULE_SETUP
     2426#line 134 "zconf.l"
    24322427return T_CLOSE_PAREN;
    24332428        YY_BREAK
    24342429case 42:
    24352430YY_RULE_SETUP
     2431#line 135 "zconf.l"
    24362432return T_NOT;
    24372433        YY_BREAK
    24382434case 43:
    24392435YY_RULE_SETUP
     2436#line 136 "zconf.l"
    24402437return T_EQUAL;
    24412438        YY_BREAK
    24422439case 44:
    24432440YY_RULE_SETUP
     2441#line 137 "zconf.l"
    24442442return T_UNEQUAL;
    24452443        YY_BREAK
    24462444case 45:
    24472445YY_RULE_SETUP
     2446#line 138 "zconf.l"
    24482447return T_IF;
    24492448        YY_BREAK
    24502449case 46:
    24512450YY_RULE_SETUP
     2451#line 139 "zconf.l"
    24522452return T_ON;
    24532453        YY_BREAK
    24542454case 47:
    24552455YY_RULE_SETUP
     2456#line 140 "zconf.l"
    24562457{
    2457                 str = zconftext[0];
     2458                str = yytext[0];
    24582459                new_string();
    24592460                BEGIN(STRING);
    … …  
    24612462        YY_BREAK
    24622463case 48:
    2463 /* rule 48 can match eol */
    2464 YY_RULE_SETUP
     2464YY_RULE_SETUP
     2465#line 145 "zconf.l"
    24652466BEGIN(INITIAL); current_file->lineno++; return T_EOL;
    24662467        YY_BREAK
    24672468case 49:
    24682469YY_RULE_SETUP
     2470#line 146 "zconf.l"
    24692471/* ignore */
    24702472        YY_BREAK
    24712473case 50:
    24722474YY_RULE_SETUP
     2475#line 147 "zconf.l"
    24732476{
    2474                 alloc_string(zconftext, zconfleng);
     2477                alloc_string(yytext, yyleng);
    24752478                zconflval.string = text;
    24762479                return T_WORD;
    … …  
    24792482case 51:
    24802483YY_RULE_SETUP
     2484#line 152 "zconf.l"
    24812485/* comment */
    24822486        YY_BREAK
    24832487case 52:
    2484 /* rule 52 can match eol */
    2485 YY_RULE_SETUP
     2488YY_RULE_SETUP
     2489#line 153 "zconf.l"
    24862490current_file->lineno++;
    24872491        YY_BREAK
    24882492case 53:
    24892493YY_RULE_SETUP
     2494#line 154 "zconf.l"
    24902495
    24912496        YY_BREAK
    24922497case YY_STATE_EOF(PARAM):
     2498#line 155 "zconf.l"
    24932499{
    24942500                BEGIN(INITIAL);
    … …  
    24962502        YY_BREAK
    24972503
     2504
    24982505case 54:
    2499 /* rule 54 can match eol */
    2500 *yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
    2501 (yy_c_buf_p) = yy_cp -= 1;
    2502 YY_DO_BEFORE_ACTION; /* set up zconftext again */
    2503 YY_RULE_SETUP
     2506*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
     2507yy_c_buf_p = yy_cp -= 1;
     2508YY_DO_BEFORE_ACTION; /* set up yytext again */
     2509YY_RULE_SETUP
     2510#line 161 "zconf.l"
    25042511{
    2505                 append_string(zconftext, zconfleng);
     2512                append_string(yytext, yyleng);
    25062513                zconflval.string = text;
    25072514                return T_WORD_QUOTE;
    … …  
    25102517case 55:
    25112518YY_RULE_SETUP
     2519#line 166 "zconf.l"
    25122520{
    2513                 append_string(zconftext, zconfleng);
     2521                append_string(yytext, yyleng);
    25142522        }
    25152523        YY_BREAK
    25162524case 56:
    2517 /* rule 56 can match eol */
    2518 *yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
    2519 (yy_c_buf_p) = yy_cp -= 1;
    2520 YY_DO_BEFORE_ACTION; /* set up zconftext again */
    2521 YY_RULE_SETUP
     2525*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
     2526yy_c_buf_p = yy_cp -= 1;
     2527YY_DO_BEFORE_ACTION; /* set up yytext again */
     2528YY_RULE_SETUP
     2529#line 169 "zconf.l"
    25222530{
    2523                 append_string(zconftext + 1, zconfleng - 1);
     2531                append_string(yytext + 1, yyleng - 1);
    25242532                zconflval.string = text;
    25252533                return T_WORD_QUOTE;
    … …  
    25282536case 57:
    25292537YY_RULE_SETUP
     2538#line 174 "zconf.l"
    25302539{
    2531                 append_string(zconftext + 1, zconfleng - 1);
     2540                append_string(yytext + 1, yyleng - 1);
    25322541        }
    25332542        YY_BREAK
    25342543case 58:
    25352544YY_RULE_SETUP
     2545#line 177 "zconf.l"
    25362546{
    2537                 if (str == zconftext[0]) {
     2547                if (str == yytext[0]) {
    25382548                        BEGIN(PARAM);
    25392549                        zconflval.string = text;
    25402550                        return T_WORD_QUOTE;
    25412551                } else
    2542                         append_string(zconftext, 1);
     2552                        append_string(yytext, 1);
    25432553        }
    25442554        YY_BREAK
    25452555case 59:
    2546 /* rule 59 can match eol */
    2547 YY_RULE_SETUP
     2556YY_RULE_SETUP
     2557#line 185 "zconf.l"
    25482558{
    25492559                printf("%s:%d:warning: multi-line strings not supported\n", zconf_curname(), zconf_lineno());
    … …  
    25542564        YY_BREAK
    25552565case YY_STATE_EOF(STRING):
     2566#line 191 "zconf.l"
    25562567{
    25572568                BEGIN(INITIAL);
    … …  
    25592570        YY_BREAK
    25602571
     2572
    25612573case 60:
    25622574YY_RULE_SETUP
     2575#line 197 "zconf.l"
    25632576{
    25642577                ts = 0;
    2565                 for (i = 0; i < zconfleng; i++) {
    2566                         if (zconftext[i] == '\t')
     2578                for (i = 0; i < yyleng; i++) {
     2579                        if (yytext[i] == '\t')
    25672580                                ts = (ts & ~7) + 8;
    25682581                        else
    … …  
    25852598        YY_BREAK
    25862599case 61:
    2587 /* rule 61 can match eol */
    2588 *yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
    2589 (yy_c_buf_p) = yy_cp -= 1;
    2590 YY_DO_BEFORE_ACTION; /* set up zconftext again */
    2591 YY_RULE_SETUP
     2600*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
     2601yy_c_buf_p = yy_cp -= 1;
     2602YY_DO_BEFORE_ACTION; /* set up yytext again */
     2603YY_RULE_SETUP
     2604#line 219 "zconf.l"
    25922605{
    25932606                current_file->lineno++;
    … …  
    25972610        YY_BREAK
    25982611case 62:
    2599 /* rule 62 can match eol */
    2600 YY_RULE_SETUP
     2612YY_RULE_SETUP
     2613#line 224 "zconf.l"
    26012614{
    26022615                current_file->lineno++;
    … …  
    26062619case 63:
    26072620YY_RULE_SETUP
     2621#line 228 "zconf.l"
    26082622{
    2609                 append_string(zconftext, zconfleng);
     2623                append_string(yytext, yyleng);
    26102624                if (!first_ts)
    26112625                        first_ts = last_ts;
    … …  
    26132627        YY_BREAK
    26142628case YY_STATE_EOF(HELP):
     2629#line 233 "zconf.l"
    26152630{
    26162631                zconf_endhelp();
    … …  
    26212636case YY_STATE_EOF(INITIAL):
    26222637case YY_STATE_EOF(COMMAND):
     2638#line 239 "zconf.l"
    26232639{
    26242640        if (current_buf) {
    … …  
    26262642                return T_EOF;
    26272643        }
    2628         fclose(zconfin);
     2644        fclose(yyin);
    26292645        yyterminate();
    26302646}
    … …  
    26322648case 64:
    26332649YY_RULE_SETUP
     2650#line 248 "zconf.l"
    26342651YY_FATAL_ERROR( "flex scanner jammed" );
    26352652        YY_BREAK
     2653#line 2654 "lex.zconf.c"
    26362654
    26372655        case YY_END_OF_BUFFER:
    26382656                {
    26392657                /* Amount of text matched not including the EOB char. */
    2640                 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
     2658                int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
    26412659
    26422660                /* Undo the effects of YY_DO_BEFORE_ACTION. */
    2643                 *yy_cp = (yy_hold_char);
     2661                *yy_cp = yy_hold_char;
    26442662                YY_RESTORE_YY_MORE_OFFSET
    26452663
    2646                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
     2664                if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
    26472665                        {
    26482666                        /* We're scanning a new file or input source.  It's
    26492667                         * possible that this happened because the user
    2650                          * just pointed zconfin at a new source and called
    2651                          * zconflex().  If so, then we have to assure
    2652                          * consistency between YY_CURRENT_BUFFER and our
     2668                         * just pointed yyin at a new source and called
     2669                         * yylex().  If so, then we have to assure
     2670                         * consistency between yy_current_buffer and our
    26532671                         * globals.  Here is the right place to do so, because
    26542672                         * this is the first action (other than possibly a
    26552673                         * back-up) that will match for the new input source.
    26562674                         */
    2657                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
    2658                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = zconfin;
    2659                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
     2675                        yy_n_chars = yy_current_buffer->yy_n_chars;
     2676                        yy_current_buffer->yy_input_file = yyin;
     2677                        yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
    26602678                        }
    26612679
    … …  
    26672685                 * in input().
    26682686                 */
    2669                 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
     2687                if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
    26702688                        { /* This was really a NUL. */
    26712689                        yy_state_type yy_next_state;
    26722690
    2673                         (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
    2674 
    2675                         yy_current_state = yy_get_previous_state(  );
     2691                        yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
     2692
     2693                        yy_current_state = yy_get_previous_state();
    26762694
    26772695                        /* Okay, we're now positioned to make the NUL
    … …  
    26862704                        yy_next_state = yy_try_NUL_trans( yy_current_state );
    26872705
    2688                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
     2706                        yy_bp = yytext_ptr + YY_MORE_ADJ;
    26892707
    26902708                        if ( yy_next_state )
    26912709                                {
    26922710                                /* Consume the NUL. */
    2693                                 yy_cp = ++(yy_c_buf_p);
     2711                                yy_cp = ++yy_c_buf_p;
    26942712                                yy_current_state = yy_next_state;
    26952713                                goto yy_match;
    … …  
    26982716                        else
    26992717                                {
    2700                                 yy_cp = (yy_c_buf_p);
     2718                                yy_cp = yy_c_buf_p;
    27012719                                goto yy_find_action;
    27022720                                }
    27032721                        }
    27042722
    2705                 else switch ( yy_get_next_buffer(  ) )
     2723                else switch ( yy_get_next_buffer() )
    27062724                        {
    27072725                        case EOB_ACT_END_OF_FILE:
    27082726                                {
    2709                                 (yy_did_buffer_switch_on_eof) = 0;
    2710 
    2711                                 if ( zconfwrap( ) )
     2727                                yy_did_buffer_switch_on_eof = 0;
     2728
     2729                                if ( yywrap() )
    27122730                                        {
    27132731                                        /* Note: because we've taken care in
    27142732                                         * yy_get_next_buffer() to have set up
    2715                                          * zconftext, we can now set up
     2733                                         * yytext, we can now set up
    27162734                                         * yy_c_buf_p so that if some total
    27172735                                         * hoser (like flex itself) wants to
    … …  
    27202738                                         * YY_NULL will get returned.
    27212739                                         */
    2722                                         (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
     2740                                        yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
    27232741
    27242742                                        yy_act = YY_STATE_EOF(YY_START);
    … …  
    27282746                                else
    27292747                                        {
    2730                                         if ( ! (yy_did_buffer_switch_on_eof) )
     2748                                        if ( ! yy_did_buffer_switch_on_eof )
    27312749                                                YY_NEW_FILE;
    27322750                                        }
    … …  
    27352753
    27362754                        case EOB_ACT_CONTINUE_SCAN:
    2737                                 (yy_c_buf_p) =
    2738                                         (yytext_ptr) + yy_amount_of_matched_text;
    2739 
    2740                                 yy_current_state = yy_get_previous_state(  );
    2741 
    2742                                 yy_cp = (yy_c_buf_p);
    2743                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
     2755                                yy_c_buf_p =
     2756                                        yytext_ptr + yy_amount_of_matched_text;
     2757
     2758                                yy_current_state = yy_get_previous_state();
     2759
     2760                                yy_cp = yy_c_buf_p;
     2761                                yy_bp = yytext_ptr + YY_MORE_ADJ;
    27442762                                goto yy_match;
    27452763
    27462764                        case EOB_ACT_LAST_MATCH:
    2747                                 (yy_c_buf_p) =
    2748                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
    2749 
    2750                                 yy_current_state = yy_get_previous_state(  );
    2751 
    2752                                 yy_cp = (yy_c_buf_p);
    2753                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
     2765                                yy_c_buf_p =
     2766                                &yy_current_buffer->yy_ch_buf[yy_n_chars];
     2767
     2768                                yy_current_state = yy_get_previous_state();
     2769
     2770                                yy_cp = yy_c_buf_p;
     2771                                yy_bp = yytext_ptr + YY_MORE_ADJ;
    27542772                                goto yy_find_action;
    27552773                        }
    … …  
    27622780        } /* end of action switch */
    27632781                } /* end of scanning one token */
    2764 } /* end of zconflex */
     2782        } /* end of yylex */
     2783
    27652784
    27662785/* yy_get_next_buffer - try to read in a new buffer
    … …  
    27712790 *      EOB_ACT_END_OF_FILE - end of file
    27722791 */
    2773 static int yy_get_next_buffer (void)
    2774 {
    2775         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
    2776         register char *source = (yytext_ptr);
     2792
     2793static int yy_get_next_buffer()
     2794        {
     2795        register char *dest = yy_current_buffer->yy_ch_buf;
     2796        register char *source = yytext_ptr;
    27772797        register int number_to_move, i;
    27782798        int ret_val;
    27792799
    2780         if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
     2800        if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
    27812801                YY_FATAL_ERROR(
    27822802                "fatal flex scanner internal error--end of buffer missed" );
    27832803
    2784         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
     2804        if ( yy_current_buffer->yy_fill_buffer == 0 )
    27852805                { /* Don't try to fill the buffer, so this is an EOF. */
    2786                 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
     2806                if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
    27872807                        {
    27882808                        /* We matched a single character, the EOB, so
    … …  
    28042824
    28052825        /* First move last chars to start of buffer. */
    2806         number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
     2826        number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
    28072827
    28082828        for ( i = 0; i < number_to_move; ++i )
    28092829                *(dest++) = *(source++);
    28102830
    2811         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
     2831        if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
    28122832                /* don't do the read, it's not guaranteed to return an EOF,
    28132833                 * just force an EOF
    28142834                 */
    2815                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
     2835                yy_current_buffer->yy_n_chars = yy_n_chars = 0;
    28162836
    28172837        else
    28182838                {
    2819                         size_t num_to_read =
    2820                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
     2839                int num_to_read =
     2840                        yy_current_buffer->yy_buf_size - number_to_move - 1;
    28212841
    28222842                while ( num_to_read <= 0 )
    28232843                        { /* Not enough room in the buffer - grow it. */
     2844#ifdef YY_USES_REJECT
     2845                        YY_FATAL_ERROR(
     2846"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
     2847#else
    28242848
    28252849                        /* just a shorter name for the current buffer */
    2826                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
     2850                        YY_BUFFER_STATE b = yy_current_buffer;
    28272851
    28282852                        int yy_c_buf_p_offset =
    2829                                 (int) ((yy_c_buf_p) - b->yy_ch_buf);
     2853                                (int) (yy_c_buf_p - b->yy_ch_buf);
    28302854
    28312855                        if ( b->yy_is_our_buffer )
    … …  
    28402864                                b->yy_ch_buf = (char *)
    28412865                                        /* Include room in for 2 EOB chars. */
    2842                                         zconfrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
     2866                                        yy_flex_realloc( (void *) b->yy_ch_buf,
     2867                                                         b->yy_buf_size + 2 );
    28432868                                }
    28442869                        else
    … …  
    28502875                                "fatal error - scanner input buffer overflow" );
    28512876
    2852                         (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
    2853 
    2854                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
     2877                        yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
     2878
     2879                        num_to_read = yy_current_buffer->yy_buf_size -
    28552880                                                number_to_move - 1;
    2856 
     2881#endif
    28572882                        }
    28582883
    … …  
    28612886
    28622887                /* Read in more data. */
    2863                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
    2864                         (yy_n_chars), num_to_read );
    2865 
    2866                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
     2888                YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
     2889                        yy_n_chars, num_to_read );
     2890
     2891                yy_current_buffer->yy_n_chars = yy_n_chars;
    28672892                }
    28682893
    2869         if ( (yy_n_chars) == 0 )
     2894        if ( yy_n_chars == 0 )
    28702895                {
    28712896                if ( number_to_move == YY_MORE_ADJ )
    28722897                        {
    28732898                        ret_val = EOB_ACT_END_OF_FILE;
    2874                         zconfrestart(zconfin );
     2899                        yyrestart( yyin );
    28752900                        }
    28762901
    … …  
    28782903                        {
    28792904                        ret_val = EOB_ACT_LAST_MATCH;
    2880                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
     2905                        yy_current_buffer->yy_buffer_status =
    28812906                                YY_BUFFER_EOF_PENDING;
    28822907                        }
    … …  
    28862911                ret_val = EOB_ACT_CONTINUE_SCAN;
    28872912
    2888         (yy_n_chars) += number_to_move;
    2889         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
    2890         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
    2891 
    2892         (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
     2913        yy_n_chars += number_to_move;
     2914        yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
     2915        yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
     2916
     2917        yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
    28932918
    28942919        return ret_val;
    2895 }
     2920        }
     2921
    28962922
    28972923/* yy_get_previous_state - get the state just before the EOB char was reached */
    28982924
    2899     static yy_state_type yy_get_previous_state (void)
    2900 {
     2925static yy_state_type yy_get_previous_state()
     2926        {
    29012927        register yy_state_type yy_current_state;
    29022928        register char *yy_cp;
    29032929
    2904         yy_current_state = (yy_start);
    2905 
    2906         for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
     2930        yy_current_state = yy_start;
     2931
     2932        for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
    29072933                {
    29082934                yy_current_state = yy_nxt[yy_current_state][(*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1)];
    … …  
    29102936
    29112937        return yy_current_state;
    2912 }
     2938        }
     2939
    29132940
    29142941/* yy_try_NUL_trans - try to make a transition on the NUL character
    … …  
    29172944 *      next_state = yy_try_NUL_trans( current_state );
    29182945 */
    2919     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
    2920 {
     2946
     2947#ifdef YY_USE_PROTOS
     2948static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
     2949#else
     2950static yy_state_type yy_try_NUL_trans( yy_current_state )
     2951yy_state_type yy_current_state;
     2952#endif
     2953        {
    29212954        register int yy_is_jam;
    29222955
    … …  
    29252958
    29262959        return yy_is_jam ? 0 : yy_current_state;
    2927 }
    2928 
    2929     static void yyunput (int c, register char * yy_bp )
    2930 {
    2931         register char *yy_cp;
    2932 
    2933     yy_cp = (yy_c_buf_p);
    2934 
    2935         /* undo effects of setting up zconftext */
    2936         *yy_cp = (yy_hold_char);
    2937 
    2938         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
     2960        }
     2961
     2962
     2963#ifndef YY_NO_UNPUT
     2964#ifdef YY_USE_PROTOS
     2965static void yyunput( int c, register char *yy_bp )
     2966#else
     2967static void yyunput( c, yy_bp )
     2968int c;
     2969register char *yy_bp;
     2970#endif
     2971        {
     2972        register char *yy_cp = yy_c_buf_p;
     2973
     2974        /* undo effects of setting up yytext */
     2975        *yy_cp = yy_hold_char;
     2976
     2977        if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
    29392978                { /* need to shift things up to make room */
    29402979                /* +2 for EOB chars. */
    2941                 register int number_to_move = (yy_n_chars) + 2;
    2942                 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
    2943                                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
     2980                register int number_to_move = yy_n_chars + 2;
     2981                register char *dest = &yy_current_buffer->yy_ch_buf[
     2982                                        yy_current_buffer->yy_buf_size + 2];
    29442983                register char *source =
    2945                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
    2946 
    2947                 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
     2984                                &yy_current_buffer->yy_ch_buf[number_to_move];
     2985
     2986                while ( source > yy_current_buffer->yy_ch_buf )
    29482987                        *--dest = *--source;
    29492988
    29502989                yy_cp += (int) (dest - source);
    29512990                yy_bp += (int) (dest - source);
    2952                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
    2953                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
    2954 
    2955                 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
     2991                yy_current_buffer->yy_n_chars =
     2992                        yy_n_chars = yy_current_buffer->yy_buf_size;
     2993
     2994                if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
    29562995                        YY_FATAL_ERROR( "flex scanner push-back overflow" );
    29572996                }
    … …  
    29592998        *--yy_cp = (char) c;
    29602999
    2961         (yytext_ptr) = yy_bp;
    2962         (yy_hold_char) = *yy_cp;
    2963         (yy_c_buf_p) = yy_cp;
    2964 }
    2965 
    2966 #ifndef YY_NO_INPUT
     3000
     3001        yytext_ptr = yy_bp;
     3002        yy_hold_char = *yy_cp;
     3003        yy_c_buf_p = yy_cp;
     3004        }
     3005#endif  /* ifndef YY_NO_UNPUT */
     3006
     3007
    29673008#ifdef __cplusplus
    2968     static int yyinput (void)
     3009static int yyinput()
    29693010#else
    2970     static int input  (void)
    2971 #endif
    2972 
    2973 {
     3011static int input()
     3012#endif
     3013        {
    29743014        int c;
    29753015
    2976         *(yy_c_buf_p) = (yy_hold_char);
    2977 
    2978         if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
     3016        *yy_c_buf_p = yy_hold_char;
     3017
     3018        if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
    29793019                {
    29803020                /* yy_c_buf_p now points to the character we want to return.
    … …  
    29823022                 * valid NUL; if not, then we've hit the end of the buffer.
    29833023                 */
    2984                 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
     3024                if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
    29853025                        /* This was really a NUL. */
    2986                         *(yy_c_buf_p) = '\0';
     3026                        *yy_c_buf_p = '\0';
    29873027
    29883028                else
    29893029                        { /* need more input */
    2990                         int offset = (yy_c_buf_p) - (yytext_ptr);
    2991                         ++(yy_c_buf_p);
    2992 
    2993                         switch ( yy_get_next_buffer(  ) )
     3030                        int offset = yy_c_buf_p - yytext_ptr;
     3031                        ++yy_c_buf_p;
     3032
     3033                        switch ( yy_get_next_buffer() )
    29943034                                {
    29953035                                case EOB_ACT_LAST_MATCH:
    … …  
    30053045
    30063046                                        /* Reset buffer status. */
    3007                                         zconfrestart(zconfin );
    3008 
    3009                                         /*FALLTHROUGH*/
     3047                                        yyrestart( yyin );
     3048
     3049                                        /* fall through */
    30103050
    30113051                                case EOB_ACT_END_OF_FILE:
    30123052                                        {
    3013                                         if ( zconfwrap( ) )
     3053                                        if ( yywrap() )
    30143054                                                return EOF;
    30153055
    3016                                         if ( ! (yy_did_buffer_switch_on_eof) )
     3056                                        if ( ! yy_did_buffer_switch_on_eof )
    30173057                                                YY_NEW_FILE;
    30183058#ifdef __cplusplus
    … …  
    30243064
    30253065                                case EOB_ACT_CONTINUE_SCAN:
    3026                                         (yy_c_buf_p) = (yytext_ptr) + offset;
     3066                                        yy_c_buf_p = yytext_ptr + offset;
    30273067                                        break;
    30283068                                }
    … …  
    30303070                }
    30313071
    3032         c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
    3033         *(yy_c_buf_p) = '\0';   /* preserve zconftext */
    3034         (yy_hold_char) = *++(yy_c_buf_p);
     3072        c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
     3073        *yy_c_buf_p = '\0';     /* preserve yytext */
     3074        yy_hold_char = *++yy_c_buf_p;
     3075
    30353076
    30363077        return c;
    3037 }
    3038 #endif  /* ifndef YY_NO_INPUT */
    3039 
    3040 /** Immediately switch to a different input stream.
    3041  * @param input_file A readable stream.
    3042  *
    3043  * @note This function does not reset the start condition to @c INITIAL .
    3044  */
    3045     void zconfrestart  (FILE * input_file )
    3046 {
    3047 
    3048         if ( ! YY_CURRENT_BUFFER ){
    3049         zconfensure_buffer_stack ();
    3050                 YY_CURRENT_BUFFER_LVALUE =
    3051             zconf_create_buffer(zconfin,YY_BUF_SIZE );
    3052         }
    3053 
    3054         zconf_init_buffer(YY_CURRENT_BUFFER,input_file );
    3055         zconf_load_buffer_state( );
    3056 }
    3057 
    3058 /** Switch to a different input buffer.
    3059  * @param new_buffer The new input buffer.
    3060  *
    3061  */
    3062     void zconf_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
    3063 {
    3064 
    3065         /* TODO. We should be able to replace this entire function body
    3066          * with
    3067          *              zconfpop_buffer_state();
    3068          *              zconfpush_buffer_state(new_buffer);
    3069      */
    3070         zconfensure_buffer_stack ();
    3071         if ( YY_CURRENT_BUFFER == new_buffer )
     3078        }
     3079
     3080
     3081#ifdef YY_USE_PROTOS
     3082void yyrestart( FILE *input_file )
     3083#else
     3084void yyrestart( input_file )
     3085FILE *input_file;
     3086#endif
     3087        {
     3088        if ( ! yy_current_buffer )
     3089                yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
     3090
     3091        yy_init_buffer( yy_current_buffer, input_file );
     3092        yy_load_buffer_state();
     3093        }
     3094
     3095
     3096#ifdef YY_USE_PROTOS
     3097void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
     3098#else
     3099void yy_switch_to_buffer( new_buffer )
     3100YY_BUFFER_STATE new_buffer;
     3101#endif
     3102        {
     3103        if ( yy_current_buffer == new_buffer )
    30723104                return;
    30733105
    3074         if ( YY_CURRENT_BUFFER )
     3106        if ( yy_current_buffer )
    30753107                {
    30763108                /* Flush out information for old buffer. */
    3077                 *(yy_c_buf_p) = (yy_hold_char);
    3078                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
    3079                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
     3109                *yy_c_buf_p = yy_hold_char;
     3110                yy_current_buffer->yy_buf_pos = yy_c_buf_p;
     3111                yy_current_buffer->yy_n_chars = yy_n_chars;
    30803112                }
    30813113
    3082         YY_CURRENT_BUFFER_LVALUE = new_buffer;
    3083         zconf_load_buffer_state( );
     3114        yy_current_buffer = new_buffer;
     3115        yy_load_buffer_state();
    30843116
    30853117        /* We don't actually know whether we did this switch during
    3086          * EOF (zconfwrap()) processing, but the only time this flag
    3087          * is looked at is after zconfwrap() is called, so it's safe
     3118         * EOF (yywrap()) processing, but the only time this flag
     3119         * is looked at is after yywrap() is called, so it's safe
    30883120         * to go ahead and always set it.
    30893121         */
    3090         (yy_did_buffer_switch_on_eof) = 1;
    3091 }
    3092 
    3093 static void zconf_load_buffer_state  (void)
    3094 {
    3095         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
    3096         (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
    3097         zconfin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
    3098         (yy_hold_char) = *(yy_c_buf_p);
    3099 }
    3100 
    3101 /** Allocate and initialize an input buffer state.
    3102  * @param file A readable stream.
    3103  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
    3104  *
    3105  * @return the allocated buffer state.
    3106  */
    3107     YY_BUFFER_STATE zconf_create_buffer  (FILE * file, int  size )
    3108 {
     3122        yy_did_buffer_switch_on_eof = 1;
     3123        }
     3124
     3125
     3126#ifdef YY_USE_PROTOS
     3127void yy_load_buffer_state( void )
     3128#else
     3129void yy_load_buffer_state()
     3130#endif
     3131        {
     3132        yy_n_chars = yy_current_buffer->yy_n_chars;
     3133        yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
     3134        yyin = yy_current_buffer->yy_input_file;
     3135        yy_hold_char = *yy_c_buf_p;
     3136        }
     3137
     3138
     3139#ifdef YY_USE_PROTOS
     3140YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
     3141#else
     3142YY_BUFFER_STATE yy_create_buffer( file, size )
     3143FILE *file;
     3144int size;
     3145#endif
     3146        {
    31093147        YY_BUFFER_STATE b;
    31103148
    3111         b = (YY_BUFFER_STATE) zconfalloc(sizeof( struct yy_buffer_state ) );
     3149        b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
    31123150        if ( ! b )
    3113                 YY_FATAL_ERROR( "out of dynamic memory in zconf_create_buffer()" );
     3151                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
    31143152
    31153153        b->yy_buf_size = size;
    … …  
    31183156         * we need to put in 2 end-of-buffer characters.
    31193157         */
    3120         b->yy_ch_buf = (char *) zconfalloc(b->yy_buf_size + 2 );
     3158        b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
    31213159        if ( ! b->yy_ch_buf )
    3122                 YY_FATAL_ERROR( "out of dynamic memory in zconf_create_buffer()" );
     3160                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
    31233161
    31243162        b->yy_is_our_buffer = 1;
    31253163
    3126         zconf_init_buffer(b,file );
     3164        yy_init_buffer( b, file );
    31273165
    31283166        return b;
    3129 }
    3130 
    3131 /** Destroy the buffer.
    3132  * @param b a buffer created with zconf_create_buffer()
    3133  *
    3134  */
    3135     void zconf_delete_buffer (YY_BUFFER_STATE  b )
    3136 {
    3137 
     3167        }
     3168
     3169
     3170#ifdef YY_USE_PROTOS
     3171void yy_delete_buffer( YY_BUFFER_STATE b )
     3172#else
     3173void yy_delete_buffer( b )
     3174YY_BUFFER_STATE b;
     3175#endif
     3176        {
    31383177        if ( ! b )
    31393178                return;
    31403179
    3141         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
    3142                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
     3180        if ( b == yy_current_buffer )
     3181                yy_current_buffer = (YY_BUFFER_STATE) 0;
    31433182
    31443183        if ( b->yy_is_our_buffer )
    3145                 zconffree((void *) b->yy_ch_buf  );
    3146 
    3147         zconffree((void *) b  );
    3148 }
    3149 
    3150 /* Initializes or reinitializes a buffer.
    3151  * This function is sometimes called more than once on the same buffer,
    3152  * such as during a zconfrestart() or at EOF.
    3153  */
    3154     static void zconf_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
    3155 
    3156 {
     3184                yy_flex_free( (void *) b->yy_ch_buf );
     3185
     3186        yy_flex_free( (void *) b );
     3187        }
     3188
     3189
     3190#ifndef YY_ALWAYS_INTERACTIVE
     3191#ifndef YY_NEVER_INTERACTIVE
     3192#include <unistd.h>
     3193#endif
     3194#endif
     3195
     3196#ifdef YY_USE_PROTOS
     3197void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
     3198#else
     3199void yy_init_buffer( b, file )
     3200YY_BUFFER_STATE b;
     3201FILE *file;
     3202#endif
     3203
     3204
     3205        {
    31573206        int oerrno = errno;
    31583207
    3159         zconf_flush_buffer(b );
     3208        yy_flush_buffer( b );
    31603209
    31613210        b->yy_input_file = file;
    31623211        b->yy_fill_buffer = 1;
    31633212
    3164     /* If b is the current buffer, then zconf_init_buffer was _probably_
    3165      * called from zconfrestart() or through yy_get_next_buffer.
    3166      * In that case, we don't want to reset the lineno or column.
    3167      */
    3168     if (b != YY_CURRENT_BUFFER){
    3169         b->yy_bs_lineno = 1;
    3170         b->yy_bs_column = 0;
    3171     }
    3172 
    3173         b->yy_is_interactive = 0;
    3174 
     3213#if YY_ALWAYS_INTERACTIVE
     3214        b->yy_is_interactive = 1;
     3215#else
     3216#if YY_NEVER_INTERACTIVE
     3217        b->yy_is_interactive = 0;
     3218#else
     3219        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
     3220#endif
     3221#endif
    31753222        errno = oerrno;
    3176 }
    3177 
    3178 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
    3179  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
    3180  *
    3181  */
    3182     void zconf_flush_buffer (YY_BUFFER_STATE  b )
    3183 {
    3184         if ( ! b )
     3223        }
     3224
     3225
     3226#ifdef YY_USE_PROTOS
     3227void yy_flush_buffer( YY_BUFFER_STATE b )
     3228#else
     3229void yy_flush_buffer( b )
     3230YY_BUFFER_STATE b;
     3231#endif
     3232
     3233        {
     3234        if ( ! b )
    31853235                return;
    31863236
    … …  
    31993249        b->yy_buffer_status = YY_BUFFER_NEW;
    32003250
    3201         if ( b == YY_CURRENT_BUFFER )
    3202                 zconf_load_buffer_state( );
    3203 }
    3204 
    3205 /** Pushes the new state onto the stack. The new state becomes
    3206  *  the current state. This function will allocate the stack
    3207  *  if necessary.
    3208  *  @param new_buffer The new state.
    3209  *
    3210  */
    3211 void zconfpush_buffer_state (YY_BUFFER_STATE new_buffer )
    3212 {
    3213         if (new_buffer == NULL)
    3214                 return;
    3215 
    3216         zconfensure_buffer_stack();
    3217 
    3218         /* This block is copied from zconf_switch_to_buffer. */
    3219         if ( YY_CURRENT_BUFFER )
    3220                 {
    3221                 /* Flush out information for old buffer. */
    3222                 *(yy_c_buf_p) = (yy_hold_char);
    3223                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
    3224                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
    3225                 }
    3226 
    3227         /* Only push if top exists. Otherwise, replace top. */
    3228         if (YY_CURRENT_BUFFER)
    3229                 (yy_buffer_stack_top)++;
    3230         YY_CURRENT_BUFFER_LVALUE = new_buffer;
    3231 
    3232         /* copied from zconf_switch_to_buffer. */
    3233         zconf_load_buffer_state( );
    3234         (yy_did_buffer_switch_on_eof) = 1;
    3235 }
    3236 
    3237 /** Removes and deletes the top of the stack, if present.
    3238  *  The next element becomes the new top.
    3239  *
    3240  */
    3241 void zconfpop_buffer_state (void)
    3242 {
    3243         if (!YY_CURRENT_BUFFER)
    3244                 return;
    3245 
    3246         zconf_delete_buffer(YY_CURRENT_BUFFER );
    3247         YY_CURRENT_BUFFER_LVALUE = NULL;
    3248         if ((yy_buffer_stack_top) > 0)
    3249                 --(yy_buffer_stack_top);
    3250 
    3251         if (YY_CURRENT_BUFFER) {
    3252                 zconf_load_buffer_state( );
    3253                 (yy_did_buffer_switch_on_eof) = 1;
    3254         }
    3255 }
    3256 
    3257 /* Allocates the stack if it does not exist.
    3258  *  Guarantees space for at least one push.
    3259  */
    3260 static void zconfensure_buffer_stack (void)
    3261 {
    3262         int num_to_alloc;
    3263 
    3264         if (!(yy_buffer_stack)) {
    3265 
    3266                 /* First allocation is just for 2 elements, since we don't know if this
    3267                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
    3268                  * immediate realloc on the next call.
    3269          */
    3270                 num_to_alloc = 1;
    3271                 (yy_buffer_stack) = (struct yy_buffer_state**)zconfalloc
    3272                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
    3273                                                                 );
    3274 
    3275                 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
    3276 
    3277                 (yy_buffer_stack_max) = num_to_alloc;
    3278                 (yy_buffer_stack_top) = 0;
    3279                 return;
    3280         }
    3281 
    3282         if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
    3283 
    3284                 /* Increase the buffer to prepare for a possible push. */
    3285                 int grow_size = 8 /* arbitrary grow size */;
    3286 
    3287                 num_to_alloc = (yy_buffer_stack_max) + grow_size;
    3288                 (yy_buffer_stack) = (struct yy_buffer_state**)zconfrealloc
    3289                                                                 ((yy_buffer_stack),
    3290                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
    3291                                                                 );
    3292 
    3293                 /* zero only the new slots.*/
    3294                 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
    3295                 (yy_buffer_stack_max) = num_to_alloc;
    3296         }
    3297 }
    3298 
    3299 /** Setup the input buffer state to scan directly from a user-specified character buffer.
    3300  * @param base the character buffer
    3301  * @param size the size in bytes of the character buffer
    3302  *
    3303  * @return the newly allocated buffer state object.
    3304  */
    3305 YY_BUFFER_STATE zconf_scan_buffer  (char * base, yy_size_t  size )
    3306 {
     3251        if ( b == yy_current_buffer )
     3252                yy_load_buffer_state();
     3253        }
     3254
     3255
     3256#ifndef YY_NO_SCAN_BUFFER
     3257#ifdef YY_USE_PROTOS
     3258YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
     3259#else
     3260YY_BUFFER_STATE yy_scan_buffer( base, size )
     3261char *base;
     3262yy_size_t size;
     3263#endif
     3264        {
    33073265        YY_BUFFER_STATE b;
    33083266
    … …  
    33133271                return 0;
    33143272
    3315         b = (YY_BUFFER_STATE) zconfalloc(sizeof( struct yy_buffer_state ) );
     3273        b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
    33163274        if ( ! b )
    3317                 YY_FATAL_ERROR( "out of dynamic memory in zconf_scan_buffer()" );
     3275                YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
    33183276
    33193277        b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
    … …  
    33273285        b->yy_buffer_status = YY_BUFFER_NEW;
    33283286
    3329         zconf_switch_to_buffer(b );
     3287        yy_switch_to_buffer( b );
    33303288
    33313289        return b;
    3332 }
    3333 
    3334 /** Setup the input buffer state to scan a string. The next call to zconflex() will
    3335  * scan from a @e copy of @a str.
    3336  * @param str a NUL-terminated string to scan
    3337  *
    3338  * @return the newly allocated buffer state object.
    3339  * @note If you want to scan bytes that may contain NUL values, then use
    3340  *       zconf_scan_bytes() instead.
    3341  */
    3342 YY_BUFFER_STATE zconf_scan_string (yyconst char * str )
    3343 {
    3344 
    3345         return zconf_scan_bytes(str,strlen(str) );
    3346 }
    3347 
    3348 /** Setup the input buffer state to scan the given bytes. The next call to zconflex() will
    3349  * scan from a @e copy of @a bytes.
    3350  * @param bytes the byte buffer to scan
    3351  * @param len the number of bytes in the buffer pointed to by @a bytes.
    3352  *
    3353  * @return the newly allocated buffer state object.
    3354  */
    3355 YY_BUFFER_STATE zconf_scan_bytes  (yyconst char * bytes, int  len )
    3356 {
     3290        }
     3291#endif
     3292
     3293
     3294#ifndef YY_NO_SCAN_STRING
     3295#ifdef YY_USE_PROTOS
     3296YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
     3297#else
     3298YY_BUFFER_STATE yy_scan_string( yy_str )
     3299yyconst char *yy_str;
     3300#endif
     3301        {
     3302        int len;
     3303        for ( len = 0; yy_str[len]; ++len )
     3304                ;
     3305
     3306        return yy_scan_bytes( yy_str, len );
     3307        }
     3308#endif
     3309
     3310
     3311#ifndef YY_NO_SCAN_BYTES
     3312#ifdef YY_USE_PROTOS
     3313YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
     3314#else
     3315YY_BUFFER_STATE yy_scan_bytes( bytes, len )
     3316yyconst char *bytes;
     3317int len;
     3318#endif
     3319        {
    33573320        YY_BUFFER_STATE b;
    33583321        char *buf;
    … …  
    33623325        /* Get memory for full buffer, including space for trailing EOB's. */
    33633326        n = len + 2;
    3364         buf = (char *) zconfalloc(n );
     3327        buf = (char *) yy_flex_alloc( n );
    33653328        if ( ! buf )
    3366                 YY_FATAL_ERROR( "out of dynamic memory in zconf_scan_bytes()" );
     3329                YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
    33673330
    33683331        for ( i = 0; i < len; ++i )
    … …  
    33713334        buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
    33723335
    3373         b = zconf_scan_buffer(buf,n );
     3336        b = yy_scan_buffer( buf, n );
    33743337        if ( ! b )
    3375                 YY_FATAL_ERROR( "bad buffer in zconf_scan_bytes()" );
     3338                YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
    33763339
    33773340        /* It's okay to grow etc. this buffer, and we should throw it
    … …  
    33813344
    33823345        return b;
    3383 }
     3346        }
     3347#endif
     3348
     3349
     3350#ifndef YY_NO_PUSH_STATE
     3351#ifdef YY_USE_PROTOS
     3352static void yy_push_state( int new_state )
     3353#else
     3354static void yy_push_state( new_state )
     3355int new_state;
     3356#endif
     3357        {
     3358        if ( yy_start_stack_ptr >= yy_start_stack_depth )
     3359                {
     3360                yy_size_t new_size;
     3361
     3362                yy_start_stack_depth += YY_START_STACK_INCR;
     3363                new_size = yy_start_stack_depth * sizeof( int );
     3364
     3365                if ( ! yy_start_stack )
     3366                        yy_start_stack = (int *) yy_flex_alloc( new_size );
     3367
     3368                else
     3369                        yy_start_stack = (int *) yy_flex_realloc(
     3370                                        (void *) yy_start_stack, new_size );
     3371
     3372                if ( ! yy_start_stack )
     3373                        YY_FATAL_ERROR(
     3374                        "out of memory expanding start-condition stack" );
     3375                }
     3376
     3377        yy_start_stack[yy_start_stack_ptr++] = YY_START;
     3378
     3379        BEGIN(new_state);
     3380        }
     3381#endif
     3382
     3383
     3384#ifndef YY_NO_POP_STATE
     3385static void yy_pop_state()
     3386        {
     3387        if ( --yy_start_stack_ptr < 0 )
     3388                YY_FATAL_ERROR( "start-condition stack underflow" );
     3389
     3390        BEGIN(yy_start_stack[yy_start_stack_ptr]);
     3391        }
     3392#endif
     3393
     3394
     3395#ifndef YY_NO_TOP_STATE
     3396static int yy_top_state()
     3397        {
     3398        return yy_start_stack[yy_start_stack_ptr - 1];
     3399        }
     3400#endif
    33843401
    33853402#ifndef YY_EXIT_FAILURE
    … …  
    33873404#endif
    33883405
    3389 static void yy_fatal_error (yyconst char* msg )
    3390 {
    3391         (void) fprintf( stderr, "%s\n", msg );
     3406#ifdef YY_USE_PROTOS
     3407static void yy_fatal_error( yyconst char msg[] )
     3408#else
     3409static void yy_fatal_error( msg )
     3410char msg[];
     3411#endif
     3412        {
     3413        (void) fprintf( stderr, "%s\n", msg );
    33923414        exit( YY_EXIT_FAILURE );
    3393 }
     3415        }
     3416
     3417
    33943418
    33953419/* Redefine yyless() so it works in section 3 code. */
    … …  
    33993423        do \
    34003424                { \
    3401                 /* Undo effects of setting up zconftext. */ \
    3402         int yyless_macro_arg = (n); \
    3403         YY_LESS_LINENO(yyless_macro_arg);\
    3404                 zconftext[zconfleng] = (yy_hold_char); \
    3405                 (yy_c_buf_p) = zconftext + yyless_macro_arg; \
    3406                 (yy_hold_char) = *(yy_c_buf_p); \
    3407                 *(yy_c_buf_p) = '\0'; \
    3408                 zconfleng = yyless_macro_arg; \
     3425                /* Undo effects of setting up yytext. */ \
     3426                yytext[yyleng] = yy_hold_char; \
     3427                yy_c_buf_p = yytext + n; \
     3428                yy_hold_char = *yy_c_buf_p; \
     3429                *yy_c_buf_p = '\0'; \
     3430                yyleng = n; \
    34093431                } \
    34103432        while ( 0 )
    34113433
    3412 /* Accessor  methods (get/set functions) to struct members. */
    3413 
    3414 /** Get the current line number.
    3415  *
    3416  */
    3417 int zconfget_lineno  (void)
    3418 {
    3419 
    3420     return zconflineno;
    3421 }
    3422 
    3423 /** Get the input stream.
    3424  *
    3425  */
    3426 FILE *zconfget_in  (void)
    3427 {
    3428         return zconfin;
    3429 }
    3430 
    3431 /** Get the output stream.
    3432  *
    3433  */
    3434 FILE *zconfget_out  (void)
    3435 {
    3436         return zconfout;
    3437 }
    3438 
    3439 /** Get the length of the current token.
    3440  *
    3441  */
    3442 int zconfget_leng  (void)
    3443 {
    3444         return zconfleng;
    3445 }
    3446 
    3447 /** Get the current token.
    3448  *
    3449  */
    3450 
    3451 char *zconfget_text  (void)
    3452 {
    3453         return zconftext;
    3454 }
    3455 
    3456 /** Set the current line number.
    3457  * @param line_number
    3458  *
    3459  */
    3460 void zconfset_lineno (int  line_number )
    3461 {
    3462 
    3463     zconflineno = line_number;
    3464 }
    3465 
    3466 /** Set the input stream. This does not discard the current
    3467  * input buffer.
    3468  * @param in_str A readable stream.
    3469  *
    3470  * @see zconf_switch_to_buffer
    3471  */
    3472 void zconfset_in (FILE *  in_str )
    3473 {
    3474         zconfin = in_str ;
    3475 }
    3476 
    3477 void zconfset_out (FILE *  out_str )
    3478 {
    3479         zconfout = out_str ;
    3480 }
    3481 
    3482 int zconfget_debug  (void)
    3483 {
    3484         return zconf_flex_debug;
    3485 }
    3486 
    3487 void zconfset_debug (int  bdebug )
    3488 {
    3489         zconf_flex_debug = bdebug ;
    3490 }
    3491 
    3492 /* zconflex_destroy is for both reentrant and non-reentrant scanners. */
    3493 int zconflex_destroy  (void)
    3494 {
    3495 
    3496     /* Pop the buffer stack, destroying each element. */
    3497         while(YY_CURRENT_BUFFER){
    3498                 zconf_delete_buffer(YY_CURRENT_BUFFER  );
    3499                 YY_CURRENT_BUFFER_LVALUE = NULL;
    3500                 zconfpop_buffer_state();
    3501         }
    3502 
    3503         /* Destroy the stack itself. */
    3504         zconffree((yy_buffer_stack) );
    3505         (yy_buffer_stack) = NULL;
    3506 
    3507     return 0;
    3508 }
    3509 
    3510 /*
    3511  * Internal utility routines.
    3512  */
     3434
     3435/* Internal utility routines. */
    35133436
    35143437#ifndef yytext_ptr
    3515 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
    3516 {
     3438#ifdef YY_USE_PROTOS
     3439static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
     3440#else
     3441static void yy_flex_strncpy( s1, s2, n )
     3442char *s1;
     3443yyconst char *s2;
     3444int n;
     3445#endif
     3446        {
    35173447        register int i;
    3518         for ( i = 0; i < n; ++i )
     3448        for ( i = 0; i < n; ++i )
    35193449                s1[i] = s2[i];
    3520 }
     3450        }
    35213451#endif
    35223452
    35233453#ifdef YY_NEED_STRLEN
    3524 static int yy_flex_strlen (yyconst char * s )
    3525 {
     3454#ifdef YY_USE_PROTOS
     3455static int yy_flex_strlen( yyconst char *s )
     3456#else
     3457static int yy_flex_strlen( s )
     3458yyconst char *s;
     3459#endif
     3460        {
    35263461        register int n;
    3527         for ( n = 0; s[n]; ++n )
     3462        for ( n = 0; s[n]; ++n )
    35283463                ;
    35293464
    35303465        return n;
    3531 }
    3532 #endif
    3533 
    3534 void *zconfalloc (yy_size_t  size )
    3535 {
     3466        }
     3467#endif
     3468
     3469
     3470#ifdef YY_USE_PROTOS
     3471static void *yy_flex_alloc( yy_size_t size )
     3472#else
     3473static void *yy_flex_alloc( size )
     3474yy_size_t size;
     3475#endif
     3476        {
    35363477        return (void *) malloc( size );
    3537 }
    3538 
    3539 void *zconfrealloc  (void * ptr, yy_size_t  size )
    3540 {
     3478        }
     3479
     3480#ifdef YY_USE_PROTOS
     3481static void *yy_flex_realloc( void *ptr, yy_size_t size )
     3482#else
     3483static void *yy_flex_realloc( ptr, size )
     3484void *ptr;
     3485yy_size_t size;
     3486#endif
     3487        {
    35413488        /* The cast to (char *) in the following accommodates both
    35423489         * implementations that use char* generic pointers, and those
    … …  
    35473494         */
    35483495        return (void *) realloc( (char *) ptr, size );
    3549 }
    3550 
    3551 void zconffree (void * ptr )
    3552 {
    3553         free( (char *) ptr );   /* see zconfrealloc() for (char *) cast */
    3554 }
    3555 
    3556 #define YYTABLES_NAME "yytables"
    3557 
    3558 #undef YY_NEW_FILE
    3559 #undef YY_FLUSH_BUFFER
    3560 #undef yy_set_bol
    3561 #undef yy_new_buffer
    3562 #undef yy_set_interactive
    3563 #undef yytext_ptr
    3564 #undef YY_DO_BEFORE_ACTION
    3565 
    3566 #ifdef YY_DECL_IS_OURS
    3567 #undef YY_DECL_IS_OURS
    3568 #undef YY_DECL
    3569 #endif
     3496        }
     3497
     3498#ifdef YY_USE_PROTOS
     3499static void yy_flex_free( void *ptr )
     3500#else
     3501static void yy_flex_free( ptr )
     3502void *ptr;
     3503#endif
     3504        {
     3505        free( ptr );
     3506        }
     3507
     3508#if YY_MAIN
     3509int main()
     3510        {
     3511        yylex();
     3512        return 0;
     3513        }
     3514#endif
     3515#line 248 "zconf.l"
    35703516
    35713517void zconf_starthelp(void)
    … …  
    35813527        BEGIN(INITIAL);
    35823528}
     3529
    35833530
    35843531/*
    … …  
    36083555void zconf_initscan(const char *name)
    36093556{
    3610         zconfin = zconf_fopen(name);
    3611         if (!zconfin) {
     3557        yyin = zconf_fopen(name);
     3558        if (!yyin) {
    36123559                printf("can't find file %s\n", name);
    36133560                exit(1);
    … …  
    36443591
    36453592                file = file_lookup(filename);
    3646                 buf = malloc(sizeof(*buf));
     3593                buf = malloc(sizeof(*buf));
    36473594                memset(buf, 0, sizeof(*buf));
    36483595                current_buf->state = YY_CURRENT_BUFFER;
    … …  
    36823629        parent = current_buf->parent;
    36833630        if (parent) {
    3684                 fclose(zconfin);
    3685                 zconf_delete_buffer(YY_CURRENT_BUFFER);
    3686                 zconf_switch_to_buffer(parent->state);
     3631                fclose(yyin);
     3632                yy_delete_buffer(YY_CURRENT_BUFFER);
     3633                yy_switch_to_buffer(parent->state);
    36873634        }
    36883635        free(current_buf);
    … …  
    37073654                return "<none>";
    37083655}
    3709 

  • package/config/zconf.tab.c_shipped

    r4e0f7fd r6753dda  
    1 /* A Bison parser, made by GNU Bison 1.875a.  */
    2 
    3 /* Skeleton parser for Yacc-like parsing with Bison,
    4    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
     1/* A Bison parser, made by GNU Bison 2.3.  */
     2
     3/* Skeleton implementation for Bison's Yacc-like parsers in C
     4
     5   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
     6   Free Software Foundation, Inc.
    57
    68   This program is free software; you can redistribute it and/or modify
    … …  
    1618   You should have received a copy of the GNU General Public License
    1719   along with this program; if not, write to the Free Software
    18    Foundation, Inc., 59 Temple Place - Suite 330,
    19    Boston, MA 02111-1307, USA.  */
    20 
    21 /* As a special exception, when this file is copied by Bison into a
    22    Bison output file, you may use that output file without restriction.
    23    This special exception was added by the Free Software Foundation
    24    in version 1.24 of Bison.  */
    25 
    26 /* Written by Richard Stallman by simplifying the original so called
    27    ``semantic'' parser.  */
     20   Foundation, Inc., 51 Franklin Street, Fifth Floor,
     21   Boston, MA 02110-1301, USA.  */
     22
     23/* As a special exception, you may create a larger work that contains
     24   part or all of the Bison parser skeleton and distribute that work
     25   under terms of your choice, so long as that work isn't itself a
     26   parser generator using the skeleton or a modified version thereof
     27   as a parser skeleton.  Alternatively, if you modify or redistribute
     28   the parser skeleton itself, you may (at your option) remove this
     29   special exception, which will cause the skeleton and the resulting
     30   Bison output files to be licensed under the GNU General Public
     31   License without this special exception.
     32
     33   This special exception was added by the Free Software Foundation in
     34   version 2.2 of Bison.  */
     35
     36/* C LALR(1) parser skeleton written by Richard Stallman, by
     37   simplifying the original so-called "semantic" parser.  */
    2838
    2939/* All symbols defined below should begin with yy or YY, to avoid
    … …  
    3747#define YYBISON 1
    3848
     49/* Bison version.  */
     50#define YYBISON_VERSION "2.3"
     51
    3952/* Skeleton name.  */
    4053#define YYSKELETON_NAME "yacc.c"
    … …  
    4659#define YYLSP_NEEDED 0
    4760
    48 /* If NAME_PREFIX is specified substitute the variables and functions
    49    names.  */
     61/* Substitute the variable and function names.  */
    5062#define yyparse zconfparse
    5163#define yylex   zconflex
    … …  
    104116   };
    105117#endif
     118/* Tokens.  */
    106119#define T_MAINMENU 258
    107120#define T_MENU 259
    … …  
    148161
    149162/* Copy the first part of user declarations.  */
    150 
     163#line 1 "zconf.y"
    151164
    152165/*
    … …  
    181194/* Enabling traces.  */
    182195#ifndef YYDEBUG
    183 # define YYDEBUG 0
     196# define YYDEBUG 1
    184197#endif
    185198
    … …  
    192205#endif
    193206
    194 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
    195 
    196 typedef union YYSTYPE {
     207/* Enabling the token table.  */
     208#ifndef YYTOKEN_TABLE
     209# define YYTOKEN_TABLE 0
     210#endif
     211
     212#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
     213typedef union YYSTYPE
     214#line 33 "zconf.y"
     215{
    197216        int token;
    198217        char *string;
    … …  
    200219        struct expr *expr;
    201220        struct menu *menu;
    202 } YYSTYPE;
    203 /* Line 191 of yacc.c.  */
    204 
     221}
     222/* Line 193 of yacc.c.  */
     223#line 224 "zconf.tab.c"
     224        YYSTYPE;
    205225# define yystype YYSTYPE /* obsolescent; will be withdrawn */
    206226# define YYSTYPE_IS_DECLARED 1
    … …  
    211231
    212232/* Copy the second part of user declarations.  */
    213 
     233#line 89 "zconf.y"
    214234
    215235#define LKC_DIRECT_LINK
    … …  
    217237
    218238
    219 /* Line 214 of yacc.c.  */
    220 
    221 
    222 #if ! defined (yyoverflow) || YYERROR_VERBOSE
     239/* Line 216 of yacc.c.  */
     240#line 241 "zconf.tab.c"
     241
     242#ifdef short
     243# undef short
     244#endif
     245
     246#ifdef YYTYPE_UINT8
     247typedef YYTYPE_UINT8 yytype_uint8;
     248#else
     249typedef unsigned char yytype_uint8;
     250#endif
     251
     252#ifdef YYTYPE_INT8
     253typedef YYTYPE_INT8 yytype_int8;
     254#elif (defined __STDC__ || defined __C99__FUNC__ \
     255     || defined __cplusplus || defined _MSC_VER)
     256typedef signed char yytype_int8;
     257#else
     258typedef short int yytype_int8;
     259#endif
     260
     261#ifdef YYTYPE_UINT16
     262typedef YYTYPE_UINT16 yytype_uint16;
     263#else
     264typedef unsigned short int yytype_uint16;
     265#endif
     266
     267#ifdef YYTYPE_INT16
     268typedef YYTYPE_INT16 yytype_int16;
     269#else
     270typedef short int yytype_int16;
     271#endif
     272
     273#ifndef YYSIZE_T
     274# ifdef __SIZE_TYPE__
     275#  define YYSIZE_T __SIZE_TYPE__
     276# elif defined size_t
     277#  define YYSIZE_T size_t
     278# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
     279     || defined __cplusplus || defined _MSC_VER)
     280#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
     281#  define YYSIZE_T size_t
     282# else
     283#  define YYSIZE_T unsigned int
     284# endif
     285#endif
     286
     287#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
     288
     289#ifndef YY_
     290# if YYENABLE_NLS
     291#  if ENABLE_NLS
     292#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
     293#   define YY_(msgid) dgettext ("bison-runtime", msgid)
     294#  endif
     295# endif
     296# ifndef YY_
     297#  define YY_(msgid) msgid
     298# endif
     299#endif
     300
     301/* Suppress unused-variable warnings by "using" E.  */
     302#if ! defined lint || defined __GNUC__
     303# define YYUSE(e) ((void) (e))
     304#else
     305# define YYUSE(e) /* empty */
     306#endif
     307
     308/* Identity function, used to suppress warnings about constant conditions.  */
     309#ifndef lint
     310# define YYID(n) (n)
     311#else
     312#if (defined __STDC__ || defined __C99__FUNC__ \
     313     || defined __cplusplus || defined _MSC_VER)
     314static int
     315YYID (int i)
     316#else
     317static int
     318YYID (i)
     319    int i;
     320#endif
     321{
     322  return i;
     323}
     324#endif
     325
     326#if ! defined yyoverflow || YYERROR_VERBOSE
    223327
    224328/* The parser invokes alloca or malloc; define the necessary symbols.  */
    225329
    226 # if YYSTACK_USE_ALLOCA
    227 #  define YYSTACK_ALLOC alloca
    228 # else
    229 #  ifndef YYSTACK_USE_ALLOCA
    230 #   if defined (alloca) || defined (_ALLOCA_H)
     330# ifdef YYSTACK_USE_ALLOCA
     331#  if YYSTACK_USE_ALLOCA
     332#   ifdef __GNUC__
     333#    define YYSTACK_ALLOC __builtin_alloca
     334#   elif defined __BUILTIN_VA_ARG_INCR
     335#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
     336#   elif defined _AIX
     337#    define YYSTACK_ALLOC __alloca
     338#   elif defined _MSC_VER
     339#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
     340#    define alloca _alloca
     341#   else
    231342#    define YYSTACK_ALLOC alloca
    232 #   else
    233 #    ifdef __GNUC__
    234 #     define YYSTACK_ALLOC __builtin_alloca
     343#    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
     344     || defined __cplusplus || defined _MSC_VER)
     345#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
     346#     ifndef _STDLIB_H
     347#      define _STDLIB_H 1
     348#     endif
    235349#    endif
    236350#   endif
    … …  
    239353
    240354# ifdef YYSTACK_ALLOC
    241    /* Pacify GCC's `empty if-body' warning. */
    242 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
     355   /* Pacify GCC's `empty if-body' warning.  */
     356#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
     357#  ifndef YYSTACK_ALLOC_MAXIMUM
     358    /* The OS might guarantee only one guard page at the bottom of the stack,
     359       and a page size can be as small as 4096 bytes.  So we cannot safely
     360       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
     361       to allow for a few compiler-allocated temporary stack slots.  */
     362#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
     363#  endif
    243364# else
    244 #  if defined (__STDC__) || defined (__cplusplus)
     365#  define YYSTACK_ALLOC YYMALLOC
     366#  define YYSTACK_FREE YYFREE
     367#  ifndef YYSTACK_ALLOC_MAXIMUM
     368#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
     369#  endif
     370#  if (defined __cplusplus && ! defined _STDLIB_H \
     371       && ! ((defined YYMALLOC || defined malloc) \
     372             && (defined YYFREE || defined free)))
    245373#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
    246 #   define YYSIZE_T size_t
     374#   ifndef _STDLIB_H
     375#    define _STDLIB_H 1
     376#   endif
    247377#  endif
    248 #  define YYSTACK_ALLOC malloc
    249 #  define YYSTACK_FREE free
     378#  ifndef YYMALLOC
     379#   define YYMALLOC malloc
     380#   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
     381     || defined __cplusplus || defined _MSC_VER)
     382void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
     383#   endif
     384#  endif
     385#  ifndef YYFREE
     386#   define YYFREE free
     387#   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
     388     || defined __cplusplus || defined _MSC_VER)
     389void free (void *); /* INFRINGES ON USER NAME SPACE */
     390#   endif
     391#  endif
    250392# endif
    251 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
    252 
    253 
    254 #if (! defined (yyoverflow) \
    255      && (! defined (__cplusplus) \
    256          || (YYSTYPE_IS_TRIVIAL)))
     393#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
     394
     395
     396#if (! defined yyoverflow \
     397     && (! defined __cplusplus \
     398         || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
    257399
    258400/* A type that is properly aligned for any stack member.  */
    259401union yyalloc
    260402{
    261   short yyss;
     403  yytype_int16 yyss;
    262404  YYSTYPE yyvs;
    263405  };
    … …  
    269411   N elements.  */
    270412# define YYSTACK_BYTES(N) \
    271      ((N) * (sizeof (short) + sizeof (YYSTYPE))                         \
     413     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
    272414      + YYSTACK_GAP_MAXIMUM)
    273415
    … …  
    275417   not overlap.  */
    276418# ifndef YYCOPY
    277 #  if 1 < __GNUC__
     419#  if defined __GNUC__ && 1 < __GNUC__
    278420#   define YYCOPY(To, From, Count) \
    279421      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
    … …  
    282424      do                                        \
    283425        {                                       \
    284           register YYSIZE_T yyi;                \
     426          YYSIZE_T yyi;                         \
    285427          for (yyi = 0; yyi < (Count); yyi++)   \
    286428            (To)[yyi] = (From)[yyi];            \
    287429        }                                       \
    288       while (0)
     430      while (YYID (0))
    289431#  endif
    290432# endif
    … …  
    304446        yyptr += yynewbytes / sizeof (*yyptr);                          \
    305447      }                                                                 \
    306     while (0)
    307 
    308 #endif
    309 
    310 #if defined (__STDC__) || defined (__cplusplus)
    311    typedef signed char yysigned_char;
    312 #else
    313    typedef short yysigned_char;
    314 #endif
    315 
    316 /* YYFINAL -- State number of the termination state. */
     448    while (YYID (0))
     449
     450#endif
     451
     452/* YYFINAL -- State number of the termination state.  */
    317453#define YYFINAL  2
    318454/* YYLAST -- Last index in YYTABLE.  */
    319455#define YYLAST   201
    320456
    321 /* YYNTOKENS -- Number of terminals. */
     457/* YYNTOKENS -- Number of terminals.  */
    322458#define YYNTOKENS  42
    323 /* YYNNTS -- Number of nonterminals. */
     459/* YYNNTS -- Number of nonterminals.  */
    324460#define YYNNTS  41
    325 /* YYNRULES -- Number of rules. */
     461/* YYNRULES -- Number of rules.  */
    326462#define YYNRULES  104
    327 /* YYNRULES -- Number of states. */
     463/* YYNRULES -- Number of states.  */
    328464#define YYNSTATES  182
    329465
    … …  
    332468#define YYMAXUTOK   296
    333469
    334 #define YYTRANSLATE(YYX)                                                \
     470#define YYTRANSLATE(YYX)                                                \
    335471  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
    336472
    337473/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
    338 static const unsigned char yytranslate[] =
     474static const yytype_uint8 yytranslate[] =
    339475{
    340476       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    … …  
    373509/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
    374510   YYRHS.  */
    375 static const unsigned short yyprhs[] =
     511static const yytype_uint16 yyprhs[] =
    376512{
    377513       0,     0,     3,     4,     7,     9,    11,    13,    17,    19,
    … …  
    388524};
    389525
    390 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
    391 static const yysigned_char yyrhs[] =
     526/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
     527static const yytype_int8 yyrhs[] =
    392528{
    393529      43,     0,    -1,    -1,    43,    44,    -1,    45,    -1,    55,
    … …  
    426562
    427563/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
    428 static const unsigned short yyrline[] =
     564static const yytype_uint16 yyrline[] =
    429565{
    430566       0,    94,    94,    95,    98,    99,   100,   101,   102,   103,
    … …  
    442578#endif
    443579
    444 #if YYDEBUG || YYERROR_VERBOSE
    445 /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
    446    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
     580#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
     581/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
     582   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
    447583static const char *const yytname[] =
    448584{
    … …  
    454590  "T_HEX", "T_WORD", "T_WORD_QUOTE", "T_UNEQUAL", "T_EOF", "T_EOL",
    455591  "T_CLOSE_PAREN", "T_OPEN_PAREN", "T_ON", "T_SELECT", "T_RANGE", "T_OR",
    456   "T_AND", "T_EQUAL", "T_NOT", "$accept", "input", "block",
    457   "common_block", "config_entry_start", "config_stmt",
    458   "menuconfig_entry_start", "menuconfig_stmt", "config_option_list",
    459   "config_option", "choice", "choice_entry", "choice_end", "choice_stmt",
    460   "choice_option_list", "choice_option", "choice_block", "if", "if_end",
    461   "if_stmt", "if_block", "menu", "menu_entry", "menu_end", "menu_stmt",
    462   "menu_block", "source", "source_stmt", "comment", "comment_stmt",
    463   "help_start", "help", "depends_list", "depends", "prompt_stmt_opt",
    464   "prompt", "end", "nl_or_eof", "if_expr", "expr", "symbol", 0
     592  "T_AND", "T_EQUAL", "T_NOT", "$accept", "input", "block", "common_block",
     593  "config_entry_start", "config_stmt", "menuconfig_entry_start",
     594  "menuconfig_stmt", "config_option_list", "config_option", "choice",
     595  "choice_entry", "choice_end", "choice_stmt", "choice_option_list",
     596  "choice_option", "choice_block", "if", "if_end", "if_stmt", "if_block",
     597  "menu", "menu_entry", "menu_end", "menu_stmt", "menu_block", "source",
     598  "source_stmt", "comment", "comment_stmt", "help_start", "help",
     599  "depends_list", "depends", "prompt_stmt_opt", "prompt", "end",
     600  "nl_or_eof", "if_expr", "expr", "symbol", 0
    465601};
    466602#endif
    … …  
    469605/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
    470606   token YYLEX-NUM.  */
    471 static const unsigned short yytoknum[] =
     607static const yytype_uint16 yytoknum[] =
    472608{
    473609       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
    … …  
    480616
    481617/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
    482 static const unsigned char yyr1[] =
     618static const yytype_uint8 yyr1[] =
    483619{
    484620       0,    42,    43,    43,    44,    44,    44,    44,    44,    44,
    … …  
    496632
    497633/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
    498 static const unsigned char yyr2[] =
     634static const yytype_uint8 yyr2[] =
    499635{
    500636       0,     2,     0,     2,     1,     1,     1,     3,     1,     1,
    … …  
    514650   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
    515651   means the default is an error.  */
    516 static const unsigned char yydefact[] =
     652static const yytype_uint8 yydefact[] =
    517653{
    518654       2,     0,     1,     0,     0,     0,     8,     0,     0,    10,
    … …  
    537673};
    538674
    539 /* YYDEFGOTO[NTERM-NUM]. */
    540 static const short yydefgoto[] =
     675/* YYDEFGOTO[NTERM-NUM].  */
     676static const yytype_int16 yydefgoto[] =
    541677{
    542678      -1,     1,    17,    18,    19,    20,    21,    22,    52,    88,
    … …  
    550686   STATE-NUM.  */
    551687#define YYPACT_NINF -99
    552 static const short yypact[] =
     688static const yytype_int16 yypact[] =
    553689{
    554690     -99,    48,   -99,    38,    46,    46,   -99,    46,   -29,   -99,
    … …  
    574710
    575711/* YYPGOTO[NTERM-NUM].  */
    576 static const short yypgoto[] =
     712static const yytype_int16 yypgoto[] =
    577713{
    578714     -99,   -99,   -99,   111,   -99,   -99,   -99,   -99,   178,   -99,
    … …  
    588724   If YYTABLE_NINF, syntax error.  */
    589725#define YYTABLE_NINF -68
    590 static const short yytable[] =
     726static const yytype_int16 yytable[] =
    591727{
    592728      66,    67,    36,    42,    39,    40,    71,    41,   123,   124,
    … …  
    613749};
    614750
    615 static const unsigned char yycheck[] =
     751static const yytype_uint8 yycheck[] =
    616752{
    617753      48,    49,     3,    32,     4,     5,    30,     7,    71,    72,
    … …  
    640776/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
    641777   symbol of state STATE-NUM.  */
    642 static const unsigned char yystos[] =
     778static const yytype_uint8 yystos[] =
    643779{
    644780       0,    43,     0,     1,     3,     4,     5,     6,     7,     8,
    … …  
    663799};
    664800
    665 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
    666 # define YYSIZE_T __SIZE_TYPE__
    667 #endif
    668 #if ! defined (YYSIZE_T) && defined (size_t)
    669 # define YYSIZE_T size_t
    670 #endif
    671 #if ! defined (YYSIZE_T)
    672 # if defined (__STDC__) || defined (__cplusplus)
    673 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
    674 #  define YYSIZE_T size_t
    675 # endif
    676 #endif
    677 #if ! defined (YYSIZE_T)
    678 # define YYSIZE_T unsigned int
    679 #endif
    680 
    681801#define yyerrok         (yyerrstatus = 0)
    682802#define yyclearin       (yychar = YYEMPTY)
    … …  
    686806#define YYACCEPT        goto yyacceptlab
    687807#define YYABORT         goto yyabortlab
    688 #define YYERROR         goto yyerrlab1
     808#define YYERROR         goto yyerrorlab
    689809
    690810
    … …  
    704824      yylval = (Value);                                         \
    705825      yytoken = YYTRANSLATE (yychar);                           \
    706       YYPOPSTACK;                                               \
     826      YYPOPSTACK (1);                                           \
    707827      goto yybackup;                                            \
    708828    }                                                           \
    709829  else                                                          \
    710     {                                                           \
    711       yyerror ("syntax error: cannot back up");\
     830    {                                                           \
     831      yyerror (YY_("syntax error: cannot back up")); \
    712832      YYERROR;                                                  \
    713833    }                                                           \
    714 while (0)
     834while (YYID (0))
     835
    715836
    716837#define YYTERROR        1
    717838#define YYERRCODE       256
    718839
    719 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
    720    are run).  */
    721 
     840
     841/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
     842   If N is 0, then set CURRENT to the empty location which ends
     843   the previous symbol: RHS[0] (always defined).  */
     844
     845#define YYRHSLOC(Rhs, K) ((Rhs)[K])
    722846#ifndef YYLLOC_DEFAULT
    723 # define YYLLOC_DEFAULT(Current, Rhs, N)         \
    724   Current.first_line   = Rhs[1].first_line;      \
    725   Current.first_column = Rhs[1].first_column;    \
    726   Current.last_line    = Rhs[N].last_line;       \
    727   Current.last_column  = Rhs[N].last_column;
    728 #endif
     847# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
     848    do                                                                  \
     849      if (YYID (N))                                                    \
     850        {                                                               \
     851          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
     852          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
     853          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
     854          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
     855        }                                                               \
     856      else                                                              \
     857        {                                                               \
     858          (Current).first_line   = (Current).last_line   =              \
     859            YYRHSLOC (Rhs, 0).last_line;                                \
     860          (Current).first_column = (Current).last_column =              \
     861            YYRHSLOC (Rhs, 0).last_column;                              \
     862        }                                                               \
     863    while (YYID (0))
     864#endif
     865
     866
     867/* YY_LOCATION_PRINT -- Print the location on the stream.
     868   This macro was not mandated originally: define only if we know
     869   we won't break user code: when these are the locations we know.  */
     870
     871#ifndef YY_LOCATION_PRINT
     872# if YYLTYPE_IS_TRIVIAL
     873#  define YY_LOCATION_PRINT(File, Loc)                  \
     874     fprintf (File, "%d.%d-%d.%d",                      \
     875              (Loc).first_line, (Loc).first_column,     \
     876              (Loc).last_line,  (Loc).last_column)
     877# else
     878#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
     879# endif
     880#endif
     881
    729882
    730883/* YYLEX -- calling `yylex' with the right arguments.  */
    … …  
    748901  if (yydebug)                                  \
    749902    YYFPRINTF Args;                             \
    750 } while (0)
    751 
    752 # define YYDSYMPRINT(Args)                      \
    753 do {                                            \
    754   if (yydebug)                                  \
    755     yysymprint Args;                            \
    756 } while (0)
    757 
    758 # define YYDSYMPRINTF(Title, Token, Value, Location)            \
    759 do {                                                            \
    760   if (yydebug)                                                  \
    761     {                                                           \
    762       YYFPRINTF (stderr, "%s ", Title);                         \
    763       yysymprint (stderr,                                       \
    764                   Token, Value);        \
    765       YYFPRINTF (stderr, "\n");                                 \
    766     }                                                           \
    767 } while (0)
     903} while (YYID (0))
     904
     905# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
     906do {                                                                      \
     907  if (yydebug)                                                            \
     908    {                                                                     \
     909      YYFPRINTF (stderr, "%s ", Title);                                   \
     910      yy_symbol_print (stderr,                                            \
     911                  Type, Value); \
     912      YYFPRINTF (stderr, "\n");                                           \
     913    }                                                                     \
     914} while (YYID (0))
     915
     916
     917/*--------------------------------.
     918| Print this symbol on YYOUTPUT.  |
     919`--------------------------------*/
     920
     921/*ARGSUSED*/
     922#if (defined __STDC__ || defined __C99__FUNC__ \
     923     || defined __cplusplus || defined _MSC_VER)
     924static void
     925yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
     926#else
     927static void
     928yy_symbol_value_print (yyoutput, yytype, yyvaluep)
     929    FILE *yyoutput;
     930    int yytype;
     931    YYSTYPE const * const yyvaluep;
     932#endif
     933{
     934  if (!yyvaluep)
     935    return;
     936# ifdef YYPRINT
     937  if (yytype < YYNTOKENS)
     938    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
     939# else
     940  YYUSE (yyoutput);
     941# endif
     942  switch (yytype)
     943    {
     944      default:
     945        break;
     946    }
     947}
     948
     949
     950/*--------------------------------.
     951| Print this symbol on YYOUTPUT.  |
     952`--------------------------------*/
     953
     954#if (defined __STDC__ || defined __C99__FUNC__ \
     955     || defined __cplusplus || defined _MSC_VER)
     956static void
     957yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
     958#else
     959static void
     960yy_symbol_print (yyoutput, yytype, yyvaluep)
     961    FILE *yyoutput;
     962    int yytype;
     963    YYSTYPE const * const yyvaluep;
     964#endif
     965{
     966  if (yytype < YYNTOKENS)
     967    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
     968  else
     969    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
     970
     971  yy_symbol_value_print (yyoutput, yytype, yyvaluep);
     972  YYFPRINTF (yyoutput, ")");
     973}
    768974
    769975/*------------------------------------------------------------------.
    770976| yy_stack_print -- Print the state stack from its BOTTOM up to its |
    771 | TOP (cinluded).                                                   |
     977| TOP (included).                                                   |
    772978`------------------------------------------------------------------*/
    773979
    774 #if defined (__STDC__) || defined (__cplusplus)
     980#if (defined __STDC__ || defined __C99__FUNC__ \
     981     || defined __cplusplus || defined _MSC_VER)
    775982static void
    776 yy_stack_print (short *bottom, short *top)
     983yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
    777984#else
    778985static void
    779986yy_stack_print (bottom, top)
    780     short *bottom;
    781     short *top;
     987    yytype_int16 *bottom;
     988    yytype_int16 *top;
    782989#endif
    783990{
    784991  YYFPRINTF (stderr, "Stack now");
    785   for (/* Nothing. */; bottom <= top; ++bottom)
     992  for (; bottom <= top; ++bottom)
    786993    YYFPRINTF (stderr, " %d", *bottom);
    787994  YYFPRINTF (stderr, "\n");
    … …  
    792999  if (yydebug)                                                  \
    7931000    yy_stack_print ((Bottom), (Top));                           \
    794 } while (0)
     1001} while (YYID (0))
    7951002
    7961003
    … …  
    7991006`------------------------------------------------*/
    8001007
    801 #if defined (__STDC__) || defined (__cplusplus)
     1008#if (defined __STDC__ || defined __C99__FUNC__ \
     1009     || defined __cplusplus || defined _MSC_VER)
    8021010static void
    803 yy_reduce_print (int yyrule)
     1011yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
    8041012#else
    8051013static void
    806 yy_reduce_print (yyrule)
     1014yy_reduce_print (yyvsp, yyrule)
     1015    YYSTYPE *yyvsp;
    8071016    int yyrule;
    8081017#endif
    8091018{
     1019  int yynrhs = yyr2[yyrule];
    8101020  int yyi;
    811   unsigned int yylineno = yyrline[yyrule];
    812   YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
    813              yyrule - 1, yylineno);
    814   /* Print the symbols being reduced, and their result.  */
    815   for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
    816     YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
    817   YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
     1021  unsigned long int yylno = yyrline[yyrule];
     1022  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
     1023             yyrule - 1, yylno);
     1024  /* The symbols being reduced.  */
     1025  for (yyi = 0; yyi < yynrhs; yyi++)
     1026    {
     1027      fprintf (stderr, "   $%d = ", yyi + 1);
     1028      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
     1029                       &(yyvsp[(yyi + 1) - (yynrhs)])
     1030                                       );
     1031      fprintf (stderr, "\n");
     1032    }
    8181033}
    8191034
    … …  
    8211036do {                                    \
    8221037  if (yydebug)                          \
    823     yy_reduce_print (Rule);             \
    824 } while (0)
     1038    yy_reduce_print (yyvsp, Rule); \
     1039} while (YYID (0))
    8251040
    8261041/* Nonzero means print parse trace.  It is left uninitialized so that
    … …  
    8291044#else /* !YYDEBUG */
    8301045# define YYDPRINTF(Args)
    831 # define YYDSYMPRINT(Args)
    832 # define YYDSYMPRINTF(Title, Token, Value, Location)
     1046# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
    8331047# define YY_STACK_PRINT(Bottom, Top)
    8341048# define YY_REDUCE_PRINT(Rule)
    … …  
    8451059
    8461060   Do not make this value too large; the results are undefined if
    847    SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
     1061   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
    8481062   evaluated with infinite-precision integer arithmetic.  */
    849 
    850 #if YYMAXDEPTH == 0
    851 # undef YYMAXDEPTH
    852 #endif
    8531063
    8541064#ifndef YYMAXDEPTH
    … …  
    8621072
    8631073# ifndef yystrlen
    864 #  if defined (__GLIBC__) && defined (_STRING_H)
     1074#  if defined __GLIBC__ && defined _STRING_H
    8651075#   define yystrlen strlen
    8661076#  else
    8671077/* Return the length of YYSTR.  */
     1078#if (defined __STDC__ || defined __C99__FUNC__ \
     1079     || defined __cplusplus || defined _MSC_VER)
    8681080static YYSIZE_T
    869 #   if defined (__STDC__) || defined (__cplusplus)
    8701081yystrlen (const char *yystr)
    871 #   else
     1082#else
     1083static YYSIZE_T
    8721084yystrlen (yystr)
    873      const char *yystr;
    874 #   endif
    875 {
    876   register const char *yys = yystr;
    877 
    878   while (*yys++ != '\0')
     1085    const char *yystr;
     1086#endif
     1087{
     1088  YYSIZE_T yylen;
     1089  for (yylen = 0; yystr[yylen]; yylen++)
    8791090    continue;
    880 
    881   return yys - yystr - 1;
     1091  return yylen;
    8821092}
    8831093#  endif
    … …  
    8851095
    8861096# ifndef yystpcpy
    887 #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
     1097#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
    8881098#   define yystpcpy stpcpy
    8891099#  else
    8901100/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
    8911101   YYDEST.  */
     1102#if (defined __STDC__ || defined __C99__FUNC__ \
     1103     || defined __cplusplus || defined _MSC_VER)
    8921104static char *
    893 #   if defined (__STDC__) || defined (__cplusplus)
    8941105yystpcpy (char *yydest, const char *yysrc)
    895 #   else
     1106#else
     1107static char *
    8961108yystpcpy (yydest, yysrc)
    897      char *yydest;
    898      const char *yysrc;
    899 #   endif
    900 {
    901   register char *yyd = yydest;
    902   register const char *yys = yysrc;
     1109    char *yydest;
     1110    const char *yysrc;
     1111#endif
     1112{
     1113  char *yyd = yydest;
     1114  const char *yys = yysrc;
    9031115
    9041116  while ((*yyd++ = *yys++) != '\0')
    … …  
    9101122# endif
    9111123
    912 #endif /* !YYERROR_VERBOSE */
    913 
    914 
    915 
    916 
    917 #if YYDEBUG
    918 /*--------------------------------.
    919 | Print this symbol on YYOUTPUT.  |
    920 `--------------------------------*/
    921 
    922 #if defined (__STDC__) || defined (__cplusplus)
    923 static void
    924 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
    925 #else
    926 static void
    927 yysymprint (yyoutput, yytype, yyvaluep)
    928     FILE *yyoutput;
    929     int yytype;
    930     YYSTYPE *yyvaluep;
    931 #endif
    932 {
    933   /* Pacify ``unused variable'' warnings.  */
    934   (void) yyvaluep;
    935 
    936   if (yytype < YYNTOKENS)
    937     {
    938       YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
    939 # ifdef YYPRINT
    940       YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
     1124# ifndef yytnamerr
     1125/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
     1126   quotes and backslashes, so that it's suitable for yyerror.  The
     1127   heuristic is that double-quoting is unnecessary unless the string
     1128   contains an apostrophe, a comma, or backslash (other than
     1129   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
     1130   null, do not copy; instead, return the length of what the result
     1131   would have been.  */
     1132static YYSIZE_T
     1133yytnamerr (char *yyres, const char *yystr)
     1134{
     1135  if (*yystr == '"')
     1136    {
     1137      YYSIZE_T yyn = 0;
     1138      char const *yyp = yystr;
     1139
     1140      for (;;)
     1141        switch (*++yyp)
     1142          {
     1143          case '\'':
     1144          case ',':
     1145            goto do_not_strip_quotes;
     1146
     1147          case '\\':
     1148            if (*++yyp != '\\')
     1149              goto do_not_strip_quotes;
     1150            /* Fall through.  */
     1151          default:
     1152            if (yyres)
     1153              yyres[yyn] = *yyp;
     1154            yyn++;
     1155            break;
     1156
     1157          case '"':
     1158            if (yyres)
     1159              yyres[yyn] = '\0';
     1160            return yyn;
     1161          }
     1162    do_not_strip_quotes: ;
     1163    }
     1164
     1165  if (! yyres)
     1166    return yystrlen (yystr);
     1167
     1168  return yystpcpy (yyres, yystr) - yyres;
     1169}
    9411170# endif
     1171
     1172/* Copy into YYRESULT an error message about the unexpected token
     1173   YYCHAR while in state YYSTATE.  Return the number of bytes copied,
     1174   including the terminating null byte.  If YYRESULT is null, do not
     1175   copy anything; just return the number of bytes that would be
     1176   copied.  As a special case, return 0 if an ordinary "syntax error"
     1177   message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
     1178   size calculation.  */
     1179static YYSIZE_T
     1180yysyntax_error (char *yyresult, int yystate, int yychar)
     1181{
     1182  int yyn = yypact[yystate];
     1183
     1184  if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
     1185    return 0;
     1186  else
     1187    {
     1188      int yytype = YYTRANSLATE (yychar);
     1189      YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
     1190      YYSIZE_T yysize = yysize0;
     1191      YYSIZE_T yysize1;
     1192      int yysize_overflow = 0;
     1193      enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
     1194      char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
     1195      int yyx;
     1196
     1197# if 0
     1198      /* This is so xgettext sees the translatable formats that are
     1199         constructed on the fly.  */
     1200      YY_("syntax error, unexpected %s");
     1201      YY_("syntax error, unexpected %s, expecting %s");
     1202      YY_("syntax error, unexpected %s, expecting %s or %s");
     1203      YY_("syntax error, unexpected %s, expecting %s or %s or %s");
     1204      YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
     1205# endif
     1206      char *yyfmt;
     1207      char const *yyf;
     1208      static char const yyunexpected[] = "syntax error, unexpected %s";
     1209      static char const yyexpecting[] = ", expecting %s";
     1210      static char const yyor[] = " or %s";
     1211      char yyformat[sizeof yyunexpected
     1212                    + sizeof yyexpecting - 1
     1213                    + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
     1214                       * (sizeof yyor - 1))];
     1215      char const *yyprefix = yyexpecting;
     1216
     1217      /* Start YYX at -YYN if negative to avoid negative indexes in
     1218         YYCHECK.  */
     1219      int yyxbegin = yyn < 0 ? -yyn : 0;
     1220
     1221      /* Stay within bounds of both yycheck and yytname.  */
     1222      int yychecklim = YYLAST - yyn + 1;
     1223      int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
     1224      int yycount = 1;
     1225
     1226      yyarg[0] = yytname[yytype];
     1227      yyfmt = yystpcpy (yyformat, yyunexpected);
     1228
     1229      for (yyx = yyxbegin; yyx < yyxend; ++yyx)
     1230        if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
     1231          {
     1232            if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
     1233              {
     1234                yycount = 1;
     1235                yysize = yysize0;
     1236                yyformat[sizeof yyunexpected - 1] = '\0';
     1237                break;
     1238              }
     1239            yyarg[yycount++] = yytname[yyx];
     1240            yysize1 = yysize + yytnamerr (0, yytname[yyx]);
     1241            yysize_overflow |= (yysize1 < yysize);
     1242            yysize = yysize1;
     1243            yyfmt = yystpcpy (yyfmt, yyprefix);
     1244            yyprefix = yyor;
     1245          }
     1246
     1247      yyf = YY_(yyformat);
     1248      yysize1 = yysize + yystrlen (yyf);
     1249      yysize_overflow |= (yysize1 < yysize);
     1250      yysize = yysize1;
     1251
     1252      if (yysize_overflow)
     1253        return YYSIZE_MAXIMUM;
     1254
     1255      if (yyresult)
     1256        {
     1257          /* Avoid sprintf, as that infringes on the user's name space.
     1258             Don't have undefined behavior even if the translation
     1259             produced a string with the wrong number of "%s"s.  */
     1260          char *yyp = yyresult;
     1261          int yyi = 0;
     1262          while ((*yyp = *yyf) != '\0')
     1263            {
     1264              if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
     1265                {
     1266                  yyp += yytnamerr (yyp, yyarg[yyi++]);
     1267                  yyf += 2;
     1268                }
     1269              else
     1270                {
     1271                  yyp++;
     1272                  yyf++;
     1273                }
     1274            }
     1275        }
     1276      return yysize;
    9421277    }
    943   else
    944     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
    945 
    946   switch (yytype)
    947     {
    948       default:
    949         break;
    950     }
    951   YYFPRINTF (yyoutput, ")");
    9521278}
    953 
    954 #endif /* ! YYDEBUG */
     1279#endif /* YYERROR_VERBOSE */
     1280
     1281
     1282
    9551283/*-----------------------------------------------.
    9561284| Release the memory associated to this symbol.  |
    9571285`-----------------------------------------------*/
    9581286
    959 #if defined (__STDC__) || defined (__cplusplus)
     1287/*ARGSUSED*/
     1288#if (defined __STDC__ || defined __C99__FUNC__ \
     1289     || defined __cplusplus || defined _MSC_VER)
    9601290static void
    961 yydestruct (int yytype, YYSTYPE *yyvaluep)
     1291yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
    9621292#else
    9631293static void
    964 yydestruct (yytype, yyvaluep)
     1294yydestruct (yymsg, yytype, yyvaluep)
     1295    const char *yymsg;
    9651296    int yytype;
    9661297    YYSTYPE *yyvaluep;
    9671298#endif
    9681299{
    969   /* Pacify ``unused variable'' warnings.  */
    970   (void) yyvaluep;
     1300  YYUSE (yyvaluep);
     1301
     1302  if (!yymsg)
     1303    yymsg = "Deleting";
     1304  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
    9711305
    9721306  switch (yytype)
    … …  
    9741308
    9751309      default:
    976         break;
     1310        break;
    9771311    }
    9781312}
    … …  
    9831317
    9841318#ifdef YYPARSE_PARAM
    985 # if defined (__STDC__) || defined (__cplusplus)
     1319#if defined __STDC__ || defined __cplusplus
    9861320int yyparse (void *YYPARSE_PARAM);
    987 # else
     1321#else
    9881322int yyparse ();
    989 # endif
     1323#endif
    9901324#else /* ! YYPARSE_PARAM */
    991 #if defined (__STDC__) || defined (__cplusplus)
     1325#if defined __STDC__ || defined __cplusplus
    9921326int yyparse (void);
    9931327#else
    … …  
    9981332
    9991333
    1000 /* The lookahead symbol.  */
     1334/* The look-ahead symbol.  */
    10011335int yychar;
    10021336
    1003 /* The semantic value of the lookahead symbol.  */
     1337/* The semantic value of the look-ahead symbol.  */
    10041338YYSTYPE yylval;
    10051339
    … …  
    10141348
    10151349#ifdef YYPARSE_PARAM
    1016 # if defined (__STDC__) || defined (__cplusplus)
    1017 int yyparse (void *YYPARSE_PARAM)
    1018 # else
    1019 int yyparse (YYPARSE_PARAM)
    1020   void *YYPARSE_PARAM;
    1021 # endif
     1350#if (defined __STDC__ || defined __C99__FUNC__ \
     1351     || defined __cplusplus || defined _MSC_VER)
     1352int
     1353yyparse (void *YYPARSE_PARAM)
     1354#else
     1355int
     1356yyparse (YYPARSE_PARAM)
     1357    void *YYPARSE_PARAM;
     1358#endif
    10221359#else /* ! YYPARSE_PARAM */
    1023 #if defined (__STDC__) || defined (__cplusplus)
     1360#if (defined __STDC__ || defined __C99__FUNC__ \
     1361     || defined __cplusplus || defined _MSC_VER)
    10241362int
    10251363yyparse (void)
    … …  
    10311369#endif
    10321370{
    1033 
    1034   register int yystate;
    1035   register int yyn;
     1371 
     1372  int yystate;
     1373  int yyn;
    10361374  int yyresult;
    10371375  /* Number of tokens to shift before error messages enabled.  */
    10381376  int yyerrstatus;
    1039   /* Lookahead token as an internal (translated) token number.  */
     1377  /* Look-ahead token as an internal (translated) token number.  */
    10401378  int yytoken = 0;
     1379#if YYERROR_VERBOSE
     1380  /* Buffer for error messages, and its allocated size.  */
     1381  char yymsgbuf[128];
     1382  char *yymsg = yymsgbuf;
     1383  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
     1384#endif
    10411385
    10421386  /* Three stacks and their tools:
    … …  
    10491393
    10501394  /* The state stack.  */
    1051   short yyssa[YYINITDEPTH];
    1052   short *yyss = yyssa;
    1053   register short *yyssp;
     1395  yytype_int16 yyssa[YYINITDEPTH];
     1396  yytype_int16 *yyss = yyssa;
     1397  yytype_int16 *yyssp;
    10541398
    10551399  /* The semantic value stack.  */
    10561400  YYSTYPE yyvsa[YYINITDEPTH];
    10571401  YYSTYPE *yyvs = yyvsa;
    1058   register YYSTYPE *yyvsp;
    1059 
    1060 
    1061 
    1062 #define YYPOPSTACK   (yyvsp--, yyssp--)
     1402  YYSTYPE *yyvsp;
     1403
     1404
     1405
     1406#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
    10631407
    10641408  YYSIZE_T yystacksize = YYINITDEPTH;
    … …  
    10691413
    10701414
    1071   /* When reducing, the number of symbols on the RHS of the reduced
    1072      rule.  */
    1073   int yylen;
     1415  /* The number of symbols on the RHS of the reduced rule.
     1416     Keep to zero when no symbol should be popped.  */
     1417  int yylen = 0;
    10741418
    10751419  YYDPRINTF ((stderr, "Starting parse\n"));
    … …  
    10951439 yynewstate:
    10961440  /* In all cases, when you get here, the value and location stacks
    1097      have just been pushed. so pushing a state here evens the stacks.
    1098      */
     1441     have just been pushed.  So pushing a state here evens the stacks.  */
    10991442  yyssp++;
    11001443
    … …  
    11091452#ifdef yyoverflow
    11101453      {
    1111         /* Give user a chance to reallocate the stack. Use copies of
     1454        /* Give user a chance to reallocate the stack.  Use copies of
    11121455           these so that the &'s don't force the real ones into
    11131456           memory.  */
    11141457        YYSTYPE *yyvs1 = yyvs;
    1115         short *yyss1 = yyss;
     1458        yytype_int16 *yyss1 = yyss;
    11161459
    11171460
    … …  
    11201463           conditional around just the two extra args, but that might
    11211464           be undefined if yyoverflow is a macro.  */
    1122         yyoverflow ("parser stack overflow",
     1465        yyoverflow (YY_("memory exhausted"),
    11231466                    &yyss1, yysize * sizeof (*yyssp),
    11241467                    &yyvs1, yysize * sizeof (*yyvsp),
    … …  
    11311474#else /* no yyoverflow */
    11321475# ifndef YYSTACK_RELOCATE
    1133       goto yyoverflowlab;
     1476      goto yyexhaustedlab;
    11341477# else
    11351478      /* Extend the stack our own way.  */
    11361479      if (YYMAXDEPTH <= yystacksize)
    1137         goto yyoverflowlab;
     1480        goto yyexhaustedlab;
    11381481      yystacksize *= 2;
    11391482      if (YYMAXDEPTH < yystacksize)
    … …  
    11411484
    11421485      {
    1143         short *yyss1 = yyss;
     1486        yytype_int16 *yyss1 = yyss;
    11441487        union yyalloc *yyptr =
    11451488          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
    11461489        if (! yyptr)
    1147           goto yyoverflowlab;
     1490          goto yyexhaustedlab;
    11481491        YYSTACK_RELOCATE (yyss);
    11491492        YYSTACK_RELOCATE (yyvs);
    … …  
    11761519yybackup:
    11771520
    1178 /* Do appropriate processing given the current state.  */
    1179 /* Read a lookahead token if we need one and don't already have one.  */
    1180 /* yyresume: */
    1181 
    1182   /* First try to decide what to do without reference to lookahead token.  */
    1183 
     1521  /* Do appropriate processing given the current state.  Read a
     1522     look-ahead token if we need one and don't already have one.  */
     1523
     1524  /* First try to decide what to do without reference to look-ahead token.  */
    11841525  yyn = yypact[yystate];
    11851526  if (yyn == YYPACT_NINF)
    11861527    goto yydefault;
    11871528
    1188   /* Not known => get a lookahead token if don't already have one.  */
    1189 
    1190   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
     1529  /* Not known => get a look-ahead token if don't already have one.  */
     1530
     1531  /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
    11911532  if (yychar == YYEMPTY)
    11921533    {
    … …  
    12031544    {
    12041545      yytoken = YYTRANSLATE (yychar);
    1205       YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
     1546      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
    12061547    }
    12071548
    … …  
    12231564    YYACCEPT;
    12241565
    1225   /* Shift the lookahead token.  */
    1226   YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
    1227 
    1228   /* Discard the token being shifted unless it is eof.  */
    1229   if (yychar != YYEOF)
    1230     yychar = YYEMPTY;
    1231 
    1232   *++yyvsp = yylval;
    1233 
    1234 
    12351566  /* Count tokens shifted since error; after three, turn off error
    12361567     status.  */
    … …  
    12381569    yyerrstatus--;
    12391570
     1571  /* Shift the look-ahead token.  */
     1572  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
     1573
     1574  /* Discard the shifted token unless it is eof.  */
     1575  if (yychar != YYEOF)
     1576    yychar = YYEMPTY;
     1577
    12401578  yystate = yyn;
     1579  *++yyvsp = yylval;
     1580
    12411581  goto yynewstate;
    12421582
    … …  
    12741614    {
    12751615        case 8:
    1276 
     1616#line 102 "zconf.y"
    12771617    { zconfprint("unexpected 'endmenu' statement"); ;}
    12781618    break;
    12791619
    12801620  case 9:
    1281 
     1621#line 103 "zconf.y"
    12821622    { zconfprint("unexpected 'endif' statement"); ;}
    12831623    break;
    12841624
    12851625  case 10:
    1286 
     1626#line 104 "zconf.y"
    12871627    { zconfprint("unexpected 'endchoice' statement"); ;}
    12881628    break;
    12891629
    12901630  case 11:
    1291 
     1631#line 105 "zconf.y"
    12921632    { zconfprint("syntax error"); yyerrok; ;}
    12931633    break;
    12941634
    12951635  case 18:
    1296 
    1297     {
    1298         struct symbol *sym = sym_lookup(yyvsp[-1].string, 0);
     1636#line 121 "zconf.y"
     1637    {
     1638        struct symbol *sym = sym_lookup((yyvsp[(2) - (3)].string), 0);
    12991639        sym->flags |= SYMBOL_OPTIONAL;
    13001640        menu_add_entry(sym);
    1301         printd(DEBUG_PARSE, "%s:%d:config %s\n", zconf_curname(), zconf_lineno(), yyvsp[-1].string);
     1641        printd(DEBUG_PARSE, "%s:%d:config %s\n", zconf_curname(), zconf_lineno(), (yyvsp[(2) - (3)].string));
    13021642;}
    13031643    break;
    13041644
    13051645  case 19:
    1306 
     1646#line 129 "zconf.y"
    13071647    {
    13081648        menu_end_entry();
    … …  
    13121652
    13131653  case 20:
    1314 
    1315     {
    1316         struct symbol *sym = sym_lookup(yyvsp[-1].string, 0);
     1654#line 135 "zconf.y"
     1655    {
     1656        struct symbol *sym = sym_lookup((yyvsp[(2) - (3)].string), 0);
    13171657        sym->flags |= SYMBOL_OPTIONAL;
    13181658        menu_add_entry(sym);
    1319         printd(DEBUG_PARSE, "%s:%d:menuconfig %s\n", zconf_curname(), zconf_lineno(), yyvsp[-1].string);
     1659        printd(DEBUG_PARSE, "%s:%d:menuconfig %s\n", zconf_curname(), zconf_lineno(), (yyvsp[(2) - (3)].string));
    13201660;}
    13211661    break;
    13221662
    13231663  case 21:
    1324 
     1664#line 143 "zconf.y"
    13251665    {
    13261666        if (current_entry->prompt)
    … …  
    13341674
    13351675  case 27:
    1336 
     1676#line 161 "zconf.y"
    13371677    {
    13381678        menu_set_type(S_TRISTATE);
    … …  
    13421682
    13431683  case 28:
    1344 
    1345     {
    1346         menu_add_expr(P_DEFAULT, yyvsp[-2].expr, yyvsp[-1].expr);
     1684#line 167 "zconf.y"
     1685    {
     1686        menu_add_expr(P_DEFAULT, (yyvsp[(2) - (4)].expr), (yyvsp[(3) - (4)].expr));
    13471687        menu_set_type(S_TRISTATE);
    13481688        printd(DEBUG_PARSE, "%s:%d:def_boolean\n", zconf_curname(), zconf_lineno());
    … …  
    13511691
    13521692  case 29:
    1353 
     1693#line 174 "zconf.y"
    13541694    {
    13551695        menu_set_type(S_BOOLEAN);
    … …  
    13591699
    13601700  case 30:
    1361 
    1362     {
    1363         menu_add_expr(P_DEFAULT, yyvsp[-2].expr, yyvsp[-1].expr);
     1701#line 180 "zconf.y"
     1702    {
     1703        menu_add_expr(P_DEFAULT, (yyvsp[(2) - (4)].expr), (yyvsp[(3) - (4)].expr));
    13641704        menu_set_type(S_BOOLEAN);
    13651705        printd(DEBUG_PARSE, "%s:%d:def_boolean\n", zconf_curname(), zconf_lineno());
    … …  
    13681708
    13691709  case 31:
    1370 
     1710#line 187 "zconf.y"
    13711711    {
    13721712        menu_set_type(S_INT);
    … …  
    13761716
    13771717  case 32:
    1378 
     1718#line 193 "zconf.y"
    13791719    {
    13801720        menu_set_type(S_HEX);
    … …  
    13841724
    13851725  case 33:
    1386 
     1726#line 199 "zconf.y"
    13871727    {
    13881728        menu_set_type(S_STRING);
    … …  
    13921732
    13931733  case 34:
    1394 
    1395     {
    1396         menu_add_prompt(P_PROMPT, yyvsp[-2].string, yyvsp[-1].expr);
     1734#line 205 "zconf.y"
     1735    {
     1736        menu_add_prompt(P_PROMPT, (yyvsp[(2) - (4)].string), (yyvsp[(3) - (4)].expr));
    13971737        printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno());
    13981738;}
    … …  
    14001740
    14011741  case 35:
    1402 
    1403     {
    1404         menu_add_expr(P_DEFAULT, yyvsp[-2].expr, yyvsp[-1].expr);
     1742#line 211 "zconf.y"
     1743    {
     1744        menu_add_expr(P_DEFAULT, (yyvsp[(2) - (4)].expr), (yyvsp[(3) - (4)].expr));
    14051745        printd(DEBUG_PARSE, "%s:%d:default\n", zconf_curname(), zconf_lineno());
    14061746;}
    … …  
    14081748
    14091749  case 36:
    1410 
    1411     {
    1412         menu_add_symbol(P_SELECT, sym_lookup(yyvsp[-2].string, 0), yyvsp[-1].expr);
     1750#line 217 "zconf.y"
     1751    {
     1752        menu_add_symbol(P_SELECT, sym_lookup((yyvsp[(2) - (4)].string), 0), (yyvsp[(3) - (4)].expr));
    14131753        printd(DEBUG_PARSE, "%s:%d:select\n", zconf_curname(), zconf_lineno());
    14141754;}
    … …  
    14161756
    14171757  case 37:
    1418 
    1419     {
    1420         menu_add_expr(P_RANGE, expr_alloc_comp(E_RANGE,yyvsp[-3].symbol, yyvsp[-2].symbol), yyvsp[-1].expr);
     1758#line 223 "zconf.y"
     1759    {
     1760        menu_add_expr(P_RANGE, expr_alloc_comp(E_RANGE,(yyvsp[(2) - (5)].symbol), (yyvsp[(3) - (5)].symbol)), (yyvsp[(4) - (5)].expr));
    14211761        printd(DEBUG_PARSE, "%s:%d:range\n", zconf_curname(), zconf_lineno());
    14221762;}
    … …  
    14241764
    14251765  case 38:
    1426 
     1766#line 231 "zconf.y"
    14271767    {
    14281768        struct symbol *sym = sym_lookup(NULL, 0);
    … …  
    14351775
    14361776  case 39:
    1437 
     1777#line 240 "zconf.y"
    14381778    {
    14391779        menu_end_entry();
    … …  
    14431783
    14441784  case 40:
    1445 
    1446     {
    1447         if (zconf_endtoken(yyvsp[0].token, T_CHOICE, T_ENDCHOICE)) {
     1785#line 246 "zconf.y"
     1786    {
     1787        if (zconf_endtoken((yyvsp[(1) - (1)].token), T_CHOICE, T_ENDCHOICE)) {
    14481788                menu_end_menu();
    14491789                printd(DEBUG_PARSE, "%s:%d:endchoice\n", zconf_curname(), zconf_lineno());
    … …  
    14531793
    14541794  case 42:
    1455 
     1795#line 256 "zconf.y"
    14561796    {
    14571797        printf("%s:%d: missing 'endchoice' for this 'choice' statement\n", current_menu->file->name, current_menu->lineno);
    … …  
    14611801
    14621802  case 48:
    1463 
    1464     {
    1465         menu_add_prompt(P_PROMPT, yyvsp[-2].string, yyvsp[-1].expr);
     1803#line 270 "zconf.y"
     1804    {
     1805        menu_add_prompt(P_PROMPT, (yyvsp[(2) - (4)].string), (yyvsp[(3) - (4)].expr));
    14661806        printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno());
    14671807;}
    … …  
    14691809
    14701810  case 49:
    1471 
     1811#line 276 "zconf.y"
    14721812    {
    14731813        menu_set_type(S_TRISTATE);
    … …  
    14771817
    14781818  case 50:
    1479 
     1819#line 282 "zconf.y"
    14801820    {
    14811821        menu_set_type(S_BOOLEAN);
    … …  
    14851825
    14861826  case 51:
    1487 
     1827#line 288 "zconf.y"
    14881828    {
    14891829        current_entry->sym->flags |= SYMBOL_OPTIONAL;
    … …  
    14931833
    14941834  case 52:
    1495 
    1496     {
    1497         menu_add_symbol(P_DEFAULT, sym_lookup(yyvsp[-2].string, 0), yyvsp[-1].expr);
     1835#line 294 "zconf.y"
     1836    {
     1837        menu_add_symbol(P_DEFAULT, sym_lookup((yyvsp[(2) - (4)].string), 0), (yyvsp[(3) - (4)].expr));
    14981838        printd(DEBUG_PARSE, "%s:%d:default\n", zconf_curname(), zconf_lineno());
    14991839;}
    … …  
    15011841
    15021842  case 55:
    1503 
     1843#line 307 "zconf.y"
    15041844    {
    15051845        printd(DEBUG_PARSE, "%s:%d:if\n", zconf_curname(), zconf_lineno());
    15061846        menu_add_entry(NULL);
    1507         menu_add_dep(yyvsp[-1].expr);
     1847        menu_add_dep((yyvsp[(2) - (3)].expr));
    15081848        menu_end_entry();
    15091849        menu_add_menu();
    … …  
    15121852
    15131853  case 56:
    1514 
    1515     {
    1516         if (zconf_endtoken(yyvsp[0].token, T_IF, T_ENDIF)) {
     1854#line 316 "zconf.y"
     1855    {
     1856        if (zconf_endtoken((yyvsp[(1) - (1)].token), T_IF, T_ENDIF)) {
    15171857                menu_end_menu();
    15181858                printd(DEBUG_PARSE, "%s:%d:endif\n", zconf_curname(), zconf_lineno());
    … …  
    15221862
    15231863  case 58:
    1524 
     1864#line 326 "zconf.y"
    15251865    {
    15261866        printf("%s:%d: missing 'endif' for this 'if' statement\n", current_menu->file->name, current_menu->lineno);
    … …  
    15301870
    15311871  case 63:
    1532 
     1872#line 341 "zconf.y"
    15331873    {
    15341874        menu_add_entry(NULL);
    1535         menu_add_prop(P_MENU, yyvsp[-1].string, NULL, NULL);
     1875        menu_add_prop(P_MENU, (yyvsp[(2) - (3)].string), NULL, NULL);
    15361876        printd(DEBUG_PARSE, "%s:%d:menu\n", zconf_curname(), zconf_lineno());
    15371877;}
    … …  
    15391879
    15401880  case 64:
    1541 
     1881#line 348 "zconf.y"
    15421882    {
    15431883        menu_end_entry();
    … …  
    15471887
    15481888  case 65:
    1549 
    1550     {
    1551         if (zconf_endtoken(yyvsp[0].token, T_MENU, T_ENDMENU)) {
     1889#line 354 "zconf.y"
     1890    {
     1891        if (zconf_endtoken((yyvsp[(1) - (1)].token), T_MENU, T_ENDMENU)) {
    15521892                menu_end_menu();
    15531893                printd(DEBUG_PARSE, "%s:%d:endmenu\n", zconf_curname(), zconf_lineno());
    … …  
    15571897
    15581898  case 67:
    1559 
     1899#line 364 "zconf.y"
    15601900    {
    15611901        printf("%s:%d: missing 'endmenu' for this 'menu' statement\n", current_menu->file->name, current_menu->lineno);
    … …  
    15651905
    15661906  case 72:
    1567 
     1907#line 374 "zconf.y"
    15681908    { zconfprint("invalid menu option"); yyerrok; ;}
    15691909    break;
    15701910
    15711911  case 73:
    1572 
    1573     {
    1574         yyval.string = yyvsp[-1].string;
    1575         printd(DEBUG_PARSE, "%s:%d:source %s\n", zconf_curname(), zconf_lineno(), yyvsp[-1].string);
     1912#line 378 "zconf.y"
     1913    {
     1914        (yyval.string) = (yyvsp[(2) - (3)].string);
     1915        printd(DEBUG_PARSE, "%s:%d:source %s\n", zconf_curname(), zconf_lineno(), (yyvsp[(2) - (3)].string));
    15761916;}
    15771917    break;
    15781918
    15791919  case 74:
    1580 
    1581     {
    1582         zconf_nextfile(yyvsp[0].string);
     1920#line 384 "zconf.y"
     1921    {
     1922        zconf_nextfile((yyvsp[(1) - (1)].string));
    15831923;}
    15841924    break;
    15851925
    15861926  case 75:
    1587 
     1927#line 391 "zconf.y"
    15881928    {
    15891929        menu_add_entry(NULL);
    1590         menu_add_prop(P_COMMENT, yyvsp[-1].string, NULL, NULL);
     1930        menu_add_prop(P_COMMENT, (yyvsp[(2) - (3)].string), NULL, NULL);
    15911931        printd(DEBUG_PARSE, "%s:%d:comment\n", zconf_curname(), zconf_lineno());
    15921932;}
    … …  
    15941934
    15951935  case 76:
    1596 
     1936#line 398 "zconf.y"
    15971937    {
    15981938        menu_end_entry();
    … …  
    16011941
    16021942  case 77:
    1603 
     1943#line 405 "zconf.y"
    16041944    {
    16051945        printd(DEBUG_PARSE, "%s:%d:help\n", zconf_curname(), zconf_lineno());
    … …  
    16091949
    16101950  case 78:
    1611 
    1612     {
    1613         current_entry->sym->help = yyvsp[0].string;
     1951#line 411 "zconf.y"
     1952    {
     1953        current_entry->sym->help = (yyvsp[(2) - (2)].string);
    16141954;}
    16151955    break;
    16161956
    16171957  case 82:
    1618 
    1619     {
    1620         menu_add_dep(yyvsp[-1].expr);
     1958#line 423 "zconf.y"
     1959    {
     1960        menu_add_dep((yyvsp[(3) - (4)].expr));
    16211961        printd(DEBUG_PARSE, "%s:%d:depends on\n", zconf_curname(), zconf_lineno());
    16221962;}
    … …  
    16241964
    16251965  case 83:
    1626 
    1627     {
    1628         menu_add_dep(yyvsp[-1].expr);
     1966#line 428 "zconf.y"
     1967    {
     1968        menu_add_dep((yyvsp[(2) - (3)].expr));
    16291969        printd(DEBUG_PARSE, "%s:%d:depends\n", zconf_curname(), zconf_lineno());
    16301970;}
    … …  
    16321972
    16331973  case 84:
    1634 
    1635     {
    1636         menu_add_dep(yyvsp[-1].expr);
     1974#line 433 "zconf.y"
     1975    {
     1976        menu_add_dep((yyvsp[(2) - (3)].expr));
    16371977        printd(DEBUG_PARSE, "%s:%d:requires\n", zconf_curname(), zconf_lineno());
    16381978;}
    … …  
    16401980
    16411981  case 86:
    1642 
    1643     {
    1644         menu_add_prop(P_PROMPT, yyvsp[-1].string, NULL, yyvsp[0].expr);
     1982#line 443 "zconf.y"
     1983    {
     1984        menu_add_prop(P_PROMPT, (yyvsp[(1) - (2)].string), NULL, (yyvsp[(2) - (2)].expr));
    16451985;}
    16461986    break;
    16471987
    16481988  case 89:
    1649 
    1650     { yyval.token = T_ENDMENU; ;}
     1989#line 451 "zconf.y"
     1990    { (yyval.token) = T_ENDMENU; ;}
    16511991    break;
    16521992
    16531993  case 90:
    1654 
    1655     { yyval.token = T_ENDCHOICE; ;}
     1994#line 452 "zconf.y"
     1995    { (yyval.token) = T_ENDCHOICE; ;}
    16561996    break;
    16571997
    16581998  case 91:
    1659 
    1660     { yyval.token = T_ENDIF; ;}
     1999#line 453 "zconf.y"
     2000    { (yyval.token) = T_ENDIF; ;}
    16612001    break;
    16622002
    16632003  case 94:
    1664 
    1665     { yyval.expr = NULL; ;}
     2004#line 459 "zconf.y"
     2005    { (yyval.expr) = NULL; ;}
    16662006    break;
    16672007
    16682008  case 95:
    1669 
    1670     { yyval.expr = yyvsp[0].expr; ;}
     2009#line 460 "zconf.y"
     2010    { (yyval.expr) = (yyvsp[(2) - (2)].expr); ;}
    16712011    break;
    16722012
    16732013  case 96:
    1674 
    1675     { yyval.expr = expr_alloc_symbol(yyvsp[0].symbol); ;}
     2014#line 463 "zconf.y"
     2015    { (yyval.expr) = expr_alloc_symbol((yyvsp[(1) - (1)].symbol)); ;}
    16762016    break;
    16772017
    16782018  case 97:
    1679 
    1680     { yyval.expr = expr_alloc_comp(E_EQUAL, yyvsp[-2].symbol, yyvsp[0].symbol); ;}
     2019#line 464 "zconf.y"
     2020    { (yyval.expr) = expr_alloc_comp(E_EQUAL, (yyvsp[(1) - (3)].symbol), (yyvsp[(3) - (3)].symbol)); ;}
    16812021    break;
    16822022
    16832023  case 98:
    1684 
    1685     { yyval.expr = expr_alloc_comp(E_UNEQUAL, yyvsp[-2].symbol, yyvsp[0].symbol); ;}
     2024#line 465 "zconf.y"
     2025    { (yyval.expr) = expr_alloc_comp(E_UNEQUAL, (yyvsp[(1) - (3)].symbol), (yyvsp[(3) - (3)].symbol)); ;}
    16862026    break;
    16872027
    16882028  case 99:
    1689 
    1690     { yyval.expr = yyvsp[-1].expr; ;}
     2029#line 466 "zconf.y"
     2030    { (yyval.expr) = (yyvsp[(2) - (3)].expr); ;}
    16912031    break;
    16922032
    16932033  case 100:
    1694 
    1695     { yyval.expr = expr_alloc_one(E_NOT, yyvsp[0].expr); ;}
     2034#line 467 "zconf.y"
     2035    { (yyval.expr) = expr_alloc_one(E_NOT, (yyvsp[(2) - (2)].expr)); ;}
    16962036    break;
    16972037
    16982038  case 101:
    1699 
    1700     { yyval.expr = expr_alloc_two(E_OR, yyvsp[-2].expr, yyvsp[0].expr); ;}
     2039#line 468 "zconf.y"
     2040    { (yyval.expr) = expr_alloc_two(E_OR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
    17012041    break;
    17022042
    17032043  case 102:
    1704 
    1705     { yyval.expr = expr_alloc_two(E_AND, yyvsp[-2].expr, yyvsp[0].expr); ;}
     2044#line 469 "zconf.y"
     2045    { (yyval.expr) = expr_alloc_two(E_AND, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;}
    17062046    break;
    17072047
    17082048  case 103:
    1709 
    1710     { yyval.symbol = sym_lookup(yyvsp[0].string, 0); free(yyvsp[0].string); ;}
     2049#line 472 "zconf.y"
     2050    { (yyval.symbol) = sym_lookup((yyvsp[(1) - (1)].string), 0); free((yyvsp[(1) - (1)].string)); ;}
    17112051    break;
    17122052
    17132053  case 104:
    1714 
    1715     { yyval.symbol = sym_lookup(yyvsp[0].string, 1); free(yyvsp[0].string); ;}
    1716     break;
    1717 
    1718 
     2054#line 473 "zconf.y"
     2055    { (yyval.symbol) = sym_lookup((yyvsp[(1) - (1)].string), 1); free((yyvsp[(1) - (1)].string)); ;}
     2056    break;
     2057
     2058
     2059/* Line 1267 of yacc.c.  */
     2060#line 2058 "zconf.tab.c"
     2061      default: break;
    17192062    }
    1720 
    1721 /* Line 999 of yacc.c.  */
    1722 
    1723 
    1724 
    1725   yyvsp -= yylen;
    1726   yyssp -= yylen;
    1727 
    1728 
     2063  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
     2064
     2065  YYPOPSTACK (yylen);
     2066  yylen = 0;
    17292067  YY_STACK_PRINT (yyss, yyssp);
    17302068
    … …  
    17552093    {
    17562094      ++yynerrs;
    1757 #if YYERROR_VERBOSE
    1758       yyn = yypact[yystate];
    1759 
    1760       if (YYPACT_NINF < yyn && yyn < YYLAST)
     2095#if ! YYERROR_VERBOSE
     2096      yyerror (YY_("syntax error"));
     2097#else
     2098      {
     2099        YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
     2100        if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
     2101          {
     2102            YYSIZE_T yyalloc = 2 * yysize;
     2103            if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
     2104              yyalloc = YYSTACK_ALLOC_MAXIMUM;
     2105            if (yymsg != yymsgbuf)
     2106              YYSTACK_FREE (yymsg);
     2107            yymsg = (char *) YYSTACK_ALLOC (yyalloc);
     2108            if (yymsg)
     2109              yymsg_alloc = yyalloc;
     2110            else
     2111              {
     2112                yymsg = yymsgbuf;
     2113                yymsg_alloc = sizeof yymsgbuf;
     2114              }
     2115          }
     2116
     2117        if (0 < yysize && yysize <= yymsg_alloc)
     2118          {
     2119            (void) yysyntax_error (yymsg, yystate, yychar);
     2120            yyerror (yymsg);
     2121          }
     2122        else
     2123          {
     2124            yyerror (YY_("syntax error"));
     2125            if (yysize != 0)
     2126              goto yyexhaustedlab;
     2127          }
     2128      }
     2129#endif
     2130    }
     2131
     2132
     2133
     2134  if (yyerrstatus == 3)
     2135    {
     2136      /* If just tried and failed to reuse look-ahead token after an
     2137         error, discard it.  */
     2138
     2139      if (yychar <= YYEOF)
    17612140        {
    1762           YYSIZE_T yysize = 0;
    1763           int yytype = YYTRANSLATE (yychar);
    1764           char *yymsg;
    1765           int yyx, yycount;
    1766 
    1767           yycount = 0;
    1768           /* Start YYX at -YYN if negative to avoid negative indexes in
    1769              YYCHECK.  */
    1770           for (yyx = yyn < 0 ? -yyn : 0;
    1771                yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
    1772             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
    1773               yysize += yystrlen (yytname[yyx]) + 15, yycount++;
    1774           yysize += yystrlen ("syntax error, unexpected ") + 1;
    1775           yysize += yystrlen (yytname[yytype]);
    1776           yymsg = (char *) YYSTACK_ALLOC (yysize);
    1777           if (yymsg != 0)
    1778             {
    1779               char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
    1780               yyp = yystpcpy (yyp, yytname[yytype]);
    1781 
    1782               if (yycount < 5)
    1783                 {
    1784                   yycount = 0;
    1785                   for (yyx = yyn < 0 ? -yyn : 0;
    1786                        yyx < (int) (sizeof (yytname) / sizeof (char *));
    1787                        yyx++)
    1788                     if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
    1789                       {
    1790                         const char *yyq = ! yycount ? ", expecting " : " or ";
    1791                         yyp = yystpcpy (yyp, yyq);
    1792                         yyp = yystpcpy (yyp, yytname[yyx]);
    1793                         yycount++;
    1794                       }
    1795                 }
    1796               yyerror (yymsg);
    1797               YYSTACK_FREE (yymsg);
    1798             }
    1799           else
    1800             yyerror ("syntax error; also virtual memory exhausted");
     2141          /* Return failure if at end of input.  */
     2142          if (yychar == YYEOF)
     2143            YYABORT;
    18012144        }
    18022145      else
    1803 #endif /* YYERROR_VERBOSE */
    1804         yyerror ("syntax error");
     2146        {
     2147          yydestruct ("Error: discarding",
     2148                      yytoken, &yylval);
     2149          yychar = YYEMPTY;
     2150        }
    18052151    }
    18062152
    1807 
    1808 
    1809   if (yyerrstatus == 3)
    1810     {
    1811       /* If just tried and failed to reuse lookahead token after an
    1812          error, discard it.  */
    1813 
    1814       /* Return failure if at end of input.  */
    1815       if (yychar == YYEOF)
    1816         {
    1817           /* Pop the error token.  */
    1818           YYPOPSTACK;
    1819           /* Pop the rest of the stack.  */
    1820           while (yyss < yyssp)
    1821             {
    1822               YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
    1823               yydestruct (yystos[*yyssp], yyvsp);
    1824               YYPOPSTACK;
    1825             }
    1826           YYABORT;
    1827         }
    1828 
    1829       YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
    1830       yydestruct (yytoken, &yylval);
    1831       yychar = YYEMPTY;
    1832 
    1833     }
    1834 
    1835   /* Else will try to reuse lookahead token after shifting the error
     2153  /* Else will try to reuse look-ahead token after shifting the error
    18362154     token.  */
    18372155  goto yyerrlab1;
    18382156
    18392157
    1840 /*----------------------------------------------------.
    1841 | yyerrlab1 -- error raised explicitly by an action.  |
    1842 `----------------------------------------------------*/
     2158/*---------------------------------------------------.
     2159| yyerrorlab -- error raised explicitly by YYERROR.  |
     2160`---------------------------------------------------*/
     2161yyerrorlab:
     2162
     2163  /* Pacify compilers like GCC when the user code never invokes
     2164     YYERROR and the label yyerrorlab therefore never appears in user
     2165     code.  */
     2166  if (/*CONSTCOND*/ 0)
     2167     goto yyerrorlab;
     2168
     2169  /* Do not reclaim the symbols of the rule which action triggered
     2170     this YYERROR.  */
     2171  YYPOPSTACK (yylen);
     2172  yylen = 0;
     2173  YY_STACK_PRINT (yyss, yyssp);
     2174  yystate = *yyssp;
     2175  goto yyerrlab1;
     2176
     2177
     2178/*-------------------------------------------------------------.
     2179| yyerrlab1 -- common code for both syntax error and YYERROR.  |
     2180`-------------------------------------------------------------*/
    18432181yyerrlab1:
    18442182  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
    … …  
    18622200        YYABORT;
    18632201
    1864       YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
    1865       yydestruct (yystos[yystate], yyvsp);
    1866       yyvsp--;
    1867       yystate = *--yyssp;
    1868 
     2202
     2203      yydestruct ("Error: popping",
     2204                  yystos[yystate], yyvsp);
     2205      YYPOPSTACK (1);
     2206      yystate = *yyssp;
    18692207      YY_STACK_PRINT (yyss, yyssp);
    18702208    }
    … …  
    18732211    YYACCEPT;
    18742212
    1875   YYDPRINTF ((stderr, "Shifting error token, "));
    1876 
    18772213  *++yyvsp = yylval;
    18782214
     2215
     2216  /* Shift the error token.  */
     2217  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
    18792218
    18802219  yystate = yyn;
    … …  
    18972236
    18982237#ifndef yyoverflow
    1899 /*----------------------------------------------.
    1900 | yyoverflowlab -- parser overflow comes here.  |
    1901 `----------------------------------------------*/
    1902 yyoverflowlab:
    1903   yyerror ("parser stack overflow");
     2238/*-------------------------------------------------.
     2239| yyexhaustedlab -- memory exhaustion comes here.  |
     2240`-------------------------------------------------*/
     2241yyexhaustedlab:
     2242  yyerror (YY_("memory exhausted"));
    19042243  yyresult = 2;
    19052244  /* Fall through.  */
    … …  
    19072246
    19082247yyreturn:
     2248  if (yychar != YYEOF && yychar != YYEMPTY)
     2249     yydestruct ("Cleanup: discarding lookahead",
     2250                 yytoken, &yylval);
     2251  /* Do not reclaim the symbols of the rule which action triggered
     2252     this YYABORT or YYACCEPT.  */
     2253  YYPOPSTACK (yylen);
     2254  YY_STACK_PRINT (yyss, yyssp);
     2255  while (yyssp != yyss)
     2256    {
     2257      yydestruct ("Cleanup: popping",
     2258                  yystos[*yyssp], yyvsp);
     2259      YYPOPSTACK (1);
     2260    }
    19092261#ifndef yyoverflow
    19102262  if (yyss != yyssa)
    19112263    YYSTACK_FREE (yyss);
    19122264#endif
    1913   return yyresult;
     2265#if YYERROR_VERBOSE
     2266  if (yymsg != yymsgbuf)
     2267    YYSTACK_FREE (yymsg);
     2268#endif
     2269  /* Make sure YYID is used.  */
     2270  return YYID (yyresult);
    19142271}
    19152272
    19162273
    1917 
     2274#line 476 "zconf.y"
    19182275
    19192276
    … …  
    21292486#include "menu.c"
    21302487
    2131 

  • package/config/zconf.tab.h_shipped

    r4e0f7fd r6753dda  
    1 /* A Bison parser, made from zconf.y, by GNU bison 1.75.  */
     1/* A Bison parser, made by GNU Bison 2.3.  */
    22
    3 /* Skeleton parser for Yacc-like parsing with Bison,
    4    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc.
     3/* Skeleton interface for Bison's Yacc-like parsers in C
     4
     5   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
     6   Free Software Foundation, Inc.
    57
    68   This program is free software; you can redistribute it and/or modify
    … …  
    1618   You should have received a copy of the GNU General Public License
    1719   along with this program; if not, write to the Free Software
    18    Foundation, Inc., 59 Temple Place - Suite 330,
    19    Boston, MA 02111-1307, USA.  */
     20   Foundation, Inc., 51 Franklin Street, Fifth Floor,
     21   Boston, MA 02110-1301, USA.  */
    2022
    21 /* As a special exception, when this file is copied by Bison into a
    22    Bison output file, you may use that output file without restriction.
    23    This special exception was added by the Free Software Foundation
    24    in version 1.24 of Bison.  */
     23/* As a special exception, you may create a larger work that contains
     24   part or all of the Bison parser skeleton and distribute that work
     25   under terms of your choice, so long as that work isn't itself a
     26   parser generator using the skeleton or a modified version thereof
     27   as a parser skeleton.  Alternatively, if you modify or redistribute
     28   the parser skeleton itself, you may (at your option) remove this
     29   special exception, which will cause the skeleton and the resulting
     30   Bison output files to be licensed under the GNU General Public
     31   License without this special exception.
    2532
    26 #ifndef BISON_ZCONF_TAB_H
    27 # define BISON_ZCONF_TAB_H
     33   This special exception was added by the Free Software Foundation in
     34   version 2.2 of Bison.  */
    2835
    2936/* Tokens.  */
    … …  
    4148     T_COMMENT = 264,
    4249     T_CONFIG = 265,
    43      T_HELP = 266,
    44      T_HELPTEXT = 267,
    45      T_IF = 268,
    46      T_ENDIF = 269,
    47      T_DEPENDS = 270,
    48      T_REQUIRES = 271,
    49      T_OPTIONAL = 272,
    50      T_PROMPT = 273,
    51      T_DEFAULT = 274,
    52      T_TRISTATE = 275,
    53      T_BOOLEAN = 276,
    54      T_INT = 277,
    55      T_HEX = 278,
    56      T_WORD = 279,
     50     T_MENUCONFIG = 266,
     51     T_HELP = 267,
     52     T_HELPTEXT = 268,
     53     T_IF = 269,
     54     T_ENDIF = 270,
     55     T_DEPENDS = 271,
     56     T_REQUIRES = 272,
     57     T_OPTIONAL = 273,
     58     T_PROMPT = 274,
     59     T_DEFAULT = 275,
     60     T_TRISTATE = 276,
     61     T_DEF_TRISTATE = 277,
     62     T_BOOLEAN = 278,
     63     T_DEF_BOOLEAN = 279,
    5764     T_STRING = 280,
    58      T_UNEQUAL = 281,
    59      T_EOF = 282,
    60      T_EOL = 283,
    61      T_CLOSE_PAREN = 284,
    62      T_OPEN_PAREN = 285,
    63      T_ON = 286,
    64      T_OR = 287,
    65      T_AND = 288,
    66      T_EQUAL = 289,
    67      T_NOT = 290
     65     T_INT = 281,
     66     T_HEX = 282,
     67     T_WORD = 283,
     68     T_WORD_QUOTE = 284,
     69     T_UNEQUAL = 285,
     70     T_EOF = 286,
     71     T_EOL = 287,
     72     T_CLOSE_PAREN = 288,
     73     T_OPEN_PAREN = 289,
     74     T_ON = 290,
     75     T_SELECT = 291,
     76     T_RANGE = 292,
     77     T_OR = 293,
     78     T_AND = 294,
     79     T_EQUAL = 295,
     80     T_NOT = 296
    6881   };
    6982#endif
     83/* Tokens.  */
    7084#define T_MAINMENU 258
    7185#define T_MENU 259
    … …  
    7690#define T_COMMENT 264
    7791#define T_CONFIG 265
    78 #define T_HELP 266
    79 #define T_HELPTEXT 267
    80 #define T_IF 268
    81 #define T_ENDIF 269
    82 #define T_DEPENDS 270
    83 #define T_REQUIRES 271
    84 #define T_OPTIONAL 272
    85 #define T_PROMPT 273
    86 #define T_DEFAULT 274
    87 #define T_TRISTATE 275
    88 #define T_BOOLEAN 276
    89 #define T_INT 277
    90 #define T_HEX 278
    91 #define T_WORD 279
     92#define T_MENUCONFIG 266
     93#define T_HELP 267
     94#define T_HELPTEXT 268
     95#define T_IF 269
     96#define T_ENDIF 270
     97#define T_DEPENDS 271
     98#define T_REQUIRES 272
     99#define T_OPTIONAL 273
     100#define T_PROMPT 274
     101#define T_DEFAULT 275
     102#define T_TRISTATE 276
     103#define T_DEF_TRISTATE 277
     104#define T_BOOLEAN 278
     105#define T_DEF_BOOLEAN 279
    92106#define T_STRING 280
    93 #define T_UNEQUAL 281
    94 #define T_EOF 282
    95 #define T_EOL 283
    96 #define T_CLOSE_PAREN 284
    97 #define T_OPEN_PAREN 285
    98 #define T_ON 286
    99 #define T_OR 287
    100 #define T_AND 288
    101 #define T_EQUAL 289
    102 #define T_NOT 290
     107#define T_INT 281
     108#define T_HEX 282
     109#define T_WORD 283
     110#define T_WORD_QUOTE 284
     111#define T_UNEQUAL 285
     112#define T_EOF 286
     113#define T_EOL 287
     114#define T_CLOSE_PAREN 288
     115#define T_OPEN_PAREN 289
     116#define T_ON 290
     117#define T_SELECT 291
     118#define T_RANGE 292
     119#define T_OR 293
     120#define T_AND 294
     121#define T_EQUAL 295
     122#define T_NOT 296
    103123
    104124
    105125
    106126
    107 #ifndef YYSTYPE
     127#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
     128typedef union YYSTYPE
    108129#line 33 "zconf.y"
    109 typedef union {
     130{
    110131        int token;
    111132        char *string;
    … …  
    113134        struct expr *expr;
    114135        struct menu *menu;
    115 } yystype;
    116 /* Line 1281 of /usr/share/bison/yacc.c.  */
    117 #line 118 "zconf.tab.h"
    118 # define YYSTYPE yystype
     136}
     137/* Line 1529 of yacc.c.  */
     138#line 139 "zconf.tab.h"
     139        YYSTYPE;
     140# define yystype YYSTYPE /* obsolescent; will be withdrawn */
     141# define YYSTYPE_IS_DECLARED 1
     142# define YYSTYPE_IS_TRIVIAL 1
    119143#endif
    120144
    121145extern YYSTYPE zconflval;
    122146
    123 
    124 #endif /* not BISON_ZCONF_TAB_H */
    125 
Note: See TracChangeset for help on using the changeset viewer.