/[bison]/bison/src/parse-gram.c
ViewVC logotype

Diff of /bison/src/parse-gram.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.3 by akim, Fri Jun 14 17:29:17 2002 UTC revision 1.4 by akim, Fri Jun 14 17:35:45 2002 UTC
# Line 1  Line 1 
1  /* A Bison parser, made from parse-gram.y  /* A Bison parser, made from parse-gram.y
2     by GNU bison 1.49b.  */     by GNU bison 1.35.  */
3    
4  /* Skeleton output parser for Bison,  #define YYBISON 1  /* Identify Bison output.  */
    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software  
    Foundation, Inc.  
   
    This program is free software; you can redistribute it and/or modify  
    it under the terms of the GNU General Public License as published by  
    the Free Software Foundation; either version 2, or (at your option)  
    any later version.  
5    
    This program is distributed in the hope that it will be useful,  
    but WITHOUT ANY WARRANTY; without even the implied warranty of  
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  
    GNU General Public License for more details.  
   
    You should have received a copy of the GNU General Public License  
    along with this program; if not, write to the Free Software  
    Foundation, Inc., 59 Temple Place - Suite 330,  
    Boston, MA 02111-1307, USA.  */  
   
 /* As a special exception, when this file is copied by Bison into a  
    Bison output file, you may use that output file without restriction.  
    This special exception was added by the Free Software Foundation  
    in version 1.24 of Bison.  */  
   
 /* This is the parser code that is written into each bison parser when  
    the %semantic_parser declaration is not specified in the grammar.  
    It was written by Richard Stallman by simplifying the original so  
    called ``semantic'' parser.  */  
   
 /* All symbols defined below should begin with yy or YY, to avoid  
    infringing on user name space.  This should be done even for local  
    variables, as they might otherwise be expanded by user macros.  
    There are some unavoidable exceptions within include files to  
    define necessary library symbols; they are noted "INFRINGES ON  
    USER NAME SPACE" below.  */  
   
 /* Identify Bison output.  */  
 #define YYBISON 1  
   
 /* Pure parsers.  */  
 #define YYPURE  1  
   
 /* Using locations.  */  
 #define YYLSP_NEEDED 1  
   
 /* If NAME_PREFIX is specified substitute the variables and functions  
    names.  */  
6  #define yyparse gram_parse  #define yyparse gram_parse
7  #define yylex   gram_lex  #define yylex gram_lex
8  #define yyerror gram_error  #define yyerror gram_error
9  #define yylval  gram_lval  #define yylval gram_lval
10  #define yychar  gram_char  #define yychar gram_char
11  #define yydebug gram_debug  #define yydebug gram_debug
12  #define yynerrs gram_nerrs  #define yynerrs gram_nerrs
13  #if YYLSP_NEEDED  #define YYLSP_NEEDED 1
 # define yylloc gram_lloc  
 #endif  
14    
15    # define        GRAM_EOF        0
16    # define        STRING  257
17    # define        CHARACTER       258
18    # define        INT     259
19    # define        PERCENT_TOKEN   260
20    # define        PERCENT_NTERM   261
21    # define        PERCENT_TYPE    262
22    # define        PERCENT_UNION   263
23    # define        PERCENT_EXPECT  264
24    # define        PERCENT_START   265
25    # define        PERCENT_LEFT    266
26    # define        PERCENT_RIGHT   267
27    # define        PERCENT_NONASSOC        268
28    # define        PERCENT_PREC    269
29    # define        PERCENT_VERBOSE 270
30    # define        PERCENT_ERROR_VERBOSE   271
31    # define        PERCENT_OUTPUT  272
32    # define        PERCENT_FILE_PREFIX     273
33    # define        PERCENT_NAME_PREFIX     274
34    # define        PERCENT_DEFINE  275
35    # define        PERCENT_PURE_PARSER     276
36    # define        PERCENT_DEFINES 277
37    # define        PERCENT_YACC    278
38    # define        PERCENT_DEBUG   279
39    # define        PERCENT_LOCATIONS       280
40    # define        PERCENT_NO_LINES        281
41    # define        PERCENT_SKELETON        282
42    # define        PERCENT_TOKEN_TABLE     283
43    # define        TYPE    284
44    # define        EQUAL   285
45    # define        SEMICOLON       286
46    # define        COLON   287
47    # define        PIPE    288
48    # define        ID      289
49    # define        PERCENT_PERCENT 290
50    # define        PROLOGUE        291
51    # define        EPILOGUE        292
52    # define        BRACED_CODE     293
53    
 /* Copy the first part of user declarations.  */  
54  #line 31 "parse-gram.y"  #line 31 "parse-gram.y"
55    
56  #include "system.h"  #include "system.h"
# Line 72  Line 62 
62  #include "reader.h"  #include "reader.h"
63  #include "conflicts.h"  #include "conflicts.h"
64    
65    /* Produce verbose parse errors.  */
66  #define YYERROR_VERBOSE 1  #define YYERROR_VERBOSE 1
67    
68  /* Pass the control structure to YYPARSE and YYLEX. */  /* Pass the control structure to YYPARSE and YYLEX. */
# Line 91  Line 82 
82     of the tokens.  */     of the tokens.  */
83  #define YYPRINT(File, Type, Value) \  #define YYPRINT(File, Type, Value) \
84          yyprint (File, &yylloc, Type, &Value)          yyprint (File, &yylloc, Type, &Value)
85  static void yyprint (FILE *file, const yyltype *loc,  static void yyprint (FILE *file, const location_t *loc,
86                       int type, const yystype *value);                       int type, const yystype *value);
87    
88  symbol_class current_class = unknown_sym;  symbol_class current_class = unknown_sym;
# Line 100  symbol_t *current_lhs; Line 91  symbol_t *current_lhs;
91  associativity current_assoc;  associativity current_assoc;
92  int current_prec = 0;  int current_prec = 0;
93    
   
 /* Tokens.  */  
 #ifndef YYTOKENTYPE  
 # if defined (__STDC__) || defined (__cplusplus)  
    /* Put the tokens into the symbol table, so that GDB and other debuggers  
       know about them.  */  
    enum yytokentype {  
      GRAM_EOF = 0,  
      STRING = 258,  
      CHARACTER = 259,  
      INT = 260,  
      PERCENT_TOKEN = 261,  
      PERCENT_NTERM = 262,  
      PERCENT_TYPE = 263,  
      PERCENT_UNION = 264,  
      PERCENT_EXPECT = 265,  
      PERCENT_START = 266,  
      PERCENT_LEFT = 267,  
      PERCENT_RIGHT = 268,  
      PERCENT_NONASSOC = 269,  
      PERCENT_PREC = 270,  
      PERCENT_VERBOSE = 271,  
      PERCENT_ERROR_VERBOSE = 272,  
      PERCENT_OUTPUT = 273,  
      PERCENT_FILE_PREFIX = 274,  
      PERCENT_NAME_PREFIX = 275,  
      PERCENT_DEFINE = 276,  
      PERCENT_PURE_PARSER = 277,  
      PERCENT_DEFINES = 278,  
      PERCENT_YACC = 279,  
      PERCENT_DEBUG = 280,  
      PERCENT_LOCATIONS = 281,  
      PERCENT_NO_LINES = 282,  
      PERCENT_SKELETON = 283,  
      PERCENT_TOKEN_TABLE = 284,  
      TYPE = 285,  
      EQUAL = 286,  
      SEMICOLON = 287,  
      COLON = 288,  
      PIPE = 289,  
      ID = 290,  
      PERCENT_PERCENT = 291,  
      PROLOGUE = 292,  
      EPILOGUE = 293,  
      BRACED_CODE = 294  
    };  
 # endif  
   /* POSIX requires `int' for tokens in interfaces.  */  
 # define YYTOKENTYPE int  
 #endif /* !YYTOKENTYPE */  
 #define GRAM_EOF 0  
 #define STRING 258  
 #define CHARACTER 259  
 #define INT 260  
 #define PERCENT_TOKEN 261  
 #define PERCENT_NTERM 262  
 #define PERCENT_TYPE 263  
 #define PERCENT_UNION 264  
 #define PERCENT_EXPECT 265  
 #define PERCENT_START 266  
 #define PERCENT_LEFT 267  
 #define PERCENT_RIGHT 268  
 #define PERCENT_NONASSOC 269  
 #define PERCENT_PREC 270  
 #define PERCENT_VERBOSE 271  
 #define PERCENT_ERROR_VERBOSE 272  
 #define PERCENT_OUTPUT 273  
 #define PERCENT_FILE_PREFIX 274  
 #define PERCENT_NAME_PREFIX 275  
 #define PERCENT_DEFINE 276  
 #define PERCENT_PURE_PARSER 277  
 #define PERCENT_DEFINES 278  
 #define PERCENT_YACC 279  
 #define PERCENT_DEBUG 280  
 #define PERCENT_LOCATIONS 281  
 #define PERCENT_NO_LINES 282  
 #define PERCENT_SKELETON 283  
 #define PERCENT_TOKEN_TABLE 284  
 #define TYPE 285  
 #define EQUAL 286  
 #define SEMICOLON 287  
 #define COLON 288  
 #define PIPE 289  
 #define ID 290  
 #define PERCENT_PERCENT 291  
 #define PROLOGUE 292  
 #define EPILOGUE 293  
 #define BRACED_CODE 294  
   
   
   
   
 /* Enabling traces.  */  
 #ifndef YYDEBUG  
 # define YYDEBUG 1  
 #endif  
   
 /* Enabling verbose error messages.  */  
 #ifdef YYERROR_VERBOSE  
 # undef YYERROR_VERBOSE  
 # define YYERROR_VERBOSE 1  
 #else  
 # define YYERROR_VERBOSE 0  
 #endif  
   
 #ifndef YYSTYPE  
