root/trunk/pdns/pdns/backends/bind/bindparser.cc @ 495

Revision 495, 37.5 KB (checked in by ahu, 8 years ago)

make bind configuration parser drop dots in zone names to save complaints about out of zone data
make out-of-zone check more case insensitive
  • Property svn:eol-style set to native
  • Property svn:keywords set to author date id revision
Line 
1/* A Bison parser, made by GNU Bison 1.875d.  */
2
3/* Skeleton parser for Yacc-like parsing with Bison,
4   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 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., 59 Temple Place - Suite 330,
19   Boston, MA 02111-1307, USA.  */
20
21/* As a special exception, when this file is copied by Bison into a
22   Bison output file, you may use that output file without restriction.
23   This special exception was added by the Free Software Foundation
24   in version 1.24 of Bison.  */
25
26/* Written by Richard Stallman by simplifying the original so called
27   ``semantic'' parser.  */
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/* Skeleton name.  */
40#define YYSKELETON_NAME "yacc.c"
41
42/* Pure parsers.  */
43#define YYPURE 0
44
45/* Using locations.  */
46#define YYLSP_NEEDED 0
47
48
49
50/* Tokens.  */
51#ifndef YYTOKENTYPE
52# define YYTOKENTYPE
53   /* Put the tokens into the symbol table, so that GDB and other debuggers
54      know about them.  */
55   enum yytokentype {
56     AWORD = 258,
57     QUOTEDWORD = 259,
58     OBRACE = 260,
59     EBRACE = 261,
60     SEMICOLON = 262,
61     ZONETOK = 263,
62     FILETOK = 264,
63     OPTIONSTOK = 265,
64     DIRECTORYTOK = 266,
65     ACLTOK = 267,
66     LOGGINGTOK = 268,
67     CLASSTOK = 269,
68     TYPETOK = 270,
69     MASTERTOK = 271
70   };
71#endif
72#define AWORD 258
73#define QUOTEDWORD 259
74#define OBRACE 260
75#define EBRACE 261
76#define SEMICOLON 262
77#define ZONETOK 263
78#define FILETOK 264
79#define OPTIONSTOK 265
80#define DIRECTORYTOK 266
81#define ACLTOK 267
82#define LOGGINGTOK 268
83#define CLASSTOK 269
84#define TYPETOK 270
85#define MASTERTOK 271
86
87
88
89
90/* Copy the first part of user declarations.  */
91#line 1 "bindparser.yy"
92
93
94#include <stdio.h>
95#include <string.h>
96#include <stdlib.h>
97#include <string>
98#include <iostream>
99#include <utility>
100#include <errno.h>
101#include "misc.hh"
102#include "zoneparser.hh"
103#include "ahuexception.hh"
104using namespace std;
105#define YYDEBUG 1
106extern int yydebug;
107#include "bindparser.hh"
108
109#define YYSTYPE char *
110
111
112#ifndef WIN32
113extern "C" 
114{
115#endif // WIN32
116        int yyparse(void);
117        int yylex(void);
118        void yyrestart(FILE *);
119        int yywrap()
120        {
121                return 1;
122        }
123#ifndef WIN32
124}
125#endif // WIN32
126
127
128extern int yydebug;
129const char *bind_directory;
130extern int linenumber;
131static void yyerror(const char *str)
132{
133  extern char *current_filename;       
134  throw AhuException("Error in bind configuration '"+string(current_filename)+"' on line "+itoa(linenumber)+": "+str);
135}
136
137extern FILE *yyin;
138static BindParser *parent;
139BindDomainInfo s_di;
140
141void BindParser::parse(const string &fname)
142{       
143        yydebug=0;
144        yyin=fopen(fname.c_str(),"r");
145        yyrestart(yyin);
146        if(!yyin)
147                throw AhuException("Unable to open '"+fname+"': "+strerror(errno));
148
149        linenumber=1;
150        parent=this;
151        extern char *current_filename;
152        extern char *original_filename;
153
154        current_filename=original_filename=(char*)fname.c_str();
155
156        yyparse();
157
158//      cerr<<"Need to parse "<<d_zonedomains.size()<<" zone statements"<<endl;
159}
160
161void BindParser::setDirectory(const string &dir)
162{
163        d_dir=dir;
164        bind_directory=d_dir.c_str();
165}
166
167const string &BindParser::getDirectory()
168{
169        return d_dir;
170}
171
172const vector<BindDomainInfo>& BindParser::getDomains()
173{
174        return d_zonedomains;
175}
176
177void BindParser::setVerbose(bool verbose)
178{
179  d_verbose=verbose;
180}
181
182void BindParser::commit(BindDomainInfo DI)
183{
184  if(DI.filename[0]!='/')
185    DI.filename=d_dir+"/"+DI.filename;
186
187  if(d_verbose)
188    cerr<<"Domain "<<DI.name<<" lives in file '"<<DI.filename<<"'"<<endl;
189
190  d_zonedomains.push_back(DI);
191}
192
193
194
195/* Enabling traces.  */
196#ifndef YYDEBUG
197# define YYDEBUG 1
198#endif
199
200/* Enabling verbose error messages.  */
201#ifdef YYERROR_VERBOSE
202# undef YYERROR_VERBOSE
203# define YYERROR_VERBOSE 1
204#else
205# define YYERROR_VERBOSE 0
206#endif
207
208#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
209typedef int YYSTYPE;
210# define yystype YYSTYPE /* obsolescent; will be withdrawn */
211# define YYSTYPE_IS_DECLARED 1
212# define YYSTYPE_IS_TRIVIAL 1
213#endif
214
215
216
217/* Copy the second part of user declarations.  */
218
219
220/* Line 214 of yacc.c.  */
221#line 222 "bindparser.cc"
222
223#if ! defined (yyoverflow) || YYERROR_VERBOSE
224
225# ifndef YYFREE
226#  define YYFREE free
227# endif
228# ifndef YYMALLOC
229#  define YYMALLOC malloc
230# endif
231
232/* The parser invokes alloca or malloc; define the necessary symbols.  */
233
234# ifdef YYSTACK_USE_ALLOCA
235#  if YYSTACK_USE_ALLOCA
236#   define YYSTACK_ALLOC alloca
237#  endif
238# else
239#  if defined (alloca) || defined (_ALLOCA_H)
240#   define YYSTACK_ALLOC alloca
241#  else
242#   ifdef __GNUC__
243#    define YYSTACK_ALLOC __builtin_alloca
244#   endif
245#  endif
246# endif
247
248# ifdef YYSTACK_ALLOC
249   /* Pacify GCC's `empty if-body' warning. */
250#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
251# else
252#  if defined (__STDC__) || defined (__cplusplus)
253#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
254#   define YYSIZE_T size_t
255#  endif
256#  define YYSTACK_ALLOC YYMALLOC
257#  define YYSTACK_FREE YYFREE
258# endif
259#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
260
261
262#if (! defined (yyoverflow) \
263     && (! defined (__cplusplus) \
264         || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
265
266/* A type that is properly aligned for any stack member.  */
267union yyalloc
268{
269  short int yyss;
270  YYSTYPE yyvs;
271  };
272
273/* The size of the maximum gap between one aligned stack and the next.  */
274# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
275
276/* The size of an array large to enough to hold all stacks, each with
277   N elements.  */
278# define YYSTACK_BYTES(N) \
279     ((N) * (sizeof (short int) + sizeof (YYSTYPE))                     \
280      + YYSTACK_GAP_MAXIMUM)
281
282/* Copy COUNT objects from FROM to TO.  The source and destination do
283   not overlap.  */
284# ifndef YYCOPY
285#  if defined (__GNUC__) && 1 < __GNUC__
286#   define YYCOPY(To, From, Count) \
287      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
288#  else
289#   define YYCOPY(To, From, Count)              \
290      do                                        \
291        {                                       \
292          register YYSIZE_T yyi;                \
293          for (yyi = 0; yyi < (Count); yyi++)   \
294            (To)[yyi] = (From)[yyi];            \
295        }                                       \
296      while (0)
297#  endif
298# endif
299
300/* Relocate STACK from its old location to the new one.  The
301   local variables YYSIZE and YYSTACKSIZE give the old and new number of
302   elements in the stack, and YYPTR gives the new location of the
303   stack.  Advance YYPTR to a properly aligned location for the next
304   stack.  */
305# define YYSTACK_RELOCATE(Stack)                                        \
306    do                                                                  \
307      {                                                                 \
308        YYSIZE_T yynewbytes;                                            \
309        YYCOPY (&yyptr->Stack, Stack, yysize);                          \
310        Stack = &yyptr->Stack;                                          \
311        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
312        yyptr += yynewbytes / sizeof (*yyptr);                          \
313      }                                                                 \
314    while (0)
315
316#endif
317
318#if defined (__STDC__) || defined (__cplusplus)
319   typedef signed char yysigned_char;
320#else
321   typedef short int yysigned_char;
322#endif
323
324/* YYFINAL -- State number of the termination state. */
325#define YYFINAL  2
326/* YYLAST -- Last index in YYTABLE.  */
327#define YYLAST   59
328
329/* YYNTOKENS -- Number of terminals. */
330#define YYNTOKENS  17
331/* YYNNTS -- Number of nonterminals. */
332#define YYNNTS  25
333/* YYNRULES -- Number of rules. */
334#define YYNRULES  46
335/* YYNRULES -- Number of states. */
336#define YYNSTATES  73
337
338/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
339#define YYUNDEFTOK  2
340#define YYMAXUTOK   271
341
342#define YYTRANSLATE(YYX)                                                \
343  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
344
345/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
346static const unsigned char yytranslate[] =
347{
348       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
349       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
350       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
351       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
352       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
353       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
354       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
355       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
356       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
357       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
358       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
359       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
360       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
361       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
362       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
363       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
364       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
365       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
366       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
367       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
368       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
369       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
370       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
371       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
372       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
373       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
374       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
375      15,    16
376};
377
378#if YYDEBUG
379/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
380   YYRHS.  */
381static const unsigned char yyprhs[] =
382{
383       0,     0,     3,     4,     8,    10,    12,    14,    16,    17,
384      21,    23,    27,    32,    37,    42,    46,    50,    54,    55,
385      59,    61,    62,    66,    68,    70,    73,    74,    77,    79,
386      81,    83,    87,    91,    92,    96,    98,   100,   102,   104,
387     109,   110,   114,   116,   119,   122,   124
388};
389
390/* YYRHS -- A `-1'-separated list of the rules' RHS. */
391static const yysigned_char yyrhs[] =
392{
393      18,     0,    -1,    -1,    18,    19,     7,    -1,    21,    -1,
394      24,    -1,    22,    -1,    23,    -1,    -1,    20,    21,     7,
395      -1,    30,    -1,     8,    40,    33,    -1,     8,    40,     3,
396      33,    -1,    10,     5,    28,     6,    -1,    13,     5,    28,
397       6,    -1,    12,    40,    25,    -1,    12,    41,    25,    -1,
398       5,    26,     6,    -1,    -1,    27,     7,    26,    -1,     3,
399      -1,    -1,    23,     7,    28,    -1,    21,    -1,    29,    -1,
400      11,    40,    -1,    -1,    30,    31,    -1,     3,    -1,    32,
401      -1,    40,    -1,     5,    20,     6,    -1,     5,    34,     6,
402      -1,    -1,    34,    22,     7,    -1,    21,    -1,    38,    -1,
403      39,    -1,    35,    -1,    16,     5,    36,     6,    -1,    -1,
404      36,    37,     7,    -1,     3,    -1,     9,    40,    -1,    15,
405       3,    -1,     4,    -1,     3,    -1
406};
407
408/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
409static const unsigned char yyrline[] =
410{
411       0,   109,   109,   111,   114,   114,   114,   114,   117,   119,
412     123,   127,   135,   145,   147,   151,   151,   154,   157,   159,
413     163,   166,   168,   171,   171,   174,   181,   183,   186,   186,
414     186,   189,   193,   196,   198,   201,   201,   201,   201,   204,
415     207,   209,   212,   219,   227,   235,   241
416};
417#endif
418
419#if YYDEBUG || YYERROR_VERBOSE
420/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
421   First, the terminals, then, starting at YYNTOKENS, nonterminals. */
422static const char *const yytname[] =
423{
424  "$end", "error", "$undefined", "AWORD", "QUOTEDWORD", "OBRACE",
425  "EBRACE", "SEMICOLON", "ZONETOK", "FILETOK", "OPTIONSTOK",
426  "DIRECTORYTOK", "ACLTOK", "LOGGINGTOK", "CLASSTOK", "TYPETOK",
427  "MASTERTOK", "$accept", "root_commands", "root_command", "commands",
428  "command", "zone_command", "options_command", "acl_command", "acl_block",
429  "acls", "acl", "options_commands", "options_directory_command", "terms",
430  "term", "block", "zone_block", "zone_commands", "zone_masters_command",
431  "masters", "master", "zone_file_command", "zone_type_command",
432  "quotedname", "filename", 0
433};
434#endif
435
436# ifdef YYPRINT
437/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
438   token YYLEX-NUM.  */
439static const unsigned short int yytoknum[] =
440{
441       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
442     265,   266,   267,   268,   269,   270,   271
443};
444# endif
445
446/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
447static const unsigned char yyr1[] =
448{
449       0,    17,    18,    18,    19,    19,    19,    19,    20,    20,
450      21,    22,    22,    23,    23,    24,    24,    25,    26,    26,
451      27,    28,    28,    23,    23,    29,    30,    30,    31,    31,
452      31,    32,    33,    34,    34,    22,    22,    22,    22,    35,
453      36,    36,    37,    38,    39,    40,    41
454};
455
456/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
457static const unsigned char yyr2[] =
458{
459       0,     2,     0,     3,     1,     1,     1,     1,     0,     3,
460       1,     3,     4,     4,     4,     3,     3,     3,     0,     3,
461       1,     0,     3,     1,     1,     2,     0,     2,     1,     1,
462       1,     3,     3,     0,     3,     1,     1,     1,     1,     4,
463       0,     3,     1,     2,     2,     1,     1
464};
465
466/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
467   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
468   means the default is an error.  */
469static const unsigned char yydefact[] =
470{
471       2,    26,     1,     0,     0,     0,     0,     0,     0,     0,
472       0,     0,     4,     6,     7,     5,    24,    10,    38,    36,
473      37,    45,     0,    43,    26,    25,    46,     0,     0,    26,
474      44,    40,     3,    28,     8,    27,    29,    30,     0,    33,
475      11,    23,     0,     0,    18,    15,    16,     0,     0,    26,
476      12,    26,    26,    13,    20,     0,     0,    14,    42,    39,
477       0,    31,     0,    32,    35,     0,    22,    17,    18,    41,
478       9,    34,    19
479};
480
481/* YYDEFGOTO[NTERM-NUM]. */
482static const yysigned_char yydefgoto[] =
483{
484      -1,     1,    11,    49,    41,    13,    42,    15,    45,    55,
485      56,    43,    16,    17,    35,    36,    40,    51,    18,    48,
486      60,    19,    20,    22,    28
487};
488
489/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
490   STATE-NUM.  */
491#define YYPACT_NINF -29
492static const yysigned_char yypact[] =
493{
494     -29,     2,   -29,    12,    12,    18,    12,     1,    24,    17,
495      32,    34,   -29,   -29,   -29,   -29,   -29,     4,   -29,   -29,
496     -29,   -29,    33,   -29,    20,   -29,   -29,    35,    35,    20,
497     -29,   -29,   -29,   -29,   -29,   -29,   -29,   -29,    37,   -29,
498     -29,   -29,    36,    38,    42,   -29,   -29,    40,     0,    41,
499     -29,    19,    20,   -29,   -29,    43,    44,   -29,   -29,   -29,
500      45,   -29,    46,   -29,   -29,    47,   -29,   -29,    42,   -29,
501     -29,   -29,   -29
502};
503
504/* YYPGOTO[NTERM-NUM].  */
505static const yysigned_char yypgoto[] =
506{
507     -29,   -29,   -29,   -29,    -1,   -12,    54,   -29,    28,   -11,
508     -29,   -28,   -29,   -29,   -29,   -29,    21,   -29,   -29,   -29,
509     -29,   -29,   -29,    15,   -29
510};
511
512/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
513   positive, shift that token.  If negative, reduce the rule which
514   number is the opposite.  If zero, do what YYDEFACT says.
515   If YYTABLE_NINF, syntax error.  */
516#define YYTABLE_NINF -22
517static const yysigned_char yytable[] =
518{
519      12,    47,     2,    58,    26,    21,    59,    33,    21,    34,
520       3,     4,     5,     6,     7,     8,    21,     9,    10,    23,
521      30,    25,    27,    24,    66,    63,   -21,     3,     4,    29,
522       5,     6,    37,     8,     9,    10,    38,    31,    39,    65,
523      44,    32,    39,    52,    53,    54,    57,    61,    62,    67,
524      64,    68,    69,    70,    71,    14,    46,    72,     0,    50
525};
526
527static const yysigned_char yycheck[] =
528{
529       1,    29,     0,     3,     3,     4,     6,     3,     4,     5,
530       8,     9,    10,    11,    12,    13,     4,    15,    16,     4,
531       3,     6,     7,     5,    52,     6,     6,     8,     9,     5,
532      10,    11,    17,    13,    15,    16,     3,     5,     5,    51,
533       5,     7,     5,     7,     6,     3,     6,     6,    49,     6,
534      51,     7,     7,     7,     7,     1,    28,    68,    -1,    38
535};
536
537/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
538   symbol of state STATE-NUM.  */
539static const unsigned char yystos[] =
540{
541       0,    18,     0,     8,     9,    10,    11,    12,    13,    15,
542      16,    19,    21,    22,    23,    24,    29,    30,    35,    38,
543      39,     4,    40,    40,     5,    40,     3,    40,    41,     5,
544       3,     5,     7,     3,     5,    31,    32,    40,     3,     5,
545      33,    21,    23,    28,     5,    25,    25,    28,    36,    20,
546      33,    34,     7,     6,     3,    26,    27,     6,     3,     6,
547      37,     6,    21,     6,    21,    22,    28,     6,     7,     7,
548       7,     7,    26
549};
550
551#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
552# define YYSIZE_T __SIZE_TYPE__
553#endif
554#if ! defined (YYSIZE_T) && defined (size_t)
555# define YYSIZE_T size_t
556#endif
557#if ! defined (YYSIZE_T)
558# if defined (__STDC__) || defined (__cplusplus)
559#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
560#  define YYSIZE_T size_t
561# endif
562#endif
563#if ! defined (YYSIZE_T)
564# define YYSIZE_T unsigned int
565#endif
566
567#define yyerrok         (yyerrstatus = 0)
568#define yyclearin       (yychar = YYEMPTY)
569#define YYEMPTY         (-2)
570#define YYEOF           0
571
572#define YYACCEPT        goto yyacceptlab
573#define YYABORT         goto yyabortlab
574#define YYERROR         goto yyerrorlab
575
576
577/* Like YYERROR except do call yyerror.  This remains here temporarily
578   to ease the transition to the new meaning of YYERROR, for GCC.
579   Once GCC version 2 has supplanted version 1, this can go.  */
580
581#define YYFAIL          goto yyerrlab
582
583#define YYRECOVERING()  (!!yyerrstatus)
584
585#define YYBACKUP(Token, Value)                                  \
586do                                                              \
587  if (yychar == YYEMPTY && yylen == 1)                          \
588    {                                                           \
589      yychar = (Token);                                         \
590      yylval = (Value);                                         \
591      yytoken = YYTRANSLATE (yychar);                           \
592      YYPOPSTACK;                                               \
593      goto yybackup;                                            \
594    }                                                           \
595  else                                                          \
596    {                                                           \
597      yyerror ("syntax error: cannot back up");\
598      YYERROR;                                                  \
599    }                                                           \
600while (0)
601
602#define YYTERROR        1
603#define YYERRCODE       256
604
605/* YYLLOC_DEFAULT -- Compute the default location (before the actions
606   are run).  */
607
608#ifndef YYLLOC_DEFAULT
609# define YYLLOC_DEFAULT(Current, Rhs, N)                \
610   ((Current).first_line   = (Rhs)[1].first_line,       \
611    (Current).first_column = (Rhs)[1].first_column,     \
612    (Current).last_line    = (Rhs)[N].last_line,        \
613    (Current).last_column  = (Rhs)[N].last_column)
614#endif
615
616/* YYLEX -- calling `yylex' with the right arguments.  */
617
618#ifdef YYLEX_PARAM
619# define YYLEX yylex (YYLEX_PARAM)
620#else
621# define YYLEX yylex ()
622#endif
623
624/* Enable debugging if requested.  */
625#if YYDEBUG
626
627# ifndef YYFPRINTF
628#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
629#  define YYFPRINTF fprintf
630# endif
631
632# define YYDPRINTF(Args)                        \
633do {                                            \
634  if (yydebug)                                  \
635    YYFPRINTF Args;                             \
636} while (0)
637
638# define YYDSYMPRINT(Args)                      \
639do {                                            \
640  if (yydebug)                                  \
641    yysymprint Args;                            \
642} while (0)
643
644# define YYDSYMPRINTF(Title, Token, Value, Location)            \
645do {                                                            \
646  if (yydebug)                                                  \
647    {                                                           \
648      YYFPRINTF (stderr, "%s ", Title);                         \
649      yysymprint (stderr,                                       \
650                  Token, Value);        \
651      YYFPRINTF (stderr, "\n");                                 \
652    }                                                           \
653} while (0)
654
655/*------------------------------------------------------------------.
656| yy_stack_print -- Print the state stack from its BOTTOM up to its |
657| TOP (included).                                                   |
658`------------------------------------------------------------------*/
659
660#if defined (__STDC__) || defined (__cplusplus)
661static void
662yy_stack_print (short int *bottom, short int *top)
663#else
664static void
665yy_stack_print (bottom, top)
666    short int *bottom;
667    short int *top;
668#endif
669{
670  YYFPRINTF (stderr, "Stack now");
671  for (/* Nothing. */; bottom <= top; ++bottom)
672    YYFPRINTF (stderr, " %d", *bottom);
673  YYFPRINTF (stderr, "\n");
674}
675
676# define YY_STACK_PRINT(Bottom, Top)                            \
677do {                                                            \
678  if (yydebug)                                                  \
679    yy_stack_print ((Bottom), (Top));                           \
680} while (0)
681
682
683/*------------------------------------------------.
684| Report that the YYRULE is going to be reduced.  |
685`------------------------------------------------*/
686
687#if defined (__STDC__) || defined (__cplusplus)
688static void
689yy_reduce_print (int yyrule)
690#else
691static void
692yy_reduce_print (yyrule)
693    int yyrule;
694#endif
695{
696  int yyi;
697  unsigned int yylno = yyrline[yyrule];
698  YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
699             yyrule - 1, yylno);
700  /* Print the symbols being reduced, and their result.  */
701  for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
702    YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
703  YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
704}
705
706# define YY_REDUCE_PRINT(Rule)          \
707do {                                    \
708  if (yydebug)                          \
709    yy_reduce_print (Rule);             \
710} while (0)
711
712/* Nonzero means print parse trace.  It is left uninitialized so that
713   multiple parsers can coexist.  */
714int yydebug;
715#else /* !YYDEBUG */
716# define YYDPRINTF(Args)
717# define YYDSYMPRINT(Args)
718# define YYDSYMPRINTF(Title, Token, Value, Location)
719# define YY_STACK_PRINT(Bottom, Top)
720# define YY_REDUCE_PRINT(Rule)
721#endif /* !YYDEBUG */
722
723
724/* YYINITDEPTH -- initial size of the parser's stacks.  */
725#ifndef YYINITDEPTH
726# define YYINITDEPTH 200
727#endif
728
729/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
730   if the built-in stack extension method is used).
731
732   Do not make this value too large; the results are undefined if
733   SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
734   evaluated with infinite-precision integer arithmetic.  */
735
736#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0
737# undef YYMAXDEPTH
738#endif
739
740#ifndef YYMAXDEPTH
741# define YYMAXDEPTH 10000
742#endif
743
744
745
746#if YYERROR_VERBOSE
747
748# ifndef yystrlen
749#  if defined (__GLIBC__) && defined (_STRING_H)
750#   define yystrlen strlen
751#  else
752/* Return the length of YYSTR.  */
753static YYSIZE_T
754#   if defined (__STDC__) || defined (__cplusplus)
755yystrlen (const char *yystr)
756#   else
757yystrlen (yystr)
758     const char *yystr;
759#   endif
760{
761  register const char *yys = yystr;
762
763  while (*yys++ != '\0')
764    continue;
765
766  return yys - yystr - 1;
767}
768#  endif
769# endif
770
771# ifndef yystpcpy
772#  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
773#   define yystpcpy stpcpy
774#  else
775/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
776   YYDEST.  */
777static char *
778#   if defined (__STDC__) || defined (__cplusplus)
779yystpcpy (char *yydest, const char *yysrc)
780#   else
781yystpcpy (yydest, yysrc)
782     char *yydest;
783     const char *yysrc;
784#   endif
785{
786  register char *yyd = yydest;
787  register const char *yys = yysrc;
788
789  while ((*yyd++ = *yys++) != '\0')
790    continue;
791
792  return yyd - 1;
793}
794#  endif
795# endif
796
797#endif /* !YYERROR_VERBOSE */
798
799
800
801#if YYDEBUG
802/*--------------------------------.
803| Print this symbol on YYOUTPUT.  |
804`--------------------------------*/
805
806#if defined (__STDC__) || defined (__cplusplus)
807static void
808yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
809#else
810static void
811yysymprint (yyoutput, yytype, yyvaluep)
812    FILE *yyoutput;
813    int yytype;
814    YYSTYPE *yyvaluep;
815#endif
816{
817  /* Pacify ``unused variable'' warnings.  */
818  (void) yyvaluep;
819
820  if (yytype < YYNTOKENS)
821    {
822      YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
823# ifdef YYPRINT
824      YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
825# endif
826    }
827  else
828    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
829
830  switch (yytype)
831    {
832      default:
833        break;
834    }
835  YYFPRINTF (yyoutput, ")");
836}
837
838#endif /* ! YYDEBUG */
839/*-----------------------------------------------.
840| Release the memory associated to this symbol.  |
841`-----------------------------------------------*/
842
843#if defined (__STDC__) || defined (__cplusplus)
844static void
845yydestruct (int yytype, YYSTYPE *yyvaluep)
846#else
847static void
848yydestruct (yytype, yyvaluep)
849    int yytype;
850    YYSTYPE *yyvaluep;
851#endif
852{
853  /* Pacify ``unused variable'' warnings.  */
854  (void) yyvaluep;
855
856  switch (yytype)
857    {
858
859      default:
860        break;
861    }
862}
863
864
865/* Prevent warnings from -Wmissing-prototypes.  */
866
867#ifdef YYPARSE_PARAM
868# if defined (__STDC__) || defined (__cplusplus)
869int yyparse (void *YYPARSE_PARAM);
870# else
871int yyparse ();
872# endif
873#else /* ! YYPARSE_PARAM */
874#if defined (__STDC__) || defined (__cplusplus)
875int yyparse (void);
876#else
877int yyparse ();
878#endif
879#endif /* ! YYPARSE_PARAM */
880
881
882
883/* The lookahead symbol.  */
884int yychar;
885
886/* The semantic value of the lookahead symbol.  */
887YYSTYPE yylval;
888
889/* Number of syntax errors so far.  */
890int yynerrs;
891
892
893
894/*----------.
895| yyparse.  |
896`----------*/
897
898#ifdef YYPARSE_PARAM
899# if defined (__STDC__) || defined (__cplusplus)
900int yyparse (void *YYPARSE_PARAM)
901# else
902int yyparse (YYPARSE_PARAM)
903  void *YYPARSE_PARAM;
904# endif
905#else /* ! YYPARSE_PARAM */
906#if defined (__STDC__) || defined (__cplusplus)
907int
908yyparse (void)
909#else
910int
911yyparse ()
912
913#endif
914#endif
915{
916 
917  register int yystate;
918  register int yyn;
919  int yyresult;
920  /* Number of tokens to shift before error messages enabled.  */
921  int yyerrstatus;
922  /* Lookahead token as an internal (translated) token number.  */
923  int yytoken = 0;
924
925  /* Three stacks and their tools:
926     `yyss': related to states,
927     `yyvs': related to semantic values,
928     `yyls': related to locations.
929
930     Refer to the stacks thru separate pointers, to allow yyoverflow
931     to reallocate them elsewhere.  */
932
933  /* The state stack.  */
934  short int yyssa[YYINITDEPTH];
935  short int *yyss = yyssa;
936  register short int *yyssp;
937
938  /* The semantic value stack.  */
939  YYSTYPE yyvsa[YYINITDEPTH];
940  YYSTYPE *yyvs = yyvsa;
941  register YYSTYPE *yyvsp;
942
943
944
945#define YYPOPSTACK   (yyvsp--, yyssp--)
946
947  YYSIZE_T yystacksize = YYINITDEPTH;
948
949  /* The variables used to return semantic value and location from the
950     action routines.  */
951  YYSTYPE yyval;
952
953
954  /* When reducing, the number of symbols on the RHS of the reduced
955     rule.  */
956  int yylen;
957
958  YYDPRINTF ((stderr, "Starting parse\n"));
959
960  yystate = 0;
961  yyerrstatus = 0;
962  yynerrs = 0;
963  yychar = YYEMPTY;             /* Cause a token to be read.  */
964
965  /* Initialize stack pointers.
966     Waste one element of value and location stack
967     so that they stay on the same level as the state stack.
968     The wasted elements are never initialized.  */
969
970  yyssp = yyss;
971  yyvsp = yyvs;
972
973
974  goto yysetstate;
975
976/*------------------------------------------------------------.
977| yynewstate -- Push a new state, which is found in yystate.  |
978`------------------------------------------------------------*/
979 yynewstate:
980  /* In all cases, when you get here, the value and location stacks
981     have just been pushed. so pushing a state here evens the stacks.
982     */
983  yyssp++;
984
985 yysetstate:
986  *yyssp = yystate;
987
988  if (yyss + yystacksize - 1 <= yyssp)
989    {
990      /* Get the current used size of the three stacks, in elements.  */
991      YYSIZE_T yysize = yyssp - yyss + 1;
992
993#ifdef yyoverflow
994      {
995        /* Give user a chance to reallocate the stack. Use copies of
996           these so that the &'s don't force the real ones into
997           memory.  */
998        YYSTYPE *yyvs1 = yyvs;
999        short int *yyss1 = yyss;
1000
1001
1002        /* Each stack pointer address is followed by the size of the
1003           data in use in that stack, in bytes.  This used to be a
1004           conditional around just the two extra args, but that might
1005           be undefined if yyoverflow is a macro.  */
1006        yyoverflow ("parser stack overflow",
1007                    &yyss1, yysize * sizeof (*yyssp),
1008                    &yyvs1, yysize * sizeof (*yyvsp),
1009
1010                    &yystacksize);
1011
1012        yyss = yyss1;
1013        yyvs = yyvs1;
1014      }
1015#else /* no yyoverflow */
1016# ifndef YYSTACK_RELOCATE
1017      goto yyoverflowlab;
1018# else
1019      /* Extend the stack our own way.  */
1020      if (YYMAXDEPTH <= yystacksize)
1021        goto yyoverflowlab;
1022      yystacksize *= 2;
1023      if (YYMAXDEPTH < yystacksize)
1024        yystacksize = YYMAXDEPTH;
1025
1026      {
1027        short int *yyss1 = yyss;
1028        union yyalloc *yyptr =
1029          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1030        if (! yyptr)
1031          goto yyoverflowlab;
1032        YYSTACK_RELOCATE (yyss);
1033        YYSTACK_RELOCATE (yyvs);
1034
1035#  undef YYSTACK_RELOCATE
1036        if (yyss1 != yyssa)
1037          YYSTACK_FREE (yyss1);
1038      }
1039# endif
1040#endif /* no yyoverflow */
1041
1042      yyssp = yyss + yysize - 1;
1043      yyvsp = yyvs + yysize - 1;
1044
1045
1046      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1047                  (unsigned long int) yystacksize));
1048
1049      if (yyss + yystacksize - 1 <= yyssp)
1050        YYABORT;
1051    }
1052
1053  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1054
1055  goto yybackup;
1056
1057/*-----------.
1058| yybackup.  |
1059`-----------*/
1060yybackup:
1061
1062/* Do appropriate processing given the current state.  */
1063/* Read a lookahead token if we need one and don't already have one.  */
1064/* yyresume: */
1065
1066  /* First try to decide what to do without reference to lookahead token.  */
1067
1068  yyn = yypact[yystate];
1069  if (yyn == YYPACT_NINF)
1070    goto yydefault;
1071
1072  /* Not known => get a lookahead token if don't already have one.  */
1073
1074  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
1075  if (yychar == YYEMPTY)
1076    {
1077      YYDPRINTF ((stderr, "Reading a token: "));
1078      yychar = YYLEX;
1079    }
1080
1081  if (yychar <= YYEOF)
1082    {
1083      yychar = yytoken = YYEOF;
1084      YYDPRINTF ((stderr, "Now at end of input.\n"));
1085    }
1086  else
1087    {
1088      yytoken = YYTRANSLATE (yychar);
1089      YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
1090    }
1091
1092  /* If the proper action on seeing token YYTOKEN is to reduce or to
1093     detect an error, take that action.  */
1094  yyn += yytoken;
1095  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1096    goto yydefault;
1097  yyn = yytable[yyn];
1098  if (yyn <= 0)
1099    {
1100      if (yyn == 0 || yyn == YYTABLE_NINF)
1101        goto yyerrlab;
1102      yyn = -yyn;
1103      goto yyreduce;
1104    }
1105
1106  if (yyn == YYFINAL)
1107    YYACCEPT;
1108
1109  /* Shift the lookahead token.  */
1110  YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
1111
1112  /* Discard the token being shifted unless it is eof.  */
1113  if (yychar != YYEOF)
1114    yychar = YYEMPTY;
1115
1116  *++yyvsp = yylval;
1117
1118
1119  /* Count tokens shifted since error; after three, turn off error
1120     status.  */
1121  if (yyerrstatus)
1122    yyerrstatus--;
1123
1124  yystate = yyn;
1125  goto yynewstate;
1126
1127
1128/*-----------------------------------------------------------.
1129| yydefault -- do the default action for the current state.  |
1130`-----------------------------------------------------------*/
1131yydefault:
1132  yyn = yydefact[yystate];
1133  if (yyn == 0)
1134    goto yyerrlab;
1135  goto yyreduce;
1136
1137
1138/*-----------------------------.
1139| yyreduce -- Do a reduction.  |
1140`-----------------------------*/
1141yyreduce:
1142  /* yyn is the number of a rule to reduce with.  */
1143  yylen = yyr2[yyn];
1144
1145  /* If YYLEN is nonzero, implement the default value of the action:
1146     `$$ = $1'.
1147
1148     Otherwise, the following line sets YYVAL to garbage.
1149     This behavior is undocumented and Bison
1150     users should not rely upon it.  Assigning to YYVAL
1151     unconditionally makes the parser a bit smaller, and it avoids a
1152     GCC warning that YYVAL may be used uninitialized.  */
1153  yyval = yyvsp[1-yylen];
1154
1155
1156  YY_REDUCE_PRINT (yyn);
1157  switch (yyn)
1158    {
1159        case 11:
1160#line 128 "bindparser.yy"
1161    {
1162                s_di.name=ZoneParser::canonic(yyvsp[-1]);
1163               
1164                parent->commit(s_di);
1165                s_di.clear();
1166        }
1167    break;
1168
1169  case 12:
1170#line 136 "bindparser.yy"
1171    {
1172                s_di.name=yyvsp[-2];
1173                parent->commit(s_di);
1174                s_di.clear();
1175        }
1176    break;
1177
1178  case 25:
1179#line 175 "bindparser.yy"
1180    {
1181                parent->setDirectory(yyvsp[0]);
1182        }
1183    break;
1184
1185  case 42:
1186#line 213 "bindparser.yy"
1187    {
1188                s_di.master=yyvsp[0];
1189        }
1190    break;
1191
1192  case 43:
1193#line 220 "bindparser.yy"
1194    {
1195          //            printf("Found a filename: '%s'\n",$2);
1196                s_di.filename=yyvsp[0];
1197        }
1198    break;
1199
1200  case 44:
1201#line 228 "bindparser.yy"
1202    {
1203                s_di.type=yyvsp[0];
1204        }
1205    break;
1206
1207  case 45:
1208#line 236 "bindparser.yy"
1209    {
1210                yyval=yyvsp[0];
1211        }
1212    break;
1213
1214
1215    }
1216
1217/* Line 1010 of yacc.c.  */
1218#line 1219 "bindparser.cc"
1219
1220  yyvsp -= yylen;
1221  yyssp -= yylen;
1222
1223
1224  YY_STACK_PRINT (yyss, yyssp);
1225
1226  *++yyvsp = yyval;
1227
1228
1229  /* Now `shift' the result of the reduction.  Determine what state
1230     that goes to, based on the state we popped back to and the rule
1231     number reduced by.  */
1232
1233  yyn = yyr1[yyn];
1234
1235  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1236  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1237    yystate = yytable[yystate];
1238  else
1239    yystate = yydefgoto[yyn - YYNTOKENS];
1240
1241  goto yynewstate;
1242
1243
1244/*------------------------------------.
1245| yyerrlab -- here on detecting error |
1246`------------------------------------*/
1247yyerrlab:
1248  /* If not already recovering from an error, report this error.  */
1249  if (!yyerrstatus)
1250    {
1251      ++yynerrs;
1252#if YYERROR_VERBOSE
1253      yyn = yypact[yystate];
1254
1255      if (YYPACT_NINF < yyn && yyn < YYLAST)
1256        {
1257          YYSIZE_T yysize = 0;
1258          int yytype = YYTRANSLATE (yychar);
1259          const char* yyprefix;
1260          char *yymsg;
1261          int yyx;
1262
1263          /* Start YYX at -YYN if negative to avoid negative indexes in
1264             YYCHECK.  */
1265          int yyxbegin = yyn < 0 ? -yyn : 0;
1266
1267          /* Stay within bounds of both yycheck and yytname.  */
1268          int yychecklim = YYLAST - yyn;
1269          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1270          int yycount = 0;
1271
1272          yyprefix = ", expecting ";
1273          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1274            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1275              {
1276                yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]);
1277                yycount += 1;
1278                if (yycount == 5)
1279                  {
1280                    yysize = 0;
1281                    break;
1282                  }
1283              }
1284          yysize += (sizeof ("syntax error, unexpected ")
1285                     + yystrlen (yytname[yytype]));
1286          yymsg = (char *) YYSTACK_ALLOC (yysize);
1287          if (yymsg != 0)
1288            {
1289              char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
1290              yyp = yystpcpy (yyp, yytname[yytype]);
1291
1292              if (yycount < 5)
1293                {
1294                  yyprefix = ", expecting ";
1295                  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1296                    if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1297                      {
1298                        yyp = yystpcpy (yyp, yyprefix);
1299                        yyp = yystpcpy (yyp, yytname[yyx]);
1300                        yyprefix = " or ";
1301                      }
1302                }
1303              yyerror (yymsg);
1304              YYSTACK_FREE (yymsg);
1305            }
1306          else
1307            yyerror ("syntax error; also virtual memory exhausted");
1308        }
1309      else
1310#endif /* YYERROR_VERBOSE */
1311        yyerror ("syntax error");
1312    }
1313
1314
1315
1316  if (yyerrstatus == 3)
1317    {
1318      /* If just tried and failed to reuse lookahead token after an
1319         error, discard it.  */
1320
1321      if (yychar <= YYEOF)
1322        {
1323          /* If at end of input, pop the error token,
1324             then the rest of the stack, then return failure.  */
1325          if (yychar == YYEOF)
1326             for (;;)
1327               {
1328                 YYPOPSTACK;
1329                 if (yyssp == yyss)
1330                   YYABORT;
1331                 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
1332                 yydestruct (yystos[*yyssp], yyvsp);
1333               }
1334        }
1335      else
1336        {
1337          YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
1338          yydestruct (yytoken, &yylval);
1339          yychar = YYEMPTY;
1340
1341        }
1342    }
1343
1344  /* Else will try to reuse lookahead token after shifting the error
1345     token.  */
1346  goto yyerrlab1;
1347
1348
1349/*---------------------------------------------------.
1350| yyerrorlab -- error raised explicitly by YYERROR.  |
1351`---------------------------------------------------*/
1352yyerrorlab:
1353
1354#ifdef __GNUC__
1355  /* Pacify GCC when the user code never invokes YYERROR and the label
1356     yyerrorlab therefore never appears in user code.  */
1357  if (0)
1358     goto yyerrorlab;
1359#endif
1360
1361  yyvsp -= yylen;
1362  yyssp -= yylen;
1363  yystate = *yyssp;
1364  goto yyerrlab1;
1365
1366
1367/*-------------------------------------------------------------.
1368| yyerrlab1 -- common code for both syntax error and YYERROR.  |
1369`-------------------------------------------------------------*/
1370yyerrlab1:
1371  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
1372
1373  for (;;)
1374    {
1375      yyn = yypact[yystate];
1376      if (yyn != YYPACT_NINF)
1377        {
1378          yyn += YYTERROR;
1379          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1380            {
1381              yyn = yytable[yyn];
1382              if (0 < yyn)
1383                break;
1384            }
1385        }
1386
1387      /* Pop the current state because it cannot handle the error token.  */
1388      if (yyssp == yyss)
1389        YYABORT;
1390
1391      YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
1392      yydestruct (yystos[yystate], yyvsp);
1393      YYPOPSTACK;
1394      yystate = *yyssp;
1395      YY_STACK_PRINT (yyss, yyssp);
1396    }
1397
1398  if (yyn == YYFINAL)
1399    YYACCEPT;
1400
1401  YYDPRINTF ((stderr, "Shifting error token, "));
1402
1403  *++yyvsp = yylval;
1404
1405
1406  yystate = yyn;
1407  goto yynewstate;
1408
1409
1410/*-------------------------------------.
1411| yyacceptlab -- YYACCEPT comes here.  |
1412`-------------------------------------*/
1413yyacceptlab:
1414  yyresult = 0;
1415  goto yyreturn;
1416
1417/*-----------------------------------.
1418| yyabortlab -- YYABORT comes here.  |
1419`-----------------------------------*/
1420yyabortlab:
1421  yyresult = 1;
1422  goto yyreturn;
1423
1424#ifndef yyoverflow
1425/*----------------------------------------------.
1426| yyoverflowlab -- parser overflow comes here.  |
1427`----------------------------------------------*/
1428yyoverflowlab:
1429  yyerror ("parser stack overflow");
1430  yyresult = 2;
1431  /* Fall through.  */
1432#endif
1433
1434yyreturn:
1435#ifndef yyoverflow
1436  if (yyss != yyssa)
1437    YYSTACK_FREE (yyss);
1438#endif
1439  return yyresult;
1440}
1441
1442
1443
Note: See TracBrowser for help on using the browser.