source: ThirdParty/mpqc_open/src/lib/util/keyval/ipv2_parse.cc@ 91c409

Candidate_v1.7.0 stable
Last change on this file since 91c409 was 860145, checked in by Frederik Heber <heber@…>, 9 years ago

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