94  #line 73 "parse-gram.y"  #line 73 "parse-gram.y"
95  typedef union {  #ifndef YYSTYPE
96    typedef union
97    {
98    symbol_t *symbol;    symbol_t *symbol;
99    int integer;    int integer;
100    char *string;    char *string;
# Line 222  typedef struct yyltype Line 109  typedef struct yyltype
109  {  {
110    int first_line;    int first_line;
111    int first_column;    int first_column;
112    
113    int last_line;    int last_line;
114    int last_column;    int last_column;
115  } yyltype;  } yyltype;
116    
117  # define YYLTYPE yyltype  # define YYLTYPE yyltype
118  # define YYLTYPE_IS_TRIVIAL 1  # define YYLTYPE_IS_TRIVIAL 1
119  #endif  #endif
120    
121  /* Copy the second part of user declarations.  */  #ifndef YYDEBUG
122    # define YYDEBUG 1
123    #endif
124    
125    
126    
127  /* Line 217 of /usr/local/share/bison/bison.simple.  */  #define YYFINAL         94
128  #line 237 "parse-gram.c"  #define YYFLAG          -32768
129    #define YYNTBASE        41
130    
131  #if ! defined (yyoverflow) || YYERROR_VERBOSE  /* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */
132    #define YYTRANSLATE(x) ((unsigned)(x) <= 293 ? yytranslate[x] : 68)
133    
134    /* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */
135    static const char yytranslate[] =
136    {
137           0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
138           2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
139           2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
140           2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
141           2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
142           2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
143           2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
144           2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
145           2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
146           2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
147           2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
148           2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
149           2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
150           2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
151           2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
152           2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
153           2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
154           2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
155           2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
156           2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
157           2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
158           2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
159           2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
160           2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
161           2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
162           2,     2,     2,     2,     2,     2,     1,     4,     5,     6,
163           7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
164          17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
165          27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
166          37,    38,    39,    40
167    };
168    
169    #if YYDEBUG
170    static const short yyprhs[] =
171    {
172           0,     0,     1,     7,     8,    11,    13,    15,    17,    21,
173          23,    25,    28,    32,    34,    38,    40,    44,    46,    49,
174          51,    53,    55,    57,    58,    62,    65,    66,    70,    71,
175          76,    80,    81,    86,    88,    90,    92,    93,    95,    97,
176         100,   102,   105,   107,   109,   112,   115,   119,   121,   124,
177         126,   129,   130,   136,   138,   142,   143,   146,   149,   153,
178         155,   157,   159,   161,   163,   165,   166,   169,   170
179    };
180    static const short yyrhs[] =
181    {
182          -1,    42,    43,    37,    57,    66,     0,     0,    43,    44,
183           0,    45,     0,    38,     0,    26,     0,    22,    65,    65,
184           0,    24,     0,    18,     0,    11,     6,     0,    20,    32,
185          65,     0,    27,     0,    21,    32,    65,     0,    28,     0,
186          19,    32,    65,     0,    23,     0,    29,    65,     0,    30,
187           0,    17,     0,    25,     0,    49,     0,     0,     8,    46,
188          56,     0,    12,    62,     0,     0,     7,    47,    56,     0,
189           0,     9,    31,    48,    53,     0,    10,    40,    67,     0,
190           0,    51,    52,    50,    54,     0,    13,     0,    14,     0,
191          15,     0,     0,    31,     0,    36,     0,    53,    36,     0,
192          62,     0,    54,    62,     0,    31,     0,    36,     0,    36,
193           6,     0,    36,    64,     0,    36,     6,    64,     0,    55,
194           0,    56,    55,     0,    58,     0,    57,    58,     0,     0,
195          36,    34,    59,    60,    33,     0,    61,     0,    60,    35,
196          61,     0,     0,    61,    62,     0,    61,    63,     0,    61,
197          16,    62,     0,    36,     0,    64,     0,     5,     0,    40,
198           0,     4,     0,     4,     0,     0,    37,    39,     0,     0,
199          33,     0
200    };
201    
202    #endif
203    
204    #if YYDEBUG
205    /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
206    static const short yyrline[] =
207    {
208           0,   132,   132,   140,   142,   145,   147,   151,   152,   153,
209         154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
210         164,   165,   168,   170,   170,   175,   179,   179,   184,   184,
211         188,   196,   196,   203,   205,   206,   209,   211,   215,   217,
212         221,   227,   236,   241,   246,   252,   258,   268,   271,   275,
213         277,   280,   280,   285,   287,   290,   293,   295,   297,   301,
214         303,   304,   307,   313,   322,   330,   335,   341,   343
215    };
216    #endif
217    
218    
219    #if (YYDEBUG) || defined YYERROR_VERBOSE
220    
221    /* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */
222    static const char *const yytname[] =
223    {
224      "$", "error", "$undefined.", "\"end of string\"", "STRING", "CHARACTER",
225      "INT", "\"%token\"", "\"%nterm\"", "\"%type\"", "\"%union\"",
226      "\"%expect\"", "\"%start\"", "\"%left\"", "\"%right\"", "\"%nonassoc\"",
227      "\"%prec\"", "\"%verbose\"", "\"%error-verbose\"", "\"%output\"",
228      "\"%file-prefix\"", "\"%name-prefix\"", "\"%define\"",
229      "\"%pure-parser\"", "\"%defines\"", "\"%yacc\"", "\"%debug\"",
230      "\"%locations\"", "\"%no-lines\"", "\"%skeleton\"", "\"%token-table\"",
231      "TYPE", "\"=\"", "\";\"", "\":\"", "\"|\"", "\"identifier\"", "\"%%\"",
232      "PROLOGUE", "EPILOGUE", "BRACED_CODE", "input", "@1", "directives",
233      "directive", "grammar_directives", "@2", "@3", "@4",
234      "precedence_directives", "@5", "precedence_directive", "type.opt",
235      "nterms_to_type.1", "terms_to_prec.1", "symbol_def", "symbol_defs.1",
236      "gram", "rules", "@6", "rhses.1", "rhs", "symbol", "action",
237      "string_as_id", "string_content", "epilogue.opt", "semi_colon_opt", 0
238    };
239    #endif
240    
241    /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
242    static const short yyr1[] =
243    {
244           0,    42,    41,    43,    43,    44,    44,    44,    44,    44,
245          44,    44,    44,    44,    44,    44,    44,    44,    44,    44,
246          44,    44,    45,    46,    45,    45,    47,    45,    48,    45,
247          45,    50,    49,    51,    51,    51,    52,    52,    53,    53,
248          54,    54,    55,    55,    55,    55,    55,    56,    56,    57,
249          57,    59,    58,    60,    60,    61,    61,    61,    61,    62,
250          62,    62,    63,    64,    65,    66,    66,    67,    67
251    };
252    
253    /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
254    static const short yyr2[] =
255    {
256           0,     0,     5,     0,     2,     1,     1,     1,     3,     1,
257           1,     2,     3,     1,     3,     1,     3,     1,     2,     1,
258           1,     1,     1,     0,     3,     2,     0,     3,     0,     4,
259           3,     0,     4,     1,     1,     1,     0,     1,     1,     2,
260           1,     2,     1,     1,     2,     2,     3,     1,     2,     1,
261           2,     0,     5,     1,     3,     0,     2,     2,     3,     1,
262           1,     1,     1,     1,     1,     0,     2,     0,     1
263    };
264    
265    /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
266       doesn't specify something else to do.  Zero means the default is an
267       error. */
268    static const short yydefact[] =
269    {
270           1,     3,     0,    26,    23,     0,     0,     0,     0,    33,
271          34,    35,    20,    10,     0,     0,     0,     0,    17,     9,
272          21,     7,    13,    15,     0,    19,     0,     6,     4,     5,
273          22,    36,     0,     0,    28,    67,    11,    63,    61,    59,
274          25,    60,     0,     0,     0,    64,     0,    18,     0,    65,
275          49,    37,    31,    42,    43,    47,    27,    24,     0,    68,
276          30,    16,    12,    14,     8,    51,     0,    50,     2,     0,
277          44,    45,    48,    38,    29,    55,    66,    32,    40,    46,
278          39,     0,    53,    41,    52,    55,     0,    62,    56,    57,
279          54,    58,     0,     0,     0
280    };
281    
282    static const short yydefgoto[] =
283    {
284          92,     1,     2,    28,    29,    33,    32,    58,    30,    69,
285          31,    52,    74,    77,    55,    56,    49,    50,    75,    81,
286          82,    88,    89,    41,    46,    68,    60
287    };
288    
289    static const short yypact[] =
290    {
291      -32768,-32768,    72,-32768,-32768,   -22,   -29,     8,    -1,-32768,
292      -32768,-32768,-32768,-32768,   -16,   -14,   -11,    22,-32768,-32768,
293      -32768,-32768,-32768,-32768,    22,-32768,    -6,-32768,-32768,-32768,
294      -32768,     0,   -24,   -24,-32768,     1,-32768,-32768,-32768,-32768,
295      -32768,-32768,    22,    22,    22,-32768,    22,-32768,    -2,   -17,
296      -32768,-32768,-32768,-32768,     4,-32768,   -24,   -24,     2,-32768,
297      -32768,-32768,-32768,-32768,-32768,-32768,     3,-32768,-32768,    -1,
298          32,-32768,-32768,-32768,     5,-32768,-32768,    -1,-32768,-32768,
299      -32768,   -18,    -3,-32768,-32768,-32768,    -1,-32768,-32768,-32768,
300          -3,-32768,    39,    40,-32768
301    };
302    
303    static const short yypgoto[] =
304    {
305      -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
306      -32768,-32768,-32768,-32768,   -28,    10,-32768,    -5,-32768,-32768,
307         -40,    -8,-32768,   -48,   -19,-32768,-32768
308    };
309    
310    
311    #define YYLAST          110
312    
313    
314    static const short yytable[] =
315    {
316          40,    37,    38,    37,    38,    47,    71,    53,    37,    34,
317          70,    35,    54,    86,    36,    84,    42,    85,    43,    48,
318          66,    44,    79,    61,    62,    63,    45,    64,    72,    72,
319          48,    51,    65,    39,    59,    39,    37,    87,    73,    93,
320          94,    80,    76,    57,    67,    90,     0,     0,     0,     0,
321           0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
322           0,    78,     0,     0,     0,     0,     0,     0,     0,    83,
323           0,     0,     0,     0,     0,     0,     0,     0,    91,     3,
324           4,     5,     6,     7,     8,     9,    10,    11,     0,    12,
325          13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
326          23,    24,    25,     0,     0,     0,     0,     0,     0,    26,
327          27
328    };
329    
330    static const short yycheck[] =
331    {
332           8,     4,     5,     4,     5,    24,    54,    31,     4,    31,
333           6,    40,    36,    16,     6,    33,    32,    35,    32,    36,
334          37,    32,    70,    42,    43,    44,     4,    46,    56,    57,
335          36,    31,    34,    36,    33,    36,     4,    40,    36,     0,
336           0,    36,    39,    33,    49,    85,    -1,    -1,    -1,    -1,
337          -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
338          -1,    69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    77,
339          -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,     7,
340           8,     9,    10,    11,    12,    13,    14,    15,    -1,    17,
341          18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
342          28,    29,    30,    -1,    -1,    -1,    -1,    -1,    -1,    37,
343          38
344    };
345    #define YYPURE 1
346    
347    /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
348    #line 3 "/usr/share/bison/bison.simple"
349    
350    /* Skeleton output parser for bison,
351    
352       Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software
353       Foundation, Inc.
354    
355       This program is free software; you can redistribute it and/or modify
356       it under the terms of the GNU General Public License as published by
357       the Free Software Foundation; either version 2, or (at your option)
358       any later version.
359    
360       This program is distributed in the hope that it will be useful,
361       but WITHOUT ANY WARRANTY; without even the implied warranty of
362       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
363       GNU General Public License for more details.
364    
365       You should have received a copy of the GNU General Public License
366       along with this program; if not, write to the Free Software
367       Foundation, Inc., 59 Temple Place - Suite 330,
368       Boston, MA 02111-1307, USA.  */
369    
370    /* As a special exception, when this file is copied by Bison into a
371       Bison output file, you may use that output file without restriction.
372       This special exception was added by the Free Software Foundation
373       in version 1.24 of Bison.  */
374    
375    /* This is the parser code that is written into each bison parser when
376       the %semantic_parser declaration is not specified in the grammar.
377       It was written by Richard Stallman by simplifying the hairy parser
378       used when %semantic_parser is specified.  */
379    
380    /* All symbols defined below should begin with yy or YY, to avoid
381       infringing on user name space.  This should be done even for local
382       variables, as they might otherwise be expanded by user macros.
383       There are some unavoidable exceptions within include files to
384       define necessary library symbols; they are noted "INFRINGES ON
385       USER NAME SPACE" below.  */
386    
387    #if ! defined (yyoverflow) || defined (YYERROR_VERBOSE)
388    
389  /* The parser invokes alloca or malloc; define the necessary symbols.  */  /* The parser invokes alloca or malloc; define the necessary symbols.  */
390    
# Line 264  typedef struct yyltype Line 413  typedef struct yyltype
413  #  define YYSTACK_ALLOC malloc  #  define YYSTACK_ALLOC malloc
414  #  define YYSTACK_FREE free  #  define YYSTACK_FREE free
415  # endif  # endif
416  #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */  #endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */
417    
418    
419  #if (! defined (yyoverflow) \  #if (! defined (yyoverflow) \
# Line 308  union yyalloc Line 457  union yyalloc
457          {                                       \          {                                       \
458            register YYSIZE_T yyi;                \            register YYSIZE_T yyi;                \
459            for (yyi = 0; yyi < (Count); yyi++)   \            for (yyi = 0; yyi < (Count); yyi++)   \
460              (To)[yyi] = (From)[yyi];    \              (To)[yyi] = (From)[yyi];            \
461          }                                       \          }                                       \
462        while (0)        while (0)
463  #  endif  #  endif
# Line 332  union yyalloc Line 481  union yyalloc
481    
482  #endif  #endif
483    
 /* YYFINAL -- State number of the termination state. */  
 #define YYFINAL  3  
 #define YYFLAG   -32768  
 #define YYLAST   110  
   
 /* YYNTOKENS -- Number of terminals. */  
 #define YYNTOKENS  40  
 /* YYNNTS -- Number of nonterminals. */  
 #define YYNNTS  28  
 /* YYNRULES -- Number of rules. */  
 #define YYNRULES  69  
 /* YYNRULES -- Number of states. */  
 #define YYNSTATES  94  
   
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */  
 #define YYUNDEFTOK  2  
 #define YYMAXUTOK   294  
   
 #define YYTRANSLATE(X) \  
   ((unsigned)(X) <= YYMAXUTOK ? yytranslate[X] : YYUNDEFTOK)  
   
 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */  
 static const unsigned char yytranslate[] =  
 {  
        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,  
        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,  
       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,  
       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,  
       35,    36,    37,    38,    39  
 };  
   
 #if YYDEBUG  
 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in  
    YYRHS.  */  
 static const unsigned char yyprhs[] =  
 {  
        0,     0,     3,     4,    10,    11,    14,    16,    18,    20,  
       24,    26,    28,    31,    35,    37,    41,    43,    47,    49,  
       52,    54,    56,    58,    60,    61,    65,    68,    69,    73,  
       74,    79,    83,    84,    89,    91,    93,    95,    96,    98,  
      100,   103,   105,   108,   110,   112,   115,   118,   122,   124,  
      127,   129,   132,   133,   139,   141,   145,   146,   149,   152,  
      156,   158,   160,   162,   164,   166,   168,   169,   172,   173  
 };  
   
 /* YYRHS -- A `-1'-separated list of the rules' RHS. */  
 static const signed char yyrhs[] =  
 {  
       41,     0,    -1,    -1,    42,    43,    36,    57,    66,    -1,  
       -1,    43,    44,    -1,    45,    -1,    37,    -1,    25,    -1,  
       21,    65,    65,    -1,    23,    -1,    17,    -1,    10,     5,  
       -1,    19,    31,    65,    -1,    26,    -1,    20,    31,    65,  
       -1,    27,    -1,    18,    31,    65,    -1,    22,    -1,    28,  
       65,    -1,    29,    -1,    16,    -1,    24,    -1,    49,    -1,  
       -1,     7,    46,    56,    -1,    11,    62,    -1,    -1,     6,  
       47,    56,    -1,    -1,     8,    30,    48,    53,    -1,     9,  
       39,    67,    -1,    -1,    51,    52,    50,    54,    -1,    12,  
       -1,    13,    -1,    14,    -1,    -1,    30,    -1,    35,    -1,  
       53,    35,    -1,    62,    -1,    54,    62,    -1,    30,    -1,  
       35,    -1,    35,     5,    -1,    35,    64,    -1,    35,     5,  
       64,    -1,    55,    -1,    56,    55,    -1,    58,    -1,    57,  
       58,    -1,    -1,    35,    33,    59,    60,    32,    -1,    61,  
       -1,    60,    34,    61,    -1,    -1,    61,    62,    -1,    61,  
       63,    -1,    61,    15,    62,    -1,    35,    -1,    64,    -1,  
        4,    -1,    39,    -1,     3,    -1,     3,    -1,    -1,    36,  
       38,    -1,    -1,    32,    -1  
 };  
   
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */  
 static const unsigned short yyrline[] =  
 {  
        0,   131,   131,   131,   139,   141,   144,   146,   150,   151,  
      152,   153,   154,   155,   156,   157,   158,   159,   160,   161,  
      162,   163,   164,   167,   169,   169,   174,   178,   178,   183,  
      183,   187,   195,   195,   202,   204,   205,   208,   210,   214,  
      216,   220,   226,   235,   240,   245,   251,   257,   267,   270,  
      274,   276,   279,   279,   284,   286,   289,   292,   294,   296,  
      300,   302,   303,   306,   312,   321,   329,   334,   340,   342  
 };  
 #endif  
   
 #if YYDEBUG || YYERROR_VERBOSE  
 /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.  
    First, the terminals, then, starting at YYNTOKENS, nonterminals. */  
 static const char *const yytname[] =  
 {  
   "\"end of string\"", "error", "$undefined.", "STRING", "CHARACTER", "INT",  
   "\"%token\"", "\"%nterm\"", "\"%type\"", "\"%union\"", "\"%expect\"",  
   "\"%start\"", "\"%left\"", "\"%right\"", "\"%nonassoc\"", "\"%prec\"",  
   "\"%verbose\"", "\"%error-verbose\"", "\"%output\"", "\"%file-prefix\"",  
   "\"%name-prefix\"", "\"%define\"", "\"%pure-parser\"", "\"%defines\"",  
   "\"%yacc\"", "\"%debug\"", "\"%locations\"", "\"%no-lines\"",  
   "\"%skeleton\"", "\"%token-table\"", "TYPE", "\"=\"", "\";\"", "\":\"",  
   "\"|\"", "\"identifier\"", "\"%%\"", "PROLOGUE", "EPILOGUE",  
   "BRACED_CODE", "$axiom", "input", "@1", "directives", "directive",  
   "grammar_directives", "@2", "@3", "@4", "precedence_directives", "@5",  
   "precedence_directive", "type.opt", "nterms_to_type.1",  
   "terms_to_prec.1", "symbol_def", "symbol_defs.1", "gram", "rules", "@6",  
   "rhses.1", "rhs", "symbol", "action", "string_as_id", "string_content",  
   "epilogue.opt", "semi_colon_opt", 0  
 };  
 #endif  
   
 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to  
    token YYLEX-NUM.  */  
 static const short yytoknum[] =  
 {  
        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,  
      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,  
      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,  
      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,  
       -1  
 };  
   
 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */  
 static const unsigned char yyr1[] =  
 {  
        0,    40,    42,    41,    43,    43,    44,    44,    44,    44,  
       44,    44,    44,    44,    44,    44,    44,    44,    44,    44,  
       44,    44,    44,    45,    46,    45,    45,    47,    45,    48,  
       45,    45,    50,    49,    51,    51,    51,    52,    52,    53,  
       53,    54,    54,    55,    55,    55,    55,    55,    56,    56,  
       57,    57,    59,    58,    60,    60,    61,    61,    61,    61,  
       62,    62,    62,    63,    64,    65,    66,    66,    67,    67  
 };  
   
 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */  
 static const unsigned char yyr2[] =  
 {  
        0,     2,     0,     5,     0,     2,     1,     1,     1,     3,  
        1,     1,     2,     3,     1,     3,     1,     3,     1,     2,  
        1,     1,     1,     1,     0,     3,     2,     0,     3,     0,  
        4,     3,     0,     4,     1,     1,     1,     0,     1,     1,  
        2,     1,     2,     1,     1,     2,     2,     3,     1,     2,  
        1,     2,     0,     5,     1,     3,     0,     2,     2,     3,  
        1,     1,     1,     1,     1,     1,     0,     2,     0,     1  
 };  
   
 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state  
    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero  
    means the default is an error.  */  
 static const short yydefact[] =  
 {  
        2,     0,     4,     0,     0,    27,    24,     0,     0,     0,  
        0,    34,    35,    36,    21,    11,     0,     0,     0,     0,  
       18,    10,    22,     8,    14,    16,     0,    20,     0,     7,  
        5,     6,    23,    37,     0,     0,    29,    68,    12,    64,  
       62,    60,    26,    61,     0,     0,     0,    65,     0,    19,  
        0,    66,    50,    38,    32,    43,    44,    48,    28,    25,  
        0,    69,    31,    17,    13,    15,     9,    52,     0,    51,  
        3,     0,    45,    46,    49,    39,    30,    56,    67,    33,  
       41,    47,    40,     0,    54,    42,    53,    56,     0,    63,  
       57,    58,    55,    59  
 };  
   
 /* YYPGOTO[NTERM-NUM]. */  
 static const short yydefgoto[] =  
 {  
       -1,     1,     2,     4,    30,    31,    35,    34,    60,    32,  
       71,    33,    54,    76,    79,    57,    58,    51,    52,    77,  
       83,    84,    90,    91,    43,    48,    70,    62  
 };  
   
 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing  
    STATE-NUM.  */  
 static const short yypact[] =  
 {  
   -32768,     9,-32768,-32768,    73,-32768,-32768,   -19,   -24,    12,  
        0,-32768,-32768,-32768,-32768,-32768,    -5,    -3,    -1,    26,  
   -32768,-32768,-32768,-32768,-32768,-32768,    26,-32768,    -4,-32768,  
   -32768,-32768,-32768,     2,   -23,   -23,-32768,     4,-32768,-32768,  
   -32768,-32768,-32768,-32768,    26,    26,    26,-32768,    26,-32768,  
        1,   -17,-32768,-32768,-32768,-32768,     5,-32768,   -23,   -23,  
        3,-32768,-32768,-32768,-32768,-32768,-32768,-32768,     6,-32768,  
   -32768,     0,    36,-32768,-32768,-32768,     7,-32768,-32768,     0,  
   -32768,-32768,-32768,   -18,    -2,-32768,-32768,-32768,     0,-32768,  
   -32768,-32768,    -2,-32768  
 };  
   
 /* YYPGOTO[NTERM-NUM].  */  
 static const short yypgoto[] =  
 {  
   -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,  
   -32768,-32768,-32768,-32768,-32768,   -38,     8,-32768,   -11,-32768,  
   -32768,   -46,   -10,-32768,   -50,   -21,-32768,-32768  
 };  
   
 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If  
    positive, shift that token.  If negative, reduce the rule which  
    number is the opposite.  If zero, do what YYDEFACT says.  */  
 static const short yytable[] =  
 {  
       42,    39,    40,    39,    40,    49,    73,    55,    39,     3,  
       72,    36,    56,    88,    86,    37,    87,    38,    50,    68,  
       74,    74,    81,    63,    64,    65,    44,    66,    45,    47,  
       46,    50,    53,    41,    67,    41,    61,    89,    75,    39,  
       69,    92,    82,    59,    78,     0,     0,     0,     0,     0,  
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,  
        0,    80,     0,     0,     0,     0,     0,     0,     0,    85,  
        0,     0,     0,     0,     0,     0,     0,     0,    93,     5,  
        6,     7,     8,     9,    10,    11,    12,    13,     0,    14,  
       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,  
       25,    26,    27,     0,     0,     0,     0,     0,     0,    28,  
       29  
 };  
   
 static const short yycheck[] =  
 {  
       10,     3,     4,     3,     4,    26,    56,    30,     3,     0,  
        5,    30,    35,    15,    32,    39,    34,     5,    35,    36,  
       58,    59,    72,    44,    45,    46,    31,    48,    31,     3,  
       31,    35,    30,    35,    33,    35,    32,    39,    35,     3,  
       51,    87,    35,    35,    38,    -1,    -1,    -1,    -1,    -1,  
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  
       -1,    71,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    79,  
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,     6,  
        7,     8,     9,    10,    11,    12,    13,    14,    -1,    16,  
       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,  
       27,    28,    29,    -1,    -1,    -1,    -1,    -1,    -1,    36,  
       37  
 };  
   
 #if YYDEBUG  
 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing  
    symbol of state STATE-NUM.  */  
 static const unsigned char yystos[] =  
 {  
        0,    41,    42,     0,    43,     6,     7,     8,     9,    10,  
       11,    12,    13,    14,    16,    17,    18,    19,    20,    21,  
       22,    23,    24,    25,    26,    27,    28,    29,    36,    37,  
       44,    45,    49,    51,    47,    46,    30,    39,     5,     3,  
        4,    35,    62,    64,    31,    31,    31,     3,    65,    65,  
       35,    57,    58,    30,    52,    30,    35,    55,    56,    56,  
       48,    32,    67,    65,    65,    65,    65,    33,    36,    58,  
       66,    50,     5,    64,    55,    35,    53,    59,    38,    54,  
       62,    64,    35,    60,    61,    62,    32,    34,    15,    39,  
       62,    63,    61,    62  
 };  
 #endif  
484    
485  #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)  #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
486  # define YYSIZE_T __SIZE_TYPE__  # define YYSIZE_T __SIZE_TYPE__
# Line 617  static const unsigned char yystos[] = Line 502  static const unsigned char yystos[] =
502  #define yyclearin       (yychar = YYEMPTY)  #define yyclearin       (yychar = YYEMPTY)
503  #define YYEMPTY         -2  #define YYEMPTY         -2
504  #define YYEOF           0  #define YYEOF           0
   
505  #define YYACCEPT        goto yyacceptlab  #define YYACCEPT        goto yyacceptlab
506  #define YYABORT         goto yyabortlab  #define YYABORT         goto yyabortlab
507  #define YYERROR         goto yyerrlab1  #define YYERROR         goto yyerrlab1
   
508  /* Like YYERROR except do call yyerror.  This remains here temporarily  /* Like YYERROR except do call yyerror.  This remains here temporarily
509     to ease the transition to the new meaning of YYERROR, for GCC.     to ease the transition to the new meaning of YYERROR, for GCC.
510     Once GCC version 2 has supplanted version 1, this can go.  */     Once GCC version 2 has supplanted version 1, this can go.  */
   
511  #define YYFAIL          goto yyerrlab  #define YYFAIL          goto yyerrlab
   
512  #define YYRECOVERING()  (!!yyerrstatus)  #define YYRECOVERING()  (!!yyerrstatus)
   
513  #define YYBACKUP(Token, Value)                                  \  #define YYBACKUP(Token, Value)                                  \
514  do                                                              \  do                                                              \
515    if (yychar == YYEMPTY && yylen == 1)                          \    if (yychar == YYEMPTY && yylen == 1)                          \
# Line 650  while (0) Line 530  while (0)
530  #define YYTERROR        1  #define YYTERROR        1
531  #define YYERRCODE       256  #define YYERRCODE       256
532    
533    
534  /* YYLLOC_DEFAULT -- Compute the default location (before the actions  /* YYLLOC_DEFAULT -- Compute the default location (before the actions
535     are run).  */     are run).
536    
537       When YYLLOC_DEFAULT is run, CURRENT is set the location of the
538       first token.  By default, to implement support for ranges, extend
539       its range to the last symbol.  */
540    
541  #ifndef YYLLOC_DEFAULT  #ifndef YYLLOC_DEFAULT
542  # define YYLLOC_DEFAULT(Current, Rhs, N)           \  # define YYLLOC_DEFAULT(Current, Rhs, N)        \
543    Current.first_line   = Rhs[1].first_line;      \     Current.last_line   = Rhs[N].last_line;      \
544    Current.first_column = Rhs[1].first_column;    \     Current.last_column = Rhs[N].last_column;
   Current.last_line    = Rhs[N].last_line;       \  
   Current.last_column  = Rhs[N].last_column;  
545  #endif  #endif
546    
547    
548  /* YYLEX -- calling `yylex' with the right arguments.  */  /* YYLEX -- calling `yylex' with the right arguments.  */
549    
550  #if YYPURE  #if YYPURE
# Line 681  while (0) Line 565  while (0)
565  # define YYLEX                  yylex ()  # define YYLEX                  yylex ()
566  #endif /* !YYPURE */  #endif /* !YYPURE */
567    
568    
569  /* Enable debugging if requested.  */  /* Enable debugging if requested.  */
570  #if YYDEBUG  #if YYDEBUG
571    
# Line 720  int yydebug; Line 605  int yydebug;
605  #ifndef YYMAXDEPTH  #ifndef YYMAXDEPTH
606  # define YYMAXDEPTH 10000  # define YYMAXDEPTH 10000
607  #endif  #endif
   
608    
609    #ifdef YYERROR_VERBOSE
 #if YYERROR_VERBOSE  
610    
611  # ifndef yystrlen  # ifndef yystrlen
612  #  if defined (__GLIBC__) && defined (_STRING_H)  #  if defined (__GLIBC__) && defined (_STRING_H)
# Line 773  yystpcpy (yydest, yysrc) Line 656  yystpcpy (yydest, yysrc)
656  }  }
657  #  endif  #  endif
658  # endif  # endif
659    #endif
 #endif /* !YYERROR_VERBOSE */  
   
