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