source: abnfparser/bap/parser.c @ 405

Last change on this file since 405 was 405, checked in by julian.reschke@…, 11 years ago

add custom version of Bill Fenner's ABNF Parser (BAP)

File size: 54.0 KB
Line 
1/* A Bison parser, made by GNU Bison 2.1.  */
2
3/* Skeleton parser for Yacc-like parsing with Bison,
4   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
5
6   This program is free software; you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation; either version 2, or (at your option)
9   any later version.
10
11   This program is distributed in the hope that it will be useful,
12   but WITHOUT ANY WARRANTY; without even the implied warranty of
13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14   GNU General Public License for more details.
15
16   You should have received a copy of the GNU General Public License
17   along with this program; if not, write to the Free Software
18   Foundation, Inc., 51 Franklin Street, Fifth Floor,
19   Boston, MA 02110-1301, 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.  */
28
29/* All symbols defined below should begin with yy or YY, to avoid
30   infringing on user name space.  This should be done even for local
31   variables, as they might otherwise be expanded by user macros.
32   There are some unavoidable exceptions within include files to
33   define necessary library symbols; they are noted "INFRINGES ON
34   USER NAME SPACE" below.  */
35
36/* Identify Bison output.  */
37#define YYBISON 1
38
39/* Bison version.  */
40#define YYBISON_VERSION "2.1"
41
42/* Skeleton name.  */
43#define YYSKELETON_NAME "yacc.c"
44
45/* Pure parsers.  */
46#define YYPURE 0
47
48/* Using locations.  */
49#define YYLSP_NEEDED 0
50
51
52
53/* Tokens.  */
54#ifndef YYTOKENTYPE
55# define YYTOKENTYPE
56   /* Put the tokens into the symbol table, so that GDB and other debuggers
57      know about them.  */
58   enum yytokentype {
59     CHARVAL = 258,
60     PROSEVAL = 259,
61     BINVAL = 260,
62     DECVAL = 261,
63     HEXVAL = 262,
64     RULENAME = 263,
65     BINVALRANGE = 264,
66     DECVALRANGE = 265,
67     HEXVALRANGE = 266,
68     REPEAT = 267,
69     LIST = 268,
70     CWSP = 269,
71     EQSLASH = 270,
72     CRLF = 271
73   };
74#endif
75/* Tokens.  */
76#define CHARVAL 258
77#define PROSEVAL 259
78#define BINVAL 260
79#define DECVAL 261
80#define HEXVAL 262
81#define RULENAME 263
82#define BINVALRANGE 264
83#define DECVALRANGE 265
84#define HEXVALRANGE 266
85#define REPEAT 267
86#define LIST 268
87#define CWSP 269
88#define EQSLASH 270
89#define CRLF 271
90
91
92
93
94/* Copy the first part of user declarations.  */
95#line 1 "parser.y"
96
97/*
98 * Bill's ABNF parser.
99 * Copyright 2002-2004 William C. Fenner <fenner@fenron.com>
100 *  All rights reserved.
101 *
102 * Redistribution and use in source and binary forms, with or without
103 * modification, are permitted provided that the following conditions
104 * are met:
105 * 1. Redistributions of source code must retain the above copyright
106 *    notice, this list of conditions and the following disclaimer.
107 * 2. Redistributions in binary form must reproduce the above copyright
108 *    notice, this list of conditions and the following disclaimer in the
109 *    documentation and/or other materials provided with the distribution.
110 * 3. Neither the name of the author nor the names of contributors
111 *    may be used to endorse or promote products derived from this software
112 *    without specific prior written permission.
113 *
114 * THIS SOFTWARE IS PROVIDED BY WILLIAM C. FENNER ``AS IS'' AND
115 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
116 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
117 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL WILLIAM C. FENNER OR HIS
118 * BROTHER B1FF BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
119 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
120 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
121 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
122 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
123 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
124 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
125 * DAMAGE.
126 */
127
128#include "config.h"
129#include <stdio.h>
130#include <stdlib.h>
131#include <stdarg.h>
132#include <string.h>
133
134#include "common.h"
135
136static const char rcsid[] =
137 "$Id: parser.y,v 1.1 2008-05-28 12:01:58 jre Exp $";
138
139extern int yylineno, yycolumn, yyerrors;
140
141int defline;
142extern struct rule *rules;
143extern char *input_file;
144
145#if defined(YYERROR_VERBOSE) && defined(YYBISON)
146#define MYERROR_VERBOSE
147#endif
148#ifdef MYERROR_VERBOSE
149/* HACK-O-ROONIE for yyerror verbosity */
150int *yystatep = NULL;
151int *yychar1p = NULL;
152#endif
153
154int pipewarn = 0;
155
156object *newobj(int);
157int yyerror(char *);
158int yylex(void);
159
160
161/* Enabling traces.  */
162#ifndef YYDEBUG
163# define YYDEBUG 0
164#endif
165
166/* Enabling verbose error messages.  */
167#ifdef YYERROR_VERBOSE
168# undef YYERROR_VERBOSE
169# define YYERROR_VERBOSE 1
170#else
171# define YYERROR_VERBOSE 0
172#endif
173
174/* Enabling the token table.  */
175#ifndef YYTOKEN_TABLE
176# define YYTOKEN_TABLE 0
177#endif
178
179#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
180#line 66 "parser.y"
181typedef union YYSTYPE {
182        char *string;
183        struct range range;
184        object *object;
185        int retval;
186} YYSTYPE;
187/* Line 196 of yacc.c.  */
188#line 189 "y.tab.c"
189# define yystype YYSTYPE /* obsolescent; will be withdrawn */
190# define YYSTYPE_IS_DECLARED 1
191# define YYSTYPE_IS_TRIVIAL 1
192#endif
193
194
195
196/* Copy the second part of user declarations.  */
197
198
199/* Line 219 of yacc.c.  */
200#line 201 "y.tab.c"
201
202#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
203# define YYSIZE_T __SIZE_TYPE__
204#endif
205#if ! defined (YYSIZE_T) && defined (size_t)
206# define YYSIZE_T size_t
207#endif
208#if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
209# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
210# define YYSIZE_T size_t
211#endif
212#if ! defined (YYSIZE_T)
213# define YYSIZE_T unsigned int
214#endif
215
216#ifndef YY_
217# if YYENABLE_NLS
218#  if ENABLE_NLS
219#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
220#   define YY_(msgid) dgettext ("bison-runtime", msgid)
221#  endif
222# endif
223# ifndef YY_
224#  define YY_(msgid) msgid
225# endif
226#endif
227
228#if ! defined (yyoverflow) || YYERROR_VERBOSE
229
230/* The parser invokes alloca or malloc; define the necessary symbols.  */
231
232# ifdef YYSTACK_USE_ALLOCA
233#  if YYSTACK_USE_ALLOCA
234#   ifdef __GNUC__
235#    define YYSTACK_ALLOC __builtin_alloca
236#   else
237#    define YYSTACK_ALLOC alloca
238#    if defined (__STDC__) || defined (__cplusplus)
239#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
240#     define YYINCLUDED_STDLIB_H
241#    endif
242#   endif
243#  endif
244# endif
245
246# ifdef YYSTACK_ALLOC
247   /* Pacify GCC's `empty if-body' warning. */
248#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
249#  ifndef YYSTACK_ALLOC_MAXIMUM
250    /* The OS might guarantee only one guard page at the bottom of the stack,
251       and a page size can be as small as 4096 bytes.  So we cannot safely
252       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
253       to allow for a few compiler-allocated temporary stack slots.  */
254#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
255#  endif
256# else
257#  define YYSTACK_ALLOC YYMALLOC
258#  define YYSTACK_FREE YYFREE
259#  ifndef YYSTACK_ALLOC_MAXIMUM
260#   define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
261#  endif
262#  ifdef __cplusplus
263extern "C" {
264#  endif
265#  ifndef YYMALLOC
266#   define YYMALLOC malloc
267#   if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
268        && (defined (__STDC__) || defined (__cplusplus)))
269void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
270#   endif
271#  endif
272#  ifndef YYFREE
273#   define YYFREE free
274#   if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
275        && (defined (__STDC__) || defined (__cplusplus)))
276void free (void *); /* INFRINGES ON USER NAME SPACE */
277#   endif
278#  endif
279#  ifdef __cplusplus
280}
281#  endif
282# endif
283#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
284
285
286#if (! defined (yyoverflow) \
287     && (! defined (__cplusplus) \
288         || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
289
290/* A type that is properly aligned for any stack member.  */
291union yyalloc
292{
293  short int yyss;
294  YYSTYPE yyvs;
295  };
296
297/* The size of the maximum gap between one aligned stack and the next.  */
298# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
299
300/* The size of an array large to enough to hold all stacks, each with
301   N elements.  */
302# define YYSTACK_BYTES(N) \
303     ((N) * (sizeof (short int) + sizeof (YYSTYPE))                     \
304      + YYSTACK_GAP_MAXIMUM)
305
306/* Copy COUNT objects from FROM to TO.  The source and destination do
307   not overlap.  */
308# ifndef YYCOPY
309#  if defined (__GNUC__) && 1 < __GNUC__
310#   define YYCOPY(To, From, Count) \
311      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
312#  else
313#   define YYCOPY(To, From, Count)              \
314      do                                        \
315        {                                       \
316          YYSIZE_T yyi;                         \
317          for (yyi = 0; yyi < (Count); yyi++)   \
318            (To)[yyi] = (From)[yyi];            \
319        }                                       \
320      while (0)
321#  endif
322# endif
323
324/* Relocate STACK from its old location to the new one.  The
325   local variables YYSIZE and YYSTACKSIZE give the old and new number of
326   elements in the stack, and YYPTR gives the new location of the
327   stack.  Advance YYPTR to a properly aligned location for the next
328   stack.  */
329# define YYSTACK_RELOCATE(Stack)                                        \
330    do                                                                  \
331      {                                                                 \
332        YYSIZE_T yynewbytes;                                            \
333        YYCOPY (&yyptr->Stack, Stack, yysize);                          \
334        Stack = &yyptr->Stack;                                          \
335        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
336        yyptr += yynewbytes / sizeof (*yyptr);                          \
337      }                                                                 \
338    while (0)
339
340#endif
341
342#if defined (__STDC__) || defined (__cplusplus)
343   typedef signed char yysigned_char;
344#else
345   typedef short int yysigned_char;
346#endif
347
348/* YYFINAL -- State number of the termination state. */
349#define YYFINAL  3
350/* YYLAST -- Last index in YYTABLE.  */
351#define YYLAST   175
352
353/* YYNTOKENS -- Number of terminals. */
354#define YYNTOKENS  24
355/* YYNNTS -- Number of nonterminals. */
356#define YYNNTS  20
357/* YYNRULES -- Number of rules. */
358#define YYNRULES  56
359/* YYNRULES -- Number of states. */
360#define YYNSTATES  83
361
362/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
363#define YYUNDEFTOK  2
364#define YYMAXUTOK   271
365
366#define YYTRANSLATE(YYX)                                                \
367  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
368
369/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
370static const unsigned char yytranslate[] =
371{
372       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
373       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
374       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
375       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
376      22,    18,     2,     2,     2,     2,     2,    20,     2,     2,
377       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
378       2,    17,     2,     2,     2,     2,     2,     2,     2,     2,
379       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
380       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
381       2,    23,     2,    19,     2,     2,     2,     2,     2,     2,
382       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
383       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
384       2,     2,     2,     2,    21,     2,     2,     2,     2,     2,
385       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
386       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
387       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
388       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
389       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
390       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
391       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
392       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
393       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
394       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
395       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
396       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
397       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
398       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
399      15,    16
400};
401
402#if YYDEBUG
403/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
404   YYRHS.  */
405static const unsigned char yyprhs[] =
406{
407       0,     0,     3,     4,     7,     9,    12,    14,    17,    20,
408      21,    24,    25,    31,    35,    39,    44,    47,    50,    52,
409      53,    55,    59,    62,    65,    67,    69,    73,    77,    83,
410      89,    95,   101,   104,   108,   112,   114,   117,   120,   123,
411     126,   128,   130,   132,   134,   136,   138,   140,   142,   144,
412     146,   148,   150,   152,   158,   164,   170
413};
414
415/* YYRHS -- A `-1'-separated list of the rules' RHS. */
416static const yysigned_char yyrhs[] =
417{
418      25,     0,    -1,    -1,    26,    27,    -1,    28,    -1,    27,
419      28,    -1,    30,    -1,    34,    16,    -1,    33,     8,    -1,
420      -1,     1,    16,    -1,    -1,    29,     8,    31,    32,    35,
421      -1,    34,    15,    34,    -1,    34,    17,    34,    -1,    34,
422      17,    34,    16,    -1,    34,    37,    -1,    34,    16,    -1,
423      14,    -1,    -1,    14,    -1,    36,    34,    16,    -1,    36,
424      18,    -1,    36,    19,    -1,    37,    -1,    38,    -1,    36,
425      33,    37,    -1,    36,    33,    38,    -1,    36,    34,    20,
426      34,    37,    -1,    36,    34,    21,    34,    37,    -1,    36,
427      34,    20,    34,    38,    -1,    36,    34,    21,    34,    38,
428      -1,    36,    37,    -1,    36,    34,    17,    -1,    36,    34,
429      15,    -1,    41,    -1,    12,    41,    -1,    12,    33,    -1,
430      13,    41,    -1,    13,    33,    -1,     5,    -1,     6,    -1,
431       7,    -1,     9,    -1,    10,    -1,    11,    -1,     8,    -1,
432      42,    -1,    43,    -1,     3,    -1,    39,    -1,    40,    -1,
433       4,    -1,    22,    34,    36,    34,    18,    -1,    22,    34,
434      36,    34,    16,    -1,    23,    34,    36,    34,    19,    -1,
435      23,    34,    36,    34,    16,    -1
436};
437
438/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
439static const unsigned short int yyrline[] =
440{
441       0,    85,    85,    85,    92,    93,    96,    97,    98,   101,
442     102,   105,   105,   152,   153,   154,   155,   156,   159,   162,
443     163,   167,   168,   169,   173,   174,   175,   186,   197,   202,
444     211,   216,   225,   239,   243,   250,   251,   263,   270,   285,
445     291,   292,   293,   297,   298,   299,   303,   310,   311,   312,
446     324,   329,   334,   343,   347,   353,   358
447};
448#endif
449
450#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
451/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
452   First, the terminals, then, starting at YYNTOKENS, nonterminals. */
453static const char *const yytname[] =
454{
455  "$end", "error", "$undefined", "CHARVAL", "PROSEVAL", "BINVAL",
456  "DECVAL", "HEXVAL", "RULENAME", "BINVALRANGE", "DECVALRANGE",
457  "HEXVALRANGE", "REPEAT", "LIST", "CWSP", "EQSLASH", "CRLF", "'='", "')'",
458  "']'", "'/'", "'|'", "'('", "'['", "$accept", "begin", "@1", "rulelist",
459  "rules", "recover", "rule", "@2", "definedas", "cwsp", "starcwsp",
460  "rulerest", "elements", "repetition", "list", "numval", "numvalrange",
461  "element", "group", "option", 0
462};
463#endif
464
465# ifdef YYPRINT
466/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
467   token YYLEX-NUM.  */
468static const unsigned short int yytoknum[] =
469{
470       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
471     265,   266,   267,   268,   269,   270,   271,    61,    41,    93,
472      47,   124,    40,    91
473};
474# endif
475
476/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
477static const unsigned char yyr1[] =
478{
479       0,    24,    26,    25,    27,    27,    28,    28,    28,    29,
480      29,    31,    30,    32,    32,    32,    32,    32,    33,    34,
481      34,    35,    35,    35,    36,    36,    36,    36,    36,    36,
482      36,    36,    36,    36,    36,    37,    37,    37,    38,    38,
483      39,    39,    39,    40,    40,    40,    41,    41,    41,    41,
484      41,    41,    41,    42,    42,    43,    43
485};
486
487/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
488static const unsigned char yyr2[] =
489{
490       0,     2,     0,     2,     1,     2,     1,     2,     2,     0,
491       2,     0,     5,     3,     3,     4,     2,     2,     1,     0,
492       1,     3,     2,     2,     1,     1,     3,     3,     5,     5,
493       5,     5,     2,     3,     3,     1,     2,     2,     2,     2,
494       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
495       1,     1,     1,     5,     5,     5,     5
496};
497
498/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
499   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
500   means the default is an error.  */
501static const unsigned char yydefact[] =
502{
503       2,     0,     0,     1,     0,    18,     0,     4,     0,     6,
504       0,     0,    10,     5,    11,     8,     7,    19,    20,     0,
505       0,    49,    52,    40,    41,    42,    46,    43,    44,    45,
506       0,     0,    19,    19,    12,    19,    24,    25,    50,    51,
507      35,    47,    48,    19,    17,    19,    16,    18,    37,    36,
508      39,    38,     0,     0,    22,    23,     0,     0,    32,    13,
509      14,    19,    19,    26,    27,    34,    21,    33,    19,    19,
510      15,     0,     0,     0,     0,    54,    53,    56,    55,    28,
511      30,    29,    31
512};
513
514/* YYDEFGOTO[NTERM-NUM]. */
515static const yysigned_char yydefgoto[] =
516{
517      -1,     1,     2,     6,     7,     8,     9,    17,    19,    56,
518      11,    34,    35,    36,    37,    38,    39,    40,    41,    42
519};
520
521/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
522   STATE-NUM.  */
523#define YYPACT_NINF -51
524static const short int yypact[] =
525{
526     -51,     1,    13,   -51,    -3,    95,     2,   -51,     9,   -51,
527      17,    10,   -51,   -51,   -51,   -51,   -51,    14,   -51,    96,
528      54,   -51,   -51,   -51,   -51,   -51,   -51,   -51,   -51,   -51,
529     138,   138,    14,    14,   -51,    75,   -51,   -51,   -51,   -51,
530     -51,   -51,   -51,    14,   -51,    14,   -51,   -51,   -51,   -51,
531     -51,   -51,    96,    96,   -51,   -51,    96,    23,   -51,   -51,
532      15,   117,   117,   -51,   -51,   -51,   -51,   -51,    14,    14,
533     -51,   147,   154,    96,    96,   -51,   -51,   -51,   -51,   -51,
534     -51,   -51,   -51
535};
536
537/* YYPGOTO[NTERM-NUM].  */
538static const yysigned_char yypgoto[] =
539{
540     -51,   -51,   -51,   -51,    29,   -51,   -51,   -51,   -51,     3,
541     -13,   -51,   -45,   -20,   -50,   -51,   -51,   -19,   -51,   -51
542};
543
544/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
545   positive, shift that token.  If negative, reduce the rule which
546   number is the opposite.  If zero, do what YYDEFACT says.
547   If YYTABLE_NINF, syntax error.  */
548#define YYTABLE_NINF -21
549static const yysigned_char yytable[] =
550{
551      46,     3,    -3,     4,    20,    10,    64,    61,    62,    10,
552      -9,    49,    51,    12,     4,    58,     5,    14,   -19,    52,
553      53,    -9,    57,    80,    82,    15,    16,     5,    18,   -19,
554      59,    70,    60,    48,    50,    13,    63,     0,    65,    66,
555      67,    58,    58,    68,    69,     0,     0,     0,    71,    72,
556       0,     0,     0,    79,    81,    73,    74,    21,    22,    23,
557      24,    25,    26,    27,    28,    29,    30,     0,     0,    43,
558      44,    45,     0,     0,     0,     0,    32,    33,    21,    22,
559      23,    24,    25,    26,    27,    28,    29,    30,     0,     5,
560       0,     0,     0,    54,    55,     0,     0,    32,    33,    21,
561      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
562     -20,   -20,   -20,   -20,   -20,   -20,   -20,     0,    32,    33,
563      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
564       0,     5,     0,     0,     0,     0,     0,     0,     0,    32,
565      33,    21,    22,    23,    24,    25,    26,    27,    28,    29,
566       0,     0,    47,     0,     0,     0,     0,     0,     0,     0,
567      32,    33,    65,    75,    67,    76,     0,    68,    69,    65,
568      77,    67,     0,    78,    68,    69
569};
570
571static const yysigned_char yycheck[] =
572{
573      20,     0,     0,     1,    17,     2,    56,    52,    53,     6,
574       8,    30,    31,    16,     1,    35,    14,     8,    16,    32,
575      33,     8,    35,    73,    74,     8,    16,    14,    14,    16,
576      43,    16,    45,    30,    31,     6,    56,    -1,    15,    16,
577      17,    61,    62,    20,    21,    -1,    -1,    -1,    61,    62,
578      -1,    -1,    -1,    73,    74,    68,    69,     3,     4,     5,
579       6,     7,     8,     9,    10,    11,    12,    -1,    -1,    15,
580      16,    17,    -1,    -1,    -1,    -1,    22,    23,     3,     4,
581       5,     6,     7,     8,     9,    10,    11,    12,    -1,    14,
582      -1,    -1,    -1,    18,    19,    -1,    -1,    22,    23,     3,
583       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
584      15,    16,    17,    18,    19,    20,    21,    -1,    22,    23,
585       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
586      -1,    14,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    22,
587      23,     3,     4,     5,     6,     7,     8,     9,    10,    11,
588      -1,    -1,    14,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
589      22,    23,    15,    16,    17,    18,    -1,    20,    21,    15,
590      16,    17,    -1,    19,    20,    21
591};
592
593/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
594   symbol of state STATE-NUM.  */
595static const unsigned char yystos[] =
596{
597       0,    25,    26,     0,     1,    14,    27,    28,    29,    30,
598      33,    34,    16,    28,     8,     8,    16,    31,    14,    32,
599      34,     3,     4,     5,     6,     7,     8,     9,    10,    11,
600      12,    13,    22,    23,    35,    36,    37,    38,    39,    40,
601      41,    42,    43,    15,    16,    17,    37,    14,    33,    41,
602      33,    41,    34,    34,    18,    19,    33,    34,    37,    34,
603      34,    36,    36,    37,    38,    15,    16,    17,    20,    21,
604      16,    34,    34,    34,    34,    16,    18,    16,    19,    37,
605      38,    37,    38
606};
607
608#define yyerrok         (yyerrstatus = 0)
609#define yyclearin       (yychar = YYEMPTY)
610#define YYEMPTY         (-2)
611#define YYEOF           0
612
613#define YYACCEPT        goto yyacceptlab
614#define YYABORT         goto yyabortlab
615#define YYERROR         goto yyerrorlab
616
617
618/* Like YYERROR except do call yyerror.  This remains here temporarily
619   to ease the transition to the new meaning of YYERROR, for GCC.
620   Once GCC version 2 has supplanted version 1, this can go.  */
621
622#define YYFAIL          goto yyerrlab
623
624#define YYRECOVERING()  (!!yyerrstatus)
625
626#define YYBACKUP(Token, Value)                                  \
627do                                                              \
628  if (yychar == YYEMPTY && yylen == 1)                          \
629    {                                                           \
630      yychar = (Token);                                         \
631      yylval = (Value);                                         \
632      yytoken = YYTRANSLATE (yychar);                           \
633      YYPOPSTACK;                                               \
634      goto yybackup;                                            \
635    }                                                           \
636  else                                                          \
637    {                                                           \
638      yyerror (YY_("syntax error: cannot back up")); \
639      YYERROR;                                                  \
640    }                                                           \
641while (0)
642
643
644#define YYTERROR        1
645#define YYERRCODE       256
646
647
648/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
649   If N is 0, then set CURRENT to the empty location which ends
650   the previous symbol: RHS[0] (always defined).  */
651
652#define YYRHSLOC(Rhs, K) ((Rhs)[K])
653#ifndef YYLLOC_DEFAULT
654# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
655    do                                                                  \
656      if (N)                                                            \
657        {                                                               \
658          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
659          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
660          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
661          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
662        }                                                               \
663      else                                                              \
664        {                                                               \
665          (Current).first_line   = (Current).last_line   =              \
666            YYRHSLOC (Rhs, 0).last_line;                                \
667          (Current).first_column = (Current).last_column =              \
668            YYRHSLOC (Rhs, 0).last_column;                              \
669        }                                                               \
670    while (0)
671#endif
672
673
674/* YY_LOCATION_PRINT -- Print the location on the stream.
675   This macro was not mandated originally: define only if we know
676   we won't break user code: when these are the locations we know.  */
677
678#ifndef YY_LOCATION_PRINT
679# if YYLTYPE_IS_TRIVIAL
680#  define YY_LOCATION_PRINT(File, Loc)                  \
681     fprintf (File, "%d.%d-%d.%d",                      \
682              (Loc).first_line, (Loc).first_column,     \
683              (Loc).last_line,  (Loc).last_column)
684# else
685#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
686# endif
687#endif
688
689
690/* YYLEX -- calling `yylex' with the right arguments.  */
691
692#ifdef YYLEX_PARAM
693# define YYLEX yylex (YYLEX_PARAM)
694#else
695# define YYLEX yylex ()
696#endif
697
698/* Enable debugging if requested.  */
699#if YYDEBUG
700
701# ifndef YYFPRINTF
702#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
703#  define YYFPRINTF fprintf
704# endif
705
706# define YYDPRINTF(Args)                        \
707do {                                            \
708  if (yydebug)                                  \
709    YYFPRINTF Args;                             \
710} while (0)
711
712# define YY_SYMBOL_PRINT(Title, Type, Value, Location)          \
713do {                                                            \
714  if (yydebug)                                                  \
715    {                                                           \
716      YYFPRINTF (stderr, "%s ", Title);                         \
717      yysymprint (stderr,                                       \
718                  Type, Value); \
719      YYFPRINTF (stderr, "\n");                                 \
720    }                                                           \
721} while (0)
722
723/*------------------------------------------------------------------.
724| yy_stack_print -- Print the state stack from its BOTTOM up to its |
725| TOP (included).                                                   |
726`------------------------------------------------------------------*/
727
728#if defined (__STDC__) || defined (__cplusplus)
729static void
730yy_stack_print (short int *bottom, short int *top)
731#else
732static void
733yy_stack_print (bottom, top)
734    short int *bottom;
735    short int *top;
736#endif
737{
738  YYFPRINTF (stderr, "Stack now");
739  for (/* Nothing. */; bottom <= top; ++bottom)
740    YYFPRINTF (stderr, " %d", *bottom);
741  YYFPRINTF (stderr, "\n");
742}
743
744# define YY_STACK_PRINT(Bottom, Top)                            \
745do {                                                            \
746  if (yydebug)                                                  \
747    yy_stack_print ((Bottom), (Top));                           \
748} while (0)
749
750
751/*------------------------------------------------.
752| Report that the YYRULE is going to be reduced.  |
753`------------------------------------------------*/
754
755#if defined (__STDC__) || defined (__cplusplus)
756static void
757yy_reduce_print (int yyrule)
758#else
759static void
760yy_reduce_print (yyrule)
761    int yyrule;
762#endif
763{
764  int yyi;
765  unsigned long int yylno = yyrline[yyrule];
766  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
767             yyrule - 1, yylno);
768  /* Print the symbols being reduced, and their result.  */
769  for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
770    YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
771  YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
772}
773
774# define YY_REDUCE_PRINT(Rule)          \
775do {                                    \
776  if (yydebug)                          \
777    yy_reduce_print (Rule);             \
778} while (0)
779
780/* Nonzero means print parse trace.  It is left uninitialized so that
781   multiple parsers can coexist.  */
782int yydebug;
783#else /* !YYDEBUG */
784# define YYDPRINTF(Args)
785# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
786# define YY_STACK_PRINT(Bottom, Top)
787# define YY_REDUCE_PRINT(Rule)
788#endif /* !YYDEBUG */
789
790
791/* YYINITDEPTH -- initial size of the parser's stacks.  */
792#ifndef YYINITDEPTH
793# define YYINITDEPTH 200
794#endif
795
796/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
797   if the built-in stack extension method is used).
798
799   Do not make this value too large; the results are undefined if
800   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
801   evaluated with infinite-precision integer arithmetic.  */
802
803#ifndef YYMAXDEPTH
804# define YYMAXDEPTH 10000
805#endif
806
807
808
809#if YYERROR_VERBOSE
810
811# ifndef yystrlen
812#  if defined (__GLIBC__) && defined (_STRING_H)
813#   define yystrlen strlen
814#  else
815/* Return the length of YYSTR.  */
816static YYSIZE_T
817#   if defined (__STDC__) || defined (__cplusplus)
818yystrlen (const char *yystr)
819#   else
820yystrlen (yystr)
821     const char *yystr;
822#   endif
823{
824  const char *yys = yystr;
825
826  while (*yys++ != '\0')
827    continue;
828
829  return yys - yystr - 1;
830}
831#  endif
832# endif
833
834# ifndef yystpcpy
835#  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
836#   define yystpcpy stpcpy
837#  else
838/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
839   YYDEST.  */
840static char *
841#   if defined (__STDC__) || defined (__cplusplus)
842yystpcpy (char *yydest, const char *yysrc)
843#   else
844yystpcpy (yydest, yysrc)
845     char *yydest;
846     const char *yysrc;
847#   endif
848{
849  char *yyd = yydest;
850  const char *yys = yysrc;
851
852  while ((*yyd++ = *yys++) != '\0')
853    continue;
854
855  return yyd - 1;
856}
857#  endif
858# endif
859
860# ifndef yytnamerr
861/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
862   quotes and backslashes, so that it's suitable for yyerror.  The
863   heuristic is that double-quoting is unnecessary unless the string
864   contains an apostrophe, a comma, or backslash (other than
865   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
866   null, do not copy; instead, return the length of what the result
867   would have been.  */
868static YYSIZE_T
869yytnamerr (char *yyres, const char *yystr)
870{
871  if (*yystr == '"')
872    {
873      size_t yyn = 0;
874      char const *yyp = yystr;
875
876      for (;;)
877        switch (*++yyp)
878          {
879          case '\'':
880          case ',':
881            goto do_not_strip_quotes;
882
883          case '\\':
884            if (*++yyp != '\\')
885              goto do_not_strip_quotes;
886            /* Fall through.  */
887          default:
888            if (yyres)
889              yyres[yyn] = *yyp;
890            yyn++;
891            break;
892
893          case '"':
894            if (yyres)
895              yyres[yyn] = '\0';
896            return yyn;
897          }
898    do_not_strip_quotes: ;
899    }
900
901  if (! yyres)
902    return yystrlen (yystr);
903
904  return yystpcpy (yyres, yystr) - yyres;
905}
906# endif
907
908#endif /* YYERROR_VERBOSE */
909
910
911
912#if YYDEBUG
913/*--------------------------------.
914| Print this symbol on YYOUTPUT.  |
915`--------------------------------*/
916
917#if defined (__STDC__) || defined (__cplusplus)
918static void
919yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
920#else
921static void
922yysymprint (yyoutput, yytype, yyvaluep)
923    FILE *yyoutput;
924    int yytype;
925    YYSTYPE *yyvaluep;
926#endif
927{
928  /* Pacify ``unused variable'' warnings.  */
929  (void) yyvaluep;
930
931  if (yytype < YYNTOKENS)
932    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
933  else
934    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
935
936
937# ifdef YYPRINT
938  if (yytype < YYNTOKENS)
939    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
940# endif
941  switch (yytype)
942    {
943      default:
944        break;
945    }
946  YYFPRINTF (yyoutput, ")");
947}
948
949#endif /* ! YYDEBUG */
950/*-----------------------------------------------.
951| Release the memory associated to this symbol.  |
952`-----------------------------------------------*/
953
954#if defined (__STDC__) || defined (__cplusplus)
955static void
956yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
957#else
958static void
959yydestruct (yymsg, yytype, yyvaluep)
960    const char *yymsg;
961    int yytype;
962    YYSTYPE *yyvaluep;
963#endif
964{
965  /* Pacify ``unused variable'' warnings.  */
966  (void) yyvaluep;
967
968  if (!yymsg)
969    yymsg = "Deleting";
970  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
971
972  switch (yytype)
973    {
974
975      default:
976        break;
977    }
978}
979
980
981/* Prevent warnings from -Wmissing-prototypes.  */
982
983#ifdef YYPARSE_PARAM
984# if defined (__STDC__) || defined (__cplusplus)
985int yyparse (void *YYPARSE_PARAM);
986# else
987int yyparse ();
988# endif
989#else /* ! YYPARSE_PARAM */
990#if defined (__STDC__) || defined (__cplusplus)
991int yyparse (void);
992#else
993int yyparse ();
994#endif
995#endif /* ! YYPARSE_PARAM */
996
997
998
999/* The look-ahead symbol.  */
1000int yychar;
1001
1002/* The semantic value of the look-ahead symbol.  */
1003YYSTYPE yylval;
1004
1005/* Number of syntax errors so far.  */
1006int yynerrs;
1007
1008
1009
1010/*----------.
1011| yyparse.  |
1012`----------*/
1013
1014#ifdef YYPARSE_PARAM
1015# if defined (__STDC__) || defined (__cplusplus)
1016int yyparse (void *YYPARSE_PARAM)
1017# else
1018int yyparse (YYPARSE_PARAM)
1019  void *YYPARSE_PARAM;
1020# endif
1021#else /* ! YYPARSE_PARAM */
1022#if defined (__STDC__) || defined (__cplusplus)
1023int
1024yyparse (void)
1025#else
1026int
1027yyparse ()
1028    ;
1029#endif
1030#endif
1031{
1032 
1033  int yystate;
1034  int yyn;
1035  int yyresult;
1036  /* Number of tokens to shift before error messages enabled.  */
1037  int yyerrstatus;
1038  /* Look-ahead token as an internal (translated) token number.  */
1039  int yytoken = 0;
1040
1041  /* Three stacks and their tools:
1042     `yyss': related to states,
1043     `yyvs': related to semantic values,
1044     `yyls': related to locations.
1045
1046     Refer to the stacks thru separate pointers, to allow yyoverflow
1047     to reallocate them elsewhere.  */
1048
1049  /* The state stack.  */
1050  short int yyssa[YYINITDEPTH];
1051  short int *yyss = yyssa;
1052  short int *yyssp;
1053
1054  /* The semantic value stack.  */
1055  YYSTYPE yyvsa[YYINITDEPTH];
1056  YYSTYPE *yyvs = yyvsa;
1057  YYSTYPE *yyvsp;
1058
1059
1060
1061#define YYPOPSTACK   (yyvsp--, yyssp--)
1062
1063  YYSIZE_T yystacksize = YYINITDEPTH;
1064
1065  /* The variables used to return semantic value and location from the
1066     action routines.  */
1067  YYSTYPE yyval;
1068
1069
1070  /* When reducing, the number of symbols on the RHS of the reduced
1071     rule.  */
1072  int yylen;
1073
1074  YYDPRINTF ((stderr, "Starting parse\n"));
1075
1076  yystate = 0;
1077  yyerrstatus = 0;
1078  yynerrs = 0;
1079  yychar = YYEMPTY;             /* Cause a token to be read.  */
1080
1081  /* Initialize stack pointers.
1082     Waste one element of value and location stack
1083     so that they stay on the same level as the state stack.
1084     The wasted elements are never initialized.  */
1085
1086  yyssp = yyss;
1087  yyvsp = yyvs;
1088
1089  goto yysetstate;
1090
1091/*------------------------------------------------------------.
1092| yynewstate -- Push a new state, which is found in yystate.  |
1093`------------------------------------------------------------*/
1094 yynewstate:
1095  /* In all cases, when you get here, the value and location stacks
1096     have just been pushed. so pushing a state here evens the stacks.
1097     */
1098  yyssp++;
1099
1100 yysetstate:
1101  *yyssp = yystate;
1102
1103  if (yyss + yystacksize - 1 <= yyssp)
1104    {
1105      /* Get the current used size of the three stacks, in elements.  */
1106      YYSIZE_T yysize = yyssp - yyss + 1;
1107
1108#ifdef yyoverflow
1109      {
1110        /* Give user a chance to reallocate the stack. Use copies of
1111           these so that the &'s don't force the real ones into
1112           memory.  */
1113        YYSTYPE *yyvs1 = yyvs;
1114        short int *yyss1 = yyss;
1115
1116
1117        /* Each stack pointer address is followed by the size of the
1118           data in use in that stack, in bytes.  This used to be a
1119           conditional around just the two extra args, but that might
1120           be undefined if yyoverflow is a macro.  */
1121        yyoverflow (YY_("memory exhausted"),
1122                    &yyss1, yysize * sizeof (*yyssp),
1123                    &yyvs1, yysize * sizeof (*yyvsp),
1124
1125                    &yystacksize);
1126
1127        yyss = yyss1;
1128        yyvs = yyvs1;
1129      }
1130#else /* no yyoverflow */
1131# ifndef YYSTACK_RELOCATE
1132      goto yyexhaustedlab;
1133# else
1134      /* Extend the stack our own way.  */
1135      if (YYMAXDEPTH <= yystacksize)
1136        goto yyexhaustedlab;
1137      yystacksize *= 2;
1138      if (YYMAXDEPTH < yystacksize)
1139        yystacksize = YYMAXDEPTH;
1140
1141      {
1142        short int *yyss1 = yyss;
1143        union yyalloc *yyptr =
1144          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1145        if (! yyptr)
1146          goto yyexhaustedlab;
1147        YYSTACK_RELOCATE (yyss);
1148        YYSTACK_RELOCATE (yyvs);
1149
1150#  undef YYSTACK_RELOCATE
1151        if (yyss1 != yyssa)
1152          YYSTACK_FREE (yyss1);
1153      }
1154# endif
1155#endif /* no yyoverflow */
1156
1157      yyssp = yyss + yysize - 1;
1158      yyvsp = yyvs + yysize - 1;
1159
1160
1161      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1162                  (unsigned long int) yystacksize));
1163
1164      if (yyss + yystacksize - 1 <= yyssp)
1165        YYABORT;
1166    }
1167
1168  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1169
1170  goto yybackup;
1171
1172/*-----------.
1173| yybackup.  |
1174`-----------*/
1175yybackup:
1176
1177/* Do appropriate processing given the current state.  */
1178/* Read a look-ahead token if we need one and don't already have one.  */
1179/* yyresume: */
1180
1181  /* First try to decide what to do without reference to look-ahead token.  */
1182
1183  yyn = yypact[yystate];
1184  if (yyn == YYPACT_NINF)
1185    goto yydefault;
1186
1187  /* Not known => get a look-ahead token if don't already have one.  */
1188
1189  /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
1190  if (yychar == YYEMPTY)
1191    {
1192      YYDPRINTF ((stderr, "Reading a token: "));
1193      yychar = YYLEX;
1194    }
1195
1196  if (yychar <= YYEOF)
1197    {
1198      yychar = yytoken = YYEOF;
1199      YYDPRINTF ((stderr, "Now at end of input.\n"));
1200    }
1201  else
1202    {
1203      yytoken = YYTRANSLATE (yychar);
1204      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1205    }
1206
1207  /* If the proper action on seeing token YYTOKEN is to reduce or to
1208     detect an error, take that action.  */
1209  yyn += yytoken;
1210  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1211    goto yydefault;
1212  yyn = yytable[yyn];
1213  if (yyn <= 0)
1214    {
1215      if (yyn == 0 || yyn == YYTABLE_NINF)
1216        goto yyerrlab;
1217      yyn = -yyn;
1218      goto yyreduce;
1219    }
1220
1221  if (yyn == YYFINAL)
1222    YYACCEPT;
1223
1224  /* Shift the look-ahead token.  */
1225  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1226
1227  /* Discard the token being shifted unless it is eof.  */
1228  if (yychar != YYEOF)
1229    yychar = YYEMPTY;
1230
1231  *++yyvsp = yylval;
1232
1233
1234  /* Count tokens shifted since error; after three, turn off error
1235     status.  */
1236  if (yyerrstatus)
1237    yyerrstatus--;
1238
1239  yystate = yyn;
1240  goto yynewstate;
1241
1242
1243/*-----------------------------------------------------------.
1244| yydefault -- do the default action for the current state.  |
1245`-----------------------------------------------------------*/
1246yydefault:
1247  yyn = yydefact[yystate];
1248  if (yyn == 0)
1249    goto yyerrlab;
1250  goto yyreduce;
1251
1252
1253/*-----------------------------.
1254| yyreduce -- Do a reduction.  |
1255`-----------------------------*/
1256yyreduce:
1257  /* yyn is the number of a rule to reduce with.  */
1258  yylen = yyr2[yyn];
1259
1260  /* If YYLEN is nonzero, implement the default value of the action:
1261     `$$ = $1'.
1262
1263     Otherwise, the following line sets YYVAL to garbage.
1264     This behavior is undocumented and Bison
1265     users should not rely upon it.  Assigning to YYVAL
1266     unconditionally makes the parser a bit smaller, and it avoids a
1267     GCC warning that YYVAL may be used uninitialized.  */
1268  yyval = yyvsp[1-yylen];
1269
1270
1271  YY_REDUCE_PRINT (yyn);
1272  switch (yyn)
1273    {
1274        case 2:
1275#line 85 "parser.y"
1276    {
1277#ifdef MYERROR_VERBOSE
1278        /* HACK-O-RAMA */ yystatep = &yystate; yychar1p = &yychar1;
1279#endif
1280                }
1281    break;
1282
1283  case 8:
1284#line 98 "parser.y"
1285    { mywarn(MYERROR, "Indented rules are Right Out."); YYERROR; }
1286    break;
1287
1288  case 11:
1289#line 105 "parser.y"
1290    { defline = yylineno; }
1291    break;
1292
1293  case 12:
1294#line 105 "parser.y"
1295    {
1296                struct rule *r;
1297
1298                r = findrule((yyvsp[-3].string));
1299
1300                if ((yyvsp[-1].retval) == 0 || r->name == NULL || r->rule == NULL) {    /* = */
1301                        if ((yyvsp[-1].retval)) {
1302                                mywarn(MYERROR, "Rule %s does not yet exist; treating /= as =", (yyvsp[-3].string));
1303                        }
1304                        if (r->name && strcmp(r->name, (yyvsp[-3].string)))
1305                                if (r->rule)
1306                                        mywarn(MYERROR, "Rule %s previously defined as %s on line %d",
1307                                                (yyvsp[-3].string), r->name, r->line);
1308                                else
1309                                        mywarn(MYWARNING, "rule %s previously referred to as %s",
1310                                                (yyvsp[-3].string), r->name);
1311                        if (r->rule)
1312                                mywarn(MYERROR, "Rule %s was already defined on line %d of %s", (yyvsp[-3].string),
1313               r->line, (r->file? r->file : "stdin"));
1314                        else {
1315                                r->name = (yyvsp[-3].string);
1316                                r->line = defline;
1317        r->file = input_file;
1318                                r->rule = (yyvsp[0].object);
1319                                if (r->next != rules) {
1320                                        /* unlink r from where it is and move to the end */
1321                                        r->prev->next = r->next;
1322                                        r->next->prev = r->prev;
1323                                        if (rules == r)
1324                                                rules = r->next;
1325                                        r->prev = rules->prev;
1326                                        rules->prev = r;
1327                                        r->prev->next = r;
1328                                        r->next = rules;
1329                                }
1330                        }
1331                } else {        /* =/ */
1332                        object *tmp;
1333
1334                        tmp = newobj(T_ALTERNATION);
1335                        tmp->u.alternation.left = r->rule;
1336                        tmp->u.alternation.right = (yyvsp[0].object);
1337                        r->rule = tmp;
1338                }
1339                }
1340    break;
1341
1342  case 13:
1343#line 152 "parser.y"
1344    { (yyval.retval) = 1; }
1345    break;
1346
1347  case 14:
1348#line 153 "parser.y"
1349    { (yyval.retval) = 0; }
1350    break;
1351
1352  case 15:
1353#line 154 "parser.y"
1354    { mywarn(MYERROR, "Empty rule"); YYERROR; /* XXX this CRLF may be the one required to recover from the error, but we've already used it... */}
1355    break;
1356
1357  case 16:
1358#line 155 "parser.y"
1359    { mywarn(MYERROR, "Got definitions, expecting '=' or '=/'"); YYERROR; }
1360    break;
1361
1362  case 17:
1363#line 156 "parser.y"
1364    { mywarn(MYERROR, "Got EOL, expecting '=' or '=/'"); YYERROR; /* XXX this CRLF may be the one required to recover from the error, but we've already used it... */}
1365    break;
1366
1367  case 21:
1368#line 167 "parser.y"
1369    { (yyval.object) = (yyvsp[-2].object); }
1370    break;
1371
1372  case 22:
1373#line 168 "parser.y"
1374    { mywarn(MYERROR, "Extra ')'?  Missing '('?"); YYERROR; }
1375    break;
1376
1377  case 23:
1378#line 169 "parser.y"
1379    { mywarn(MYERROR, "Extra ']'?  Missing '['?"); YYERROR; }
1380    break;
1381
1382  case 26:
1383#line 175 "parser.y"
1384    {
1385                /* concatenation */
1386                object *o = (yyvsp[-2].object);
1387
1388                (yyval.object) = (yyvsp[-2].object);
1389                if (o->type == T_ALTERNATION)
1390                        o = o->u.alternation.right;
1391                while (o->next) /* n**2, do this better */
1392                        o = o->next;
1393                o->next = (yyvsp[0].object);
1394                }
1395    break;
1396
1397  case 27:
1398#line 186 "parser.y"
1399    {
1400                /* concatenation */
1401                object *o = (yyvsp[-2].object);
1402
1403                (yyval.object) = (yyvsp[-2].object);
1404                if (o->type == T_ALTERNATION)
1405                        o = o->u.alternation.right;
1406                while (o->next) /* n**2, do this better */
1407                        o = o->next;
1408                o->next = (yyvsp[0].object);
1409                }
1410    break;
1411
1412  case 28:
1413#line 197 "parser.y"
1414    {
1415                (yyval.object) = newobj(T_ALTERNATION);
1416                (yyval.object)->u.alternation.left = (yyvsp[-4].object);
1417                (yyval.object)->u.alternation.right = (yyvsp[0].object);
1418                }
1419    break;
1420
1421  case 29:
1422#line 202 "parser.y"
1423    {
1424                if (!pipewarn) {
1425                        mywarn(MYERROR, "'/' is the alternation character in ABNF");
1426                        pipewarn = 1;
1427                }
1428                (yyval.object) = newobj(T_ALTERNATION);
1429                (yyval.object)->u.alternation.left = (yyvsp[-4].object);
1430                (yyval.object)->u.alternation.right = (yyvsp[0].object);
1431                }
1432    break;
1433
1434  case 30:
1435#line 211 "parser.y"
1436    {
1437                (yyval.object) = newobj(T_ALTERNATION);
1438                (yyval.object)->u.alternation.left = (yyvsp[-4].object);
1439                (yyval.object)->u.alternation.right = (yyvsp[0].object);
1440                }
1441    break;
1442
1443  case 31:
1444#line 216 "parser.y"
1445    {
1446                if (!pipewarn) {
1447                        mywarn(MYERROR, "'/' is the alternation character in ABNF");
1448                        pipewarn = 1;
1449                }
1450                (yyval.object) = newobj(T_ALTERNATION);
1451                (yyval.object)->u.alternation.left = (yyvsp[-4].object);
1452                (yyval.object)->u.alternation.right = (yyvsp[0].object);
1453                }
1454    break;
1455
1456  case 32:
1457#line 225 "parser.y"
1458    {
1459                object *o = (yyvsp[-1].object);
1460                mywarn(MYERROR, "Concatenation of adjacent elements is not allowed (missing whitespace?)");
1461                printf("; line %d ... trying to concatenate ", yylineno);
1462                if (o->type == T_ALTERNATION)
1463                        o = o->u.alternation.right;
1464                while (o->next) /* n**2, do this better */
1465                        o = o->next;
1466                printobj(o, 1);
1467                printf("\n; ... with ");
1468                printobj((yyvsp[0].object), 1);
1469                printf("\n");
1470                YYERROR;
1471                }
1472    break;
1473
1474  case 33:
1475#line 239 "parser.y"
1476    {
1477                mywarn(MYERROR, "Encountered definition while parsing rule (Indented rule?)");
1478                YYERROR;
1479                }
1480    break;
1481
1482  case 34:
1483#line 243 "parser.y"
1484    {
1485                mywarn(MYERROR, "Encountered definition while parsing rule (Indented rule?)");
1486                YYERROR;
1487                }
1488    break;
1489
1490  case 36:
1491#line 251 "parser.y"
1492    {
1493                                (yyval.object) = (yyvsp[0].object);
1494                                /* 5*10[foo] is really *10(foo), so leave
1495                                 * the zero that [ put there. */
1496                                if ((yyval.object)->u.e.repetition.lo != 0)
1497                                        (yyval.object)->u.e.repetition.lo = (yyvsp[-1].range).lo;
1498                                (yyval.object)->u.e.repetition.hi = (yyvsp[-1].range).hi;
1499                                if ((yyvsp[-1].range).hi < (yyvsp[-1].range).lo && (yyvsp[-1].range).hi != -1)
1500                                        mywarn(MYERROR, "Repeat range swapped, should be min*max");
1501                                if ((yyvsp[-1].range).hi == 0)
1502                                        mywarn(MYFYI, "absolute repeat count of zero means this element may not occur at all");
1503                                }
1504    break;
1505
1506  case 37:
1507#line 263 "parser.y"
1508    {
1509                                mywarn(MYERROR, "No whitespace allowed between repeat and element.");
1510                                YYERROR;
1511                                }
1512    break;
1513
1514  case 38:
1515#line 270 "parser.y"
1516    {
1517                                (yyval.object) = (yyvsp[0].object);
1518                                if ((yyval.object)->u.e.repetition.lo != 0)
1519                                        (yyval.object)->u.e.repetition.lo = (yyvsp[-1].range).lo;
1520                                (yyval.object)->u.e.repetition.hi = (yyvsp[-1].range).hi;
1521                                if ((yyvsp[-1].range).hi < (yyvsp[-1].range).lo && (yyvsp[-1].range).hi != -1)
1522                                        mywarn(MYERROR, "List range swapped, should be min*max");
1523                                if ((yyvsp[-1].range).hi == 0)
1524                                        mywarn(MYFYI, "absolute list count of zero means this element may not occur at all");
1525        if ((yyvsp[-1].range).lo != 0 && (yyvsp[-1].range).lo != 1 && (yyvsp[-1].range).lo != -1)
1526                                        mywarn(MYERROR, "List range min must be 0 or 1");
1527        if ((yyvsp[-1].range).hi != -1)
1528                                        mywarn(MYERROR, "List range max must be infinity");
1529        (yyval.object)->u.e.islist = 1;
1530                                }
1531    break;
1532
1533  case 39:
1534#line 285 "parser.y"
1535    {
1536                                mywarn(MYERROR, "No whitespace allowed between list and element.");
1537                                YYERROR;
1538                                }
1539    break;
1540
1541  case 46:
1542#line 303 "parser.y"
1543    {
1544                                (yyval.object) = newobj(T_RULE);
1545                                (yyval.object)->u.e.e.rule.name = (yyvsp[0].string);
1546                                (yyval.object)->u.e.e.rule.rule = findrule((yyvsp[0].string));
1547                                if (strcmp((yyvsp[0].string), (yyval.object)->u.e.e.rule.rule->name))
1548                                        mywarn(MYWARNING, "rule %s defined on line %d referred to as %s", (yyval.object)->u.e.e.rule.rule->name, (yyval.object)->u.e.e.rule.rule->line, (yyvsp[0].string));
1549                                }
1550    break;
1551
1552  case 49:
1553#line 312 "parser.y"
1554    {
1555                                char *p = (yyvsp[0].string);
1556                                if (*(yyvsp[0].string))
1557                                        p += strlen((yyvsp[0].string)) - 1;
1558                                if (*p == '\n' || *p == '\r') {
1559                                        mywarn(MYERROR, "unterminated quoted-string");
1560                                        YYERROR;
1561                                }
1562                                (yyval.object) = newobj(T_TERMSTR);
1563                                (yyval.object)->u.e.e.termstr.str = (yyvsp[0].string);
1564                                (yyval.object)->u.e.e.termstr.flags = 0;
1565                                }
1566    break;
1567
1568  case 50:
1569#line 324 "parser.y"
1570    {
1571                                (yyval.object) = newobj(T_TERMSTR);
1572                                (yyval.object)->u.e.e.termstr.str = (yyvsp[0].string);
1573                                (yyval.object)->u.e.e.termstr.flags = F_CASESENSITIVE;
1574                                }
1575    break;
1576
1577  case 51:
1578#line 329 "parser.y"
1579    {
1580                                (yyval.object) = newobj(T_TERMRANGE);
1581                                (yyval.object)->u.e.e.termrange.lo = (yyvsp[0].range).lo;
1582                                (yyval.object)->u.e.e.termrange.hi = (yyvsp[0].range).hi;
1583                                }
1584    break;
1585
1586  case 52:
1587#line 334 "parser.y"
1588    {
1589                                (yyval.object) = newobj(T_PROSE);
1590                                (yyval.object)->u.e.e.proseval = (yyvsp[0].string);
1591                                if (strcmp((yyvsp[0].string), "\"") == 0) {
1592                                        mywarn(MYFYI, "suggest DQUOTE or %%x22 instead of <\">.");
1593                                }
1594                                }
1595    break;
1596
1597  case 53:
1598#line 343 "parser.y"
1599    {
1600                                                (yyval.object) = newobj(T_GROUP);
1601                                                (yyval.object)->u.e.e.group = (yyvsp[-2].object);
1602                                                }
1603    break;
1604
1605  case 54:
1606#line 347 "parser.y"
1607    {
1608                mywarn(MYERROR, "Missing ')'?  Extra '('?");
1609                YYERROR;
1610                }
1611    break;
1612
1613  case 55:
1614#line 353 "parser.y"
1615    {
1616                                                (yyval.object) = newobj(T_GROUP);
1617                                                (yyval.object)->u.e.e.group = (yyvsp[-2].object);
1618                                                (yyval.object)->u.e.repetition.lo = 0;
1619                                                }
1620    break;
1621
1622  case 56:
1623#line 358 "parser.y"
1624    {
1625                mywarn(MYERROR, "Missing ']'?  Extra '['?");
1626                YYERROR;
1627                }
1628    break;
1629
1630
1631      default: break;
1632    }
1633
1634/* Line 1126 of yacc.c.  */
1635#line 1636 "y.tab.c"
1636
1637  yyvsp -= yylen;
1638  yyssp -= yylen;
1639
1640
1641  YY_STACK_PRINT (yyss, yyssp);
1642
1643  *++yyvsp = yyval;
1644
1645
1646  /* Now `shift' the result of the reduction.  Determine what state
1647     that goes to, based on the state we popped back to and the rule
1648     number reduced by.  */
1649
1650  yyn = yyr1[yyn];
1651
1652  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1653  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1654    yystate = yytable[yystate];
1655  else
1656    yystate = yydefgoto[yyn - YYNTOKENS];
1657
1658  goto yynewstate;
1659
1660
1661/*------------------------------------.
1662| yyerrlab -- here on detecting error |
1663`------------------------------------*/
1664yyerrlab:
1665  /* If not already recovering from an error, report this error.  */
1666  if (!yyerrstatus)
1667    {
1668      ++yynerrs;
1669#if YYERROR_VERBOSE
1670      yyn = yypact[yystate];
1671
1672      if (YYPACT_NINF < yyn && yyn < YYLAST)
1673        {
1674          int yytype = YYTRANSLATE (yychar);
1675          YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1676          YYSIZE_T yysize = yysize0;
1677          YYSIZE_T yysize1;
1678          int yysize_overflow = 0;
1679          char *yymsg = 0;
1680#         define YYERROR_VERBOSE_ARGS_MAXIMUM 5
1681          char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1682          int yyx;
1683
1684#if 0
1685          /* This is so xgettext sees the translatable formats that are
1686             constructed on the fly.  */
1687          YY_("syntax error, unexpected %s");
1688          YY_("syntax error, unexpected %s, expecting %s");
1689          YY_("syntax error, unexpected %s, expecting %s or %s");
1690          YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1691          YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1692#endif
1693          char *yyfmt;
1694          char const *yyf;
1695          static char const yyunexpected[] = "syntax error, unexpected %s";
1696          static char const yyexpecting[] = ", expecting %s";
1697          static char const yyor[] = " or %s";
1698          char yyformat[sizeof yyunexpected
1699                        + sizeof yyexpecting - 1
1700                        + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1701                           * (sizeof yyor - 1))];
1702          char const *yyprefix = yyexpecting;
1703
1704          /* Start YYX at -YYN if negative to avoid negative indexes in
1705             YYCHECK.  */
1706          int yyxbegin = yyn < 0 ? -yyn : 0;
1707
1708          /* Stay within bounds of both yycheck and yytname.  */
1709          int yychecklim = YYLAST - yyn;
1710          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1711          int yycount = 1;
1712
1713          yyarg[0] = yytname[yytype];
1714          yyfmt = yystpcpy (yyformat, yyunexpected);
1715
1716          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1717            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1718              {
1719                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1720                  {
1721                    yycount = 1;
1722                    yysize = yysize0;
1723                    yyformat[sizeof yyunexpected - 1] = '\0';
1724                    break;
1725                  }
1726                yyarg[yycount++] = yytname[yyx];
1727                yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1728                yysize_overflow |= yysize1 < yysize;
1729                yysize = yysize1;
1730                yyfmt = yystpcpy (yyfmt, yyprefix);
1731                yyprefix = yyor;
1732              }
1733
1734          yyf = YY_(yyformat);
1735          yysize1 = yysize + yystrlen (yyf);
1736          yysize_overflow |= yysize1 < yysize;
1737          yysize = yysize1;
1738
1739          if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)
1740            yymsg = (char *) YYSTACK_ALLOC (yysize);
1741          if (yymsg)
1742            {
1743              /* Avoid sprintf, as that infringes on the user's name space.
1744                 Don't have undefined behavior even if the translation
1745                 produced a string with the wrong number of "%s"s.  */
1746              char *yyp = yymsg;
1747              int yyi = 0;
1748              while ((*yyp = *yyf))
1749                {
1750                  if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1751                    {
1752                      yyp += yytnamerr (yyp, yyarg[yyi++]);
1753                      yyf += 2;
1754                    }
1755                  else
1756                    {
1757                      yyp++;
1758                      yyf++;
1759                    }
1760                }
1761              yyerror (yymsg);
1762              YYSTACK_FREE (yymsg);
1763            }
1764          else
1765            {
1766              yyerror (YY_("syntax error"));
1767              goto yyexhaustedlab;
1768            }
1769        }
1770      else
1771#endif /* YYERROR_VERBOSE */
1772        yyerror (YY_("syntax error"));
1773    }
1774
1775
1776
1777  if (yyerrstatus == 3)
1778    {
1779      /* If just tried and failed to reuse look-ahead token after an
1780         error, discard it.  */
1781
1782      if (yychar <= YYEOF)
1783        {
1784          /* Return failure if at end of input.  */
1785          if (yychar == YYEOF)
1786            YYABORT;
1787        }
1788      else
1789        {
1790          yydestruct ("Error: discarding", yytoken, &yylval);
1791          yychar = YYEMPTY;
1792        }
1793    }
1794
1795  /* Else will try to reuse look-ahead token after shifting the error
1796     token.  */
1797  goto yyerrlab1;
1798
1799
1800/*---------------------------------------------------.
1801| yyerrorlab -- error raised explicitly by YYERROR.  |
1802`---------------------------------------------------*/
1803yyerrorlab:
1804
1805  /* Pacify compilers like GCC when the user code never invokes
1806     YYERROR and the label yyerrorlab therefore never appears in user
1807     code.  */
1808  if (0)
1809     goto yyerrorlab;
1810
1811yyvsp -= yylen;
1812  yyssp -= yylen;
1813  yystate = *yyssp;
1814  goto yyerrlab1;
1815
1816
1817/*-------------------------------------------------------------.
1818| yyerrlab1 -- common code for both syntax error and YYERROR.  |
1819`-------------------------------------------------------------*/
1820yyerrlab1:
1821  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
1822
1823  for (;;)
1824    {
1825      yyn = yypact[yystate];
1826      if (yyn != YYPACT_NINF)
1827        {
1828          yyn += YYTERROR;
1829          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1830            {
1831              yyn = yytable[yyn];
1832              if (0 < yyn)
1833                break;
1834            }
1835        }
1836
1837      /* Pop the current state because it cannot handle the error token.  */
1838      if (yyssp == yyss)
1839        YYABORT;
1840
1841
1842      yydestruct ("Error: popping", yystos[yystate], yyvsp);
1843      YYPOPSTACK;
1844      yystate = *yyssp;
1845      YY_STACK_PRINT (yyss, yyssp);
1846    }
1847
1848  if (yyn == YYFINAL)
1849    YYACCEPT;
1850
1851  *++yyvsp = yylval;
1852
1853
1854  /* Shift the error token. */
1855  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1856
1857  yystate = yyn;
1858  goto yynewstate;
1859
1860
1861/*-------------------------------------.
1862| yyacceptlab -- YYACCEPT comes here.  |
1863`-------------------------------------*/
1864yyacceptlab:
1865  yyresult = 0;
1866  goto yyreturn;
1867
1868/*-----------------------------------.
1869| yyabortlab -- YYABORT comes here.  |
1870`-----------------------------------*/
1871yyabortlab:
1872  yyresult = 1;
1873  goto yyreturn;
1874
1875#ifndef yyoverflow
1876/*-------------------------------------------------.
1877| yyexhaustedlab -- memory exhaustion comes here.  |
1878`-------------------------------------------------*/
1879yyexhaustedlab:
1880  yyerror (YY_("memory exhausted"));
1881  yyresult = 2;
1882  /* Fall through.  */
1883#endif
1884
1885yyreturn:
1886  if (yychar != YYEOF && yychar != YYEMPTY)
1887     yydestruct ("Cleanup: discarding lookahead",
1888                 yytoken, &yylval);
1889  while (yyssp != yyss)
1890    {
1891      yydestruct ("Cleanup: popping",
1892                  yystos[*yyssp], yyvsp);
1893      YYPOPSTACK;
1894    }
1895#ifndef yyoverflow
1896  if (yyss != yyssa)
1897    YYSTACK_FREE (yyss);
1898#endif
1899  return yyresult;
1900}
1901
1902
1903#line 364 "parser.y"
1904
1905
1906void
1907mywarn(int level, const char *fmt, ...)
1908{
1909        va_list ap;
1910
1911        /* file name */
1912        fprintf(stderr, "%s(%d:%d): ", input_file, yylineno, yycolumn);
1913        switch (level) {
1914                case MYFYI: fprintf(stderr, "fyi: "); break;
1915                case MYWARNING: fprintf(stderr, "warning: "); break;
1916                case MYERROR: ++yyerrors; /* fall through */
1917                default: fprintf(stderr, "error: "); break;
1918        }
1919        va_start(ap, fmt);
1920        vfprintf(stderr, fmt, ap);
1921        fprintf(stderr, "\n");
1922}
1923
1924int
1925yyerror(char *s)
1926{
1927#ifdef MYERROR_VERBOSE
1928        mywarn(MYERROR, "state %d, token %s: %s", 
1929                *yystatep,
1930                (yychar1p && (*yychar1p >= 0 && *yychar1p <= (sizeof(yytname)/sizeof(yytname[0])))) ? yytname[*yychar1p] : "?",
1931                s);
1932#else
1933        mywarn(MYERROR, "%s\n", s);
1934#endif
1935        return 0;
1936}
1937
1938object *
1939newobj(int type)
1940{
1941        object *o;
1942
1943        o = calloc(sizeof(object), 1);
1944        if (o == NULL) {
1945                mywarn(MYERROR, "out of memory");
1946                exit(1);
1947        }
1948        o->type = type;
1949        o->next = NULL;
1950        switch (type) {
1951                case T_RULE:
1952                case T_GROUP:
1953                case T_TERMSTR:
1954                case T_TERMRANGE:
1955                case T_PROSE:
1956                        o->u.e.repetition.lo = 1;
1957                        o->u.e.repetition.hi = 1;
1958                        break;
1959        }
1960        return o;
1961}
1962
Note: See TracBrowser for help on using the repository browser.