660    
661    #line 315 "/usr/share/bison/bison.simple"
662    
663    
664  /* The user can define YYPARSE_PARAM as the name of an argument to be passed  /* The user can define YYPARSE_PARAM as the name of an argument to be passed
665     into yyparse.  The argument should have type void *.     into yyparse.  The argument should have type void *.
# Line 813  int yyparse (void); Line 696  int yyparse (void);
696  /* The lookahead symbol.  */                            \  /* The lookahead symbol.  */                            \
697  int yychar;                                             \  int yychar;                                             \
698                                                          \                                                          \
699  /* The semantic value of the lookahead symbol.  */      \  /* The semantic value of the lookahead symbol. */       \
700  YYSTYPE yylval;                                         \  YYSTYPE yylval;                                         \
701                                                          \                                                          \
702  /* Number of parse errors so far.  */                   \  /* Number of parse errors so far.  */                   \
# Line 830  YYLTYPE yylloc; Line 713  YYLTYPE yylloc;
713  YY_DECL_NON_LSP_VARIABLES  YY_DECL_NON_LSP_VARIABLES
714  #endif  #endif
715    
716  /* If nonreentrant, generate the variables here.  */  
717    /* If nonreentrant, generate the variables here. */
718    
719  #if !YYPURE  #if !YYPURE
720  YY_DECL_VARIABLES  YY_DECL_VARIABLES
# Line 840  int Line 724  int
724  yyparse (YYPARSE_PARAM_ARG)  yyparse (YYPARSE_PARAM_ARG)
725       YYPARSE_PARAM_DECL       YYPARSE_PARAM_DECL
726  {  {
727    /* If reentrant, generate the variables here.  */    /* If reentrant, generate the variables here. */
728  #if YYPURE  #if YYPURE
729    YY_DECL_VARIABLES    YY_DECL_VARIABLES
730  #endif  /* !YYPURE */  #endif  /* !YYPURE */
# Line 861  yyparse (YYPARSE_PARAM_ARG) Line 745  yyparse (YYPARSE_PARAM_ARG)
745       Refer to the stacks thru separate pointers, to allow yyoverflow       Refer to the stacks thru separate pointers, to allow yyoverflow
746       to reallocate them elsewhere.  */       to reallocate them elsewhere.  */
747    
748    /* The state stack.  */    /* The state stack. */
749    short yyssa[YYINITDEPTH];    short yyssa[YYINITDEPTH];
750    short *yyss = yyssa;    short *yyss = yyssa;
751    register short *yyssp;    register short *yyssp;
# Line 886  yyparse (YYPARSE_PARAM_ARG) Line 770  yyparse (YYPARSE_PARAM_ARG)
770    
771    YYSIZE_T yystacksize = YYINITDEPTH;    YYSIZE_T yystacksize = YYINITDEPTH;
772    
773    
774    /* The variables used to return semantic value and location from the    /* The variables used to return semantic value and location from the
775       action routines.  */       action routines.  */
776    YYSTYPE yyval;    YYSTYPE yyval;
# Line 894  yyparse (YYPARSE_PARAM_ARG) Line 779  yyparse (YYPARSE_PARAM_ARG)
779  #endif  #endif
780    
781    /* When reducing, the number of symbols on the RHS of the reduced    /* When reducing, the number of symbols on the RHS of the reduced
782       rule.  */       rule. */
783    int yylen;    int yylen;
784    
785    YYDPRINTF ((stderr, "Starting parse\n"));    YYDPRINTF ((stderr, "Starting parse\n"));
# Line 981  yyparse (YYPARSE_PARAM_ARG) Line 866  yyparse (YYPARSE_PARAM_ARG)
866            goto yyoverflowlab;            goto yyoverflowlab;
867          YYSTACK_RELOCATE (yyss);          YYSTACK_RELOCATE (yyss);
868          YYSTACK_RELOCATE (yyvs);          YYSTACK_RELOCATE (yyvs);
869  #  if YYLSP_NEEDED  # if YYLSP_NEEDED
870          YYSTACK_RELOCATE (yyls);          YYSTACK_RELOCATE (yyls);
871  #  endif  # endif
872  #  undef YYSTACK_RELOCATE  # undef YYSTACK_RELOCATE
873          if (yyss1 != yyssa)          if (yyss1 != yyssa)
874            YYSTACK_FREE (yyss1);            YYSTACK_FREE (yyss1);
875        }        }
# Line 1008  yyparse (YYPARSE_PARAM_ARG) Line 893  yyparse (YYPARSE_PARAM_ARG)
893    
894    goto yybackup;    goto yybackup;
895    
896    
897  /*-----------.  /*-----------.
898  | yybackup.  |  | yybackup.  |
899  `-----------*/  `-----------*/
# Line 1034  yybackup: Line 920  yybackup:
920        yychar = YYLEX;        yychar = YYLEX;
921      }      }
922    
923    /* Convert token to internal form (in yychar1) for indexing tables with.  */    /* Convert token to internal form (in yychar1) for indexing tables with */
924    
925    if (yychar <= 0)              /* This means end of input.  */    if (yychar <= 0)              /* This means end of input. */
926      {      {
927        yychar1 = 0;        yychar1 = 0;
928        yychar = YYEOF;           /* Don't call YYLEX any more.  */        yychar = YYEOF;           /* Don't call YYLEX any more */
929    
930        YYDPRINTF ((stderr, "Now at end of input.\n"));        YYDPRINTF ((stderr, "Now at end of input.\n"));
931      }      }
# Line 1140  yyreduce: Line 1026  yyreduce:
1026    yyval = yyvsp[1-yylen];    yyval = yyvsp[1-yylen];
1027    
1028  #if YYLSP_NEEDED  #if YYLSP_NEEDED
1029    /* Default location. */    /* Similarly for the default location.  Let the user run additional
1030         commands if for instance locations are ranges.  */
1031      yyloc = yylsp[1-yylen];
1032    YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);    YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
1033  #endif  #endif
1034    
# Line 1152  yyreduce: Line 1040  yyreduce:
1040        int yyi;        int yyi;
1041    
1042        YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",        YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
1043                   yyn - 1, yyrline[yyn]);                   yyn, yyrline[yyn]);
1044    
1045        /* Print the symbols being reduced, and their result.  */        /* Print the symbols being reduced, and their result.  */
1046        for (yyi = yyprhs[yyn]; yyrhs[yyi] >= 0; yyi++)        for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)
1047          YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);          YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
1048        YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);        YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
1049      }      }
1050  #endif  #endif
   switch (yyn)  
     {  
         case 2:  
 #line 131 "parse-gram.y"  
     { LOCATION_RESET (yylloc); }  
     break;  
1051    
1052    case 3:    switch (yyn) {
1053  #line 133 "parse-gram.y"  
1054      {  case 1:
1055    #line 132 "parse-gram.y"
1056    { LOCATION_RESET (yylloc); }
1057        break;
1058    case 2:
1059    #line 134 "parse-gram.y"
1060    {
1061        yycontrol->errcode = 0;        yycontrol->errcode = 0;
1062        epilogue_set (yyvsp[0].string, yylsp[0].first_line);        epilogue_set (yyvsp[0].string, yylsp[0]);
1063      }      }
1064      break;      break;
1065    case 6:
1066    case 7:  #line 148 "parse-gram.y"
1067  #line 147 "parse-gram.y"  {
1068      {       prologue_augment (yyvsp[0].string, yylsp[0]);
      prologue_augment (yyvsp[0].string, yylsp[0].first_line);  
1069     }     }
1070      break;      break;
1071    case 7:
   case 8:  
 #line 150 "parse-gram.y"  
     { debug_flag = 1; }  
     break;  
   
   case 9:  
1072  #line 151 "parse-gram.y"  #line 151 "parse-gram.y"
1073      { muscle_insert (yyvsp[-1].string, yyvsp[0].string); }  { debug_flag = 1; }
1074      break;      break;
1075    case 8:
   case 10:  
1076  #line 152 "parse-gram.y"  #line 152 "parse-gram.y"
1077      { defines_flag = 1; }  { muscle_insert (yyvsp[-1].string, yyvsp[0].string); }
1078      break;      break;
1079    case 9:
   case 11:  
1080  #line 153 "parse-gram.y"  #line 153 "parse-gram.y"
1081      { error_verbose = 1; }  { defines_flag = 1; }
1082      break;      break;
1083    case 10:
   case 12:  
1084  #line 154 "parse-gram.y"  #line 154 "parse-gram.y"
1085      { expected_conflicts = yyvsp[0].integer; }  { error_verbose = 1; }
1086      break;      break;
1087    case 11:
   case 13:  
1088  #line 155 "parse-gram.y"  #line 155 "parse-gram.y"
1089      { spec_file_prefix = yyvsp[0].string; }  { expected_conflicts = yyvsp[0].integer; }
1090      break;      break;
1091    case 12:
   case 14:  
1092  #line 156 "parse-gram.y"  #line 156 "parse-gram.y"
1093      { locations_flag = 1; }  { spec_file_prefix = yyvsp[0].string; }
1094      break;      break;
1095    case 13:
   case 15:  
1096  #line 157 "parse-gram.y"  #line 157 "parse-gram.y"
1097      { spec_name_prefix = yyvsp[0].string; }  { locations_flag = 1; }
1098      break;      break;
1099    case 14:
   case 16:  
1100  #line 158 "parse-gram.y"  #line 158 "parse-gram.y"
1101      { no_lines_flag = 1; }  { spec_name_prefix = yyvsp[0].string; }
1102      break;      break;
1103    case 15:
   case 17:  
1104  #line 159 "parse-gram.y"  #line 159 "parse-gram.y"
1105      { spec_outfile = yyvsp[0].string; }  { no_lines_flag = 1; }
1106      break;      break;
1107    case 16:
   case 18:  
1108  #line 160 "parse-gram.y"  #line 160 "parse-gram.y"
1109      { pure_parser = 1; }  { spec_outfile = yyvsp[0].string; }
1110      break;      break;
1111    case 17:
   case 19:  
1112  #line 161 "parse-gram.y"  #line 161 "parse-gram.y"
1113      { skeleton = yyvsp[0].string; }  { pure_parser = 1; }
1114      break;      break;
1115    case 18:
   case 20:  
1116  #line 162 "parse-gram.y"  #line 162 "parse-gram.y"
1117      { token_table_flag = 1; }  { skeleton = yyvsp[0].string; }
1118      break;      break;
1119    case 19:
   case 21:  
1120  #line 163 "parse-gram.y"  #line 163 "parse-gram.y"
1121      { report_flag = 1; }  { token_table_flag = 1; }
1122      break;      break;
1123    case 20:
   case 22:  
1124  #line 164 "parse-gram.y"  #line 164 "parse-gram.y"
1125      { yacc_flag = 1; }  { report_flag = 1; }
1126      break;      break;
1127    case 21:
1128    case 24:  #line 165 "parse-gram.y"
1129  #line 169 "parse-gram.y"  { yacc_flag = 1; }
     { current_class = nterm_sym; }  
1130      break;      break;
1131    case 23:
   case 25:  
1132  #line 170 "parse-gram.y"  #line 170 "parse-gram.y"
1133      {  { current_class = nterm_sym; }
1134        break;
1135    case 24:
1136    #line 171 "parse-gram.y"
1137    {
1138        current_class = unknown_sym;        current_class = unknown_sym;
1139        current_type = NULL;        current_type = NULL;
1140      }      }
1141      break;      break;
1142    case 25:
1143    case 26:  #line 176 "parse-gram.y"
1144  #line 175 "parse-gram.y"  {
     {  
1145        grammar_start_symbol_set (yyvsp[0].symbol);        grammar_start_symbol_set (yyvsp[0].symbol);
1146      }      }
1147      break;      break;
1148    case 26:
   case 27:  
 #line 178 "parse-gram.y"  
     { current_class = token_sym; }  
     break;  
   
   case 28:  
1149  #line 179 "parse-gram.y"  #line 179 "parse-gram.y"
1150      {  { current_class = token_sym; }
1151        break;
1152    case 27:
1153    #line 180 "parse-gram.y"
1154    {
1155        current_class = unknown_sym;        current_class = unknown_sym;
1156        current_type = NULL;        current_type = NULL;
1157      }      }
1158      break;      break;
1159    case 28:
   case 29:  
 #line 183 "parse-gram.y"  
     {current_type = yyvsp[0].string; }  
     break;  
   
   case 30:  
1160  #line 184 "parse-gram.y"  #line 184 "parse-gram.y"
1161      {  {current_type = yyvsp[0].string; }
1162        break;
1163    case 29:
1164    #line 185 "parse-gram.y"
1165    {
1166        current_type = NULL;        current_type = NULL;
1167      }      }
1168      break;      break;
1169    case 30:
1170    case 31:  #line 189 "parse-gram.y"
1171  #line 188 "parse-gram.y"  {
     {  
1172        typed = 1;        typed = 1;
1173        MUSCLE_INSERT_INT ("stype_line", yylsp[-1].first_line);        MUSCLE_INSERT_INT ("stype_line", yylsp[-1].first_line);
1174        muscle_insert ("stype", yyvsp[-1].string);        muscle_insert ("stype", yyvsp[-1].string);
1175      }      }
1176      break;      break;
1177    case 31:
1178    case 32:  #line 198 "parse-gram.y"
1179  #line 197 "parse-gram.y"  { current_assoc = yyvsp[-1].assoc; ++current_prec; }
1180      { current_assoc = yyvsp[-1].assoc; ++current_prec; }      break;
1181    case 32:
1182    #line 200 "parse-gram.y"
1183    { current_assoc = non_assoc; current_type = NULL; }
1184      break;      break;
1185    case 33:
   case 33:  
 #line 199 "parse-gram.y"  
     { current_assoc = non_assoc; current_type = NULL; }  
     break;  
   
   case 34:  
 #line 203 "parse-gram.y"  
     { yyval.assoc = left_assoc; }  
     break;  
   
   case 35:  
1186  #line 204 "parse-gram.y"  #line 204 "parse-gram.y"
1187      { yyval.assoc = right_assoc; }  { yyval.assoc = left_assoc; }
1188      break;      break;
1189    case 34:
   case 36:  
1190  #line 205 "parse-gram.y"  #line 205 "parse-gram.y"
1191      { yyval.assoc = non_assoc; }  { yyval.assoc = right_assoc; }
1192      break;      break;
1193    case 35:
1194    case 37:  #line 206 "parse-gram.y"
1195  #line 209 "parse-gram.y"  { yyval.assoc = non_assoc; }
     { current_type = NULL;}  
1196      break;      break;
1197    case 36:
   case 38:  
1198  #line 210 "parse-gram.y"  #line 210 "parse-gram.y"
1199      { current_type = yyvsp[0].string; }  { current_type = NULL;}
1200      break;      break;
1201    case 37:
1202    case 39:  #line 211 "parse-gram.y"
1203  #line 215 "parse-gram.y"  { current_type = yyvsp[0].string; }
     { symbol_type_set (yyvsp[0].symbol, current_type); }  
1204      break;      break;
1205    case 38:
   case 40:  
1206  #line 216 "parse-gram.y"  #line 216 "parse-gram.y"
1207      { symbol_type_set (yyvsp[0].symbol, current_type); }  { symbol_type_set (yyvsp[0].symbol, current_type); }
1208      break;      break;
1209    case 39:
1210    case 41:  #line 217 "parse-gram.y"
1211  #line 222 "parse-gram.y"  { symbol_type_set (yyvsp[0].symbol, current_type); }
1212      {      break;
1213    case 40:
1214    #line 223 "parse-gram.y"
1215    {
1216        symbol_type_set (yyvsp[0].symbol, current_type);        symbol_type_set (yyvsp[0].symbol, current_type);
1217        symbol_precedence_set (yyvsp[0].symbol, current_prec, current_assoc);        symbol_precedence_set (yyvsp[0].symbol, current_prec, current_assoc);
1218      }      }
1219      break;      break;
1220    case 41:
1221    case 42:  #line 228 "parse-gram.y"
1222  #line 227 "parse-gram.y"  {
     {  
1223        symbol_type_set (yyvsp[0].symbol, current_type);        symbol_type_set (yyvsp[0].symbol, current_type);
1224        symbol_precedence_set (yyvsp[0].symbol, current_prec, current_assoc);        symbol_precedence_set (yyvsp[0].symbol, current_prec, current_assoc);
1225      }      }
1226      break;      break;
1227    case 42:
1228    case 43:  #line 238 "parse-gram.y"
1229  #line 237 "parse-gram.y"  {
     {  
1230         current_type = yyvsp[0].string;         current_type = yyvsp[0].string;
1231       }       }
1232      break;      break;
1233    case 43:
1234    case 44:  #line 242 "parse-gram.y"
1235  #line 241 "parse-gram.y"  {
     {  
1236         symbol_class_set (yyvsp[0].symbol, current_class);         symbol_class_set (yyvsp[0].symbol, current_class);
1237         symbol_type_set (yyvsp[0].symbol, current_type);         symbol_type_set (yyvsp[0].symbol, current_type);
1238       }       }
1239      break;      break;
1240    case 44:
1241    case 45:  #line 247 "parse-gram.y"
1242  #line 246 "parse-gram.y"  {
     {  
1243        symbol_class_set (yyvsp[-1].symbol, current_class);        symbol_class_set (yyvsp[-1].symbol, current_class);
1244        symbol_type_set (yyvsp[-1].symbol, current_type);        symbol_type_set (yyvsp[-1].symbol, current_type);
1245        symbol_user_token_number_set (yyvsp[-1].symbol, yyvsp[0].integer);        symbol_user_token_number_set (yyvsp[-1].symbol, yyvsp[0].integer);
1246      }      }
1247      break;      break;
1248    case 45:
1249    case 46:  #line 253 "parse-gram.y"
1250  #line 252 "parse-gram.y"  {
     {  
1251        symbol_class_set (yyvsp[-1].symbol, current_class);        symbol_class_set (yyvsp[-1].symbol, current_class);
1252        symbol_type_set (yyvsp[-1].symbol, current_type);        symbol_type_set (yyvsp[-1].symbol, current_type);
1253        symbol_make_alias (yyvsp[-1].symbol, yyvsp[0].symbol);        symbol_make_alias (yyvsp[-1].symbol, yyvsp[0].symbol);
1254      }      }
1255      break;      break;
1256    case 46:
1257    case 47:  #line 259 "parse-gram.y"
1258  #line 258 "parse-gram.y"  {
     {  
1259        symbol_class_set (yyvsp[-2].symbol, current_class);        symbol_class_set (yyvsp[-2].symbol, current_class);
1260        symbol_type_set (yyvsp[-2].symbol, current_type);        symbol_type_set (yyvsp[-2].symbol, current_type);
1261        symbol_user_token_number_set (yyvsp[-2].symbol, yyvsp[-1].integer);        symbol_user_token_number_set (yyvsp[-2].symbol, yyvsp[-1].integer);
1262        symbol_make_alias (yyvsp[-2].symbol, yyvsp[0].symbol);        symbol_make_alias (yyvsp[-2].symbol, yyvsp[0].symbol);
1263      }      }
1264      break;      break;
1265    case 47:
1266    case 48:  #line 270 "parse-gram.y"
1267  #line 269 "parse-gram.y"  {;}
1268      {;}      break;
1269      break;  case 48:
1270    #line 272 "parse-gram.y"
1271    case 49:  {;}
 #line 271 "parse-gram.y"  
     {;}  
     break;  
   
   case 52:  
 #line 280 "parse-gram.y"  
     { current_lhs = yyvsp[-1].symbol; }  
1272      break;      break;
1273    case 51:
   case 53:  
1274  #line 281 "parse-gram.y"  #line 281 "parse-gram.y"
1275      {;}  { current_lhs = yyvsp[-1].symbol; }
1276      break;      break;
1277    case 52:
1278    case 54:  #line 282 "parse-gram.y"
1279  #line 285 "parse-gram.y"  {;}
     { grammar_rule_end (); }  
1280      break;      break;
1281    case 53:
   case 55:  
1282  #line 286 "parse-gram.y"  #line 286 "parse-gram.y"
1283      { grammar_rule_end (); }  { grammar_rule_end (); }
1284      break;      break;
1285    case 54:
1286    case 56:  #line 287 "parse-gram.y"
1287  #line 291 "parse-gram.y"  { grammar_rule_end (); }
     { grammar_rule_begin (current_lhs); }  
1288      break;      break;
1289    case 55:
1290    case 57:  #line 292 "parse-gram.y"
1291  #line 293 "parse-gram.y"  { grammar_rule_begin (current_lhs); }
     { grammar_current_rule_symbol_append (yyvsp[0].symbol); }  
1292      break;      break;
1293    case 56:
1294    case 58:  #line 294 "parse-gram.y"
1295  #line 295 "parse-gram.y"  { grammar_current_rule_symbol_append (yyvsp[0].symbol); }
     { grammar_current_rule_action_append (yyvsp[0].string, yylsp[0].first_line); }  
1296      break;      break;
1297    case 57:
1298    case 59:  #line 296 "parse-gram.y"
1299  #line 297 "parse-gram.y"  { grammar_current_rule_action_append (yyvsp[0].string, yylsp[0].first_line); }
     { grammar_current_rule_prec_set (yyvsp[0].symbol); }  
1300      break;      break;
1301    case 58:
1302    case 60:  #line 298 "parse-gram.y"
1303  #line 301 "parse-gram.y"  { grammar_current_rule_prec_set (yyvsp[0].symbol); }
     { yyval.symbol = yyvsp[0].symbol; }  
1304      break;      break;
1305    case 59:
   case 61:  
1306  #line 302 "parse-gram.y"  #line 302 "parse-gram.y"
1307      { yyval.symbol = yyvsp[0].symbol; }  { yyval.symbol = yyvsp[0].symbol; }
1308      break;      break;
1309    case 60:
   case 62:  
1310  #line 303 "parse-gram.y"  #line 303 "parse-gram.y"
1311      { yyval.symbol = getsym (yyvsp[0].string); }  { yyval.symbol = yyvsp[0].symbol; }
1312      break;      break;
1313    case 61:
1314    case 63:  #line 304 "parse-gram.y"
1315  #line 308 "parse-gram.y"  { yyval.symbol = getsym (yyvsp[0].string); }
1316      { yyval.string = yyvsp[0].string; }      break;
1317    case 62:
1318    #line 309 "parse-gram.y"
1319    { yyval.string = yyvsp[0].string; }
1320      break;      break;
1321    case 63:
1322    case 64:  #line 315 "parse-gram.y"
1323  #line 314 "parse-gram.y"  {
     {  
1324        yyval.symbol = getsym (yyvsp[0].string);        yyval.symbol = getsym (yyvsp[0].string);
1325        symbol_class_set (yyval.symbol, token_sym);        symbol_class_set (yyval.symbol, token_sym);
1326      }      }
1327      break;      break;
1328    case 64:
1329    case 65:  #line 324 "parse-gram.y"
1330  #line 323 "parse-gram.y"  {
     {  
1331        yyval.string = yyvsp[0].string + 1;        yyval.string = yyvsp[0].string + 1;
1332        yyval.string[strlen (yyval.string) - 1] = '\0';        yyval.string[strlen (yyval.string) - 1] = '\0';
1333      }      }
1334      break;      break;
1335    case 65:
1336    case 66:  #line 332 "parse-gram.y"
1337  #line 331 "parse-gram.y"  {
     {  
1338        yyval.string = xstrdup ("");        yyval.string = xstrdup ("");
1339      }      }
1340      break;      break;
1341    case 66:
1342    case 67:  #line 336 "parse-gram.y"
1343  #line 335 "parse-gram.y"  {
     {  
1344        yyval.string = yyvsp[0].string;        yyval.string = yyvsp[0].string;
1345      }      }
1346      break;      break;
1347    }
1348    
1349    #line 705 "/usr/share/bison/bison.simple"
1350    
     }  
   
 /* Line 1010 of /usr/local/share/bison/bison.simple.  */  
 #line 1523 "parse-gram.c"  
1351    
1352    yyvsp -= yylen;    yyvsp -= yylen;
1353    yyssp -= yylen;    yyssp -= yylen;
# Line 1549  yyreduce: Line 1377  yyreduce:
1377    
1378    yyn = yyr1[yyn];    yyn = yyr1[yyn];
1379    
1380    yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;    yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
1381    if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)    if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1382      yystate = yytable[yystate];      yystate = yytable[yystate];
1383    else    else
1384      yystate = yydefgoto[yyn - YYNTOKENS];      yystate = yydefgoto[yyn - YYNTBASE];
1385    
1386    goto yynewstate;    goto yynewstate;
1387    
# Line 1567  yyerrlab: Line 1395  yyerrlab:
1395      {      {
1396        ++yynerrs;        ++yynerrs;
1397    
1398  #if YYERROR_VERBOSE  #ifdef YYERROR_VERBOSE
1399        yyn = yypact[yystate];        yyn = yypact[yystate];
1400    
1401        if (yyn > YYFLAG && yyn < YYLAST)        if (yyn > YYFLAG && yyn < YYLAST)
# Line 1607  yyerrlab: Line 1435  yyerrlab:
1435                  }                  }
1436                yyerror (yymsg);                yyerror (yymsg);
1437                YYSTACK_FREE (yymsg);                YYSTACK_FREE (yymsg);
1438              }              }
1439            else            else
1440              yyerror ("parse error; also virtual memory exhausted");              yyerror ("parse error; also virtual memory exhausted");
1441          }          }
1442        else        else
1443  #endif /* YYERROR_VERBOSE */  #endif /* defined (YYERROR_VERBOSE) */
1444          yyerror ("parse error");          yyerror ("parse error");
1445      }      }
1446    goto yyerrlab1;    goto yyerrlab1;
1447    
1448    
1449  /*----------------------------------------------------.  /*--------------------------------------------------.
1450  | yyerrlab1 -- error raised explicitly by an action.  |  | yyerrlab1 -- error raised explicitly by an action |
1451  `----------------------------------------------------*/  `--------------------------------------------------*/
1452  yyerrlab1:  yyerrlab1:
1453    if (yyerrstatus == 3)    if (yyerrstatus == 3)
1454      {      {
1455        /* If just tried and failed to reuse lookahead token after an        /* If just tried and failed to reuse lookahead token after an
1456           error, discard it.  */           error, discard it.  */
1457    
1458        /* Return failure if at end of input.  */        /* return failure if at end of input */
1459        if (yychar == YYEOF)        if (yychar == YYEOF)
1460          YYABORT;          YYABORT;
1461        YYDPRINTF ((stderr, "Discarding token %d (%s).\n",        YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
# Line 1638  yyerrlab1: Line 1466  yyerrlab1:
1466    /* Else will try to reuse lookahead token after shifting the error    /* Else will try to reuse lookahead token after shifting the error
1467       token.  */       token.  */
1468    
1469    yyerrstatus = 3;      /* Each real token shifted decrements this.  */    yyerrstatus = 3;              /* Each real token shifted decrements this */
1470    
1471    for (;;)    goto yyerrhandle;
     {  
       yyn = yypact[yystate];  
       if (yyn != YYFLAG)  
         {  
           yyn += YYTERROR;  
           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)  
             {  
               yyn = yytable[yyn];  
               if (0 < yyn)  
                 break;  
             }  
         }  
1472    
       /* Pop the current state because it cannot handle the error token.  */  
       if (yyssp == yyss)  
         YYABORT;  
1473    
1474  #if YYDEBUG  /*-------------------------------------------------------------------.
1475        if (yydebug)  | yyerrdefault -- current state does not do anything special for the |
1476          {  | error token.                                                       |
1477            if (yystos[yystate] < YYNTOKENS)  `-------------------------------------------------------------------*/
1478              {  yyerrdefault:
1479                YYFPRINTF (stderr, "Error: popping token %d (%s",  #if 0
1480                           yytoknum[yystos[yystate]], yytname[yystos[yystate]]);    /* This is wrong; only states that explicitly want error tokens
1481  # ifdef YYPRINT       should shift them.  */
1482                YYPRINT (stderr, yytoknum[yystos[yystate]], *yyvsp);  
1483  # endif    /* If its default is to accept any token, ok.  Otherwise pop it.  */
1484                YYFPRINTF (stderr, ")\n");    yyn = yydefact[yystate];
1485              }    if (yyn)
1486            else      goto yydefault;
             {  
               YYFPRINTF (stderr, "Error: popping nonterminal (%s)\n",  
                          yytname[yystos[yystate]]);  
             }  
         }  
1487  #endif  #endif
1488    
1489        yyvsp--;  
1490        yystate = *--yyssp;  /*---------------------------------------------------------------.
1491    | yyerrpop -- pop the current state because it cannot handle the |
1492    | error token                                                    |
1493    `---------------------------------------------------------------*/
1494    yyerrpop:
1495      if (yyssp == yyss)
1496        YYABORT;
1497      yyvsp--;
1498      yystate = *--yyssp;
1499  #if YYLSP_NEEDED  #if YYLSP_NEEDED
1500        yylsp--;    yylsp--;
1501  #endif  #endif
1502    
1503  #if YYDEBUG  #if YYDEBUG
1504        if (yydebug)    if (yydebug)
1505          {      {
1506            short *yyssp1 = yyss - 1;        short *yyssp1 = yyss - 1;
1507            YYFPRINTF (stderr, "Error: state stack now");        YYFPRINTF (stderr, "Error: state stack now");
1508            while (yyssp1 != yyssp)        while (yyssp1 != yyssp)
1509              YYFPRINTF (stderr, " %d", *++yyssp1);          YYFPRINTF (stderr, " %d", *++yyssp1);
1510            YYFPRINTF (stderr, "\n");        YYFPRINTF (stderr, "\n");
1511          }      }
1512  #endif  #endif
1513    
1514    /*--------------.
1515    | yyerrhandle.  |
1516    `--------------*/
1517    yyerrhandle:
1518      yyn = yypact[yystate];
1519      if (yyn == YYFLAG)
1520        goto yyerrdefault;
1521    
1522      yyn += YYTERROR;
1523      if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
1524        goto yyerrdefault;
1525    
1526      yyn = yytable[yyn];
1527      if (yyn < 0)
1528        {
1529          if (yyn == YYFLAG)
1530            goto yyerrpop;
1531          yyn = -yyn;
1532          goto yyreduce;
1533      }      }
1534      else if (yyn == 0)
1535        goto yyerrpop;
1536    
1537    if (yyn == YYFINAL)    if (yyn == YYFINAL)
1538      YYACCEPT;      YYACCEPT;
# Line 1739  yyreturn: Line 1577  yyreturn:
1577  #endif  #endif
1578    return yyresult;    return yyresult;
1579  }  }
1580    #line 345 "parse-gram.y"
 #line 344 "parse-gram.y"  
1581    
1582  /*------------------------------------------------------------------.  /*------------------------------------------------------------------.
1583  | When debugging the parser, display tokens' locations and values.  |  | When debugging the parser, display tokens' locations and values.  |
# Line 1748  yyreturn: Line 1585  yyreturn:
1585    
1586  static void  static void
1587  yyprint (FILE *file,  yyprint (FILE *file,
1588           const yyltype *loc, int type, const yystype *value)           const location_t *loc, int type, const yystype *value)
1589  {  {
1590    fputs (" (", file);    fputs (" (", file);
1591    LOCATION_PRINT (file, *loc);    LOCATION_PRINT (file, *loc);
# Line 1785  yyprint (FILE *file, Line 1622  yyprint (FILE *file,
1622    
1623  void  void
1624  gram_error (gram_control_t *control ATTRIBUTE_UNUSED,  gram_error (gram_control_t *control ATTRIBUTE_UNUSED,
1625              yyltype *yylloc, const char *msg)              location_t *yylloc, const char *msg)
1626  {  {
1627    LOCATION_PRINT (stderr, *yylloc);    LOCATION_PRINT (stderr, *yylloc);
1628    fprintf (stderr, ": %s\n", msg);    fprintf (stderr, ": %s\n", msg);
1629  }  }
   

Legend:
Removed from v.1.3  
changed lines
  Added in v.1.4

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26