1 /* A Bison parser, made by GNU Bison 2.5. */
2
3 /* Bison implementation for Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
6
7 This program is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 /* As a special exception, you may create a larger work that contains
21 part or all of the Bison parser skeleton and distribute that work
22 under terms of your choice, so long as that work isn't itself a
23 parser generator using the skeleton or a modified version thereof
24 as a parser skeleton. Alternatively, if you modify or redistribute
25 the parser skeleton itself, you may (at your option) remove this
26 special exception, which will cause the skeleton and the resulting
27 Bison output files to be licensed under the GNU General Public
28 License without this special exception.
29
30 This special exception was added by the Free Software Foundation in
31 version 2.2 of Bison. */
32
33 /* C LALR(1) parser skeleton written by Richard Stallman, by
34 simplifying the original so-called "semantic" parser. */
35
36 /* All symbols defined below should begin with yy or YY, to avoid
37 infringing on user name space. This should be done even for local
38 variables, as they might otherwise be expanded by user macros.
39 There are some unavoidable exceptions within include files to
40 define necessary library symbols; they are noted "INFRINGES ON
41 USER NAME SPACE" below. */
42
43 /* Identify Bison output. */
44 #define YYBISON 1
45
46 /* Bison version. */
47 #define YYBISON_VERSION "2.5"
48
49 /* Skeleton name. */
50 #define YYSKELETON_NAME "yacc.c"
51
52 /* Pure parsers. */
53 #define YYPURE 0
54
55 /* Push parsers. */
56 #define YYPUSH 0
57
58 /* Pull parsers. */
59 #define YYPULL 1
60
61 /* Using locations. */
62 #define YYLSP_NEEDED 0
63
64
65
66 /* Copy the first part of user declarations. */
67
68 /* Line 268 of yacc.c */
69 #line 1 "gram.y"
70
71 /* -*- c -*-
72 * Grammar for states.
73 * Copyright (c) 1997-1998 Markku Rossi.
74 *
75 * Author: Markku Rossi <mtr@iki.fi>
76 */
77
78 /*
79 * This file is part of GNU Enscript.
80 *
81 * Enscript is free software: you can redistribute it and/or modify
82 * it under the terms of the GNU General Public License as published by
83 * the Free Software Foundation, either version 3 of the License, or
84 * (at your option) any later version.
85 *
86 * Enscript is distributed in the hope that it will be useful,
87 * but WITHOUT ANY WARRANTY; without even the implied warranty of
88 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
89 * GNU General Public License for more details.
90 *
91 * You should have received a copy of the GNU General Public License
92 * along with Enscript. If not, see <http://www.gnu.org/licenses/>.
93 */
94
95 /*
96 * $Id: gram.y,v 1.1.1.1 2003/03/05 07:25:52 mtr Exp $
97 */
98
99 #include "defs.h"
100
101
102 /* Line 268 of yacc.c */
103 #line 104 "gram.c"
104
105 /* Enabling traces. */
106 #ifndef YYDEBUG
107 # define YYDEBUG 0
108 #endif
109
110 /* Enabling verbose error messages. */
111 #ifdef YYERROR_VERBOSE
112 # undef YYERROR_VERBOSE
113 # define YYERROR_VERBOSE 1
114 #else
115 # define YYERROR_VERBOSE 0
116 #endif
117
118 /* Enabling the token table. */
119 #ifndef YYTOKEN_TABLE
120 # define YYTOKEN_TABLE 0
121 #endif
122
123
124 /* Tokens. */
125 #ifndef YYTOKENTYPE
126 # define YYTOKENTYPE
127 /* Put the tokens into the symbol table, so that GDB and other debuggers
128 know about them. */
129 enum yytokentype {
130 tSYMBOL = 258,
131 tREGEXP = 259,
132 tSTRING = 260,
133 tINTEGER = 261,
134 tREAL = 262,
135 tSUB = 263,
136 tSTATE = 264,
137 tSTART = 265,
138 tSTARTRULES = 266,
139 tNAMERULES = 267,
140 tBEGIN = 268,
141 tEND = 269,
142 tRETURN = 270,
143 tIF = 271,
144 tELSE = 272,
145 tLOCAL = 273,
146 tWHILE = 274,
147 tFOR = 275,
148 tEXTENDS = 276,
149 tDIVASSIGN = 277,
150 tMULASSIGN = 278,
151 tSUBASSIGN = 279,
152 tADDASSIGN = 280,
153 tOR = 281,
154 tAND = 282,
155 tNE = 283,
156 tEQ = 284,
157 tLE = 285,
158 tGE = 286,
159 tDIV = 287,
160 tMINUSMINUS = 288,
161 tPLUSPLUS = 289
162 };
163 #endif
164 /* Tokens. */
165 #define tSYMBOL 258
166 #define tREGEXP 259
167 #define tSTRING 260
168 #define tINTEGER 261
169 #define tREAL 262
170 #define tSUB 263
171 #define tSTATE 264
172 #define tSTART 265
173 #define tSTARTRULES 266
174 #define tNAMERULES 267
175 #define tBEGIN 268
176 #define tEND 269
177 #define tRETURN 270
178 #define tIF 271
179 #define tELSE 272
180 #define tLOCAL 273
181 #define tWHILE 274
182 #define tFOR 275
183 #define tEXTENDS 276
184 #define tDIVASSIGN 277
185 #define tMULASSIGN 278
186 #define tSUBASSIGN 279
187 #define tADDASSIGN 280
188 #define tOR 281
189 #define tAND 282
190 #define tNE 283
191 #define tEQ 284
192 #define tLE 285
193 #define tGE 286
194 #define tDIV 287
195 #define tMINUSMINUS 288
196 #define tPLUSPLUS 289
197
198
199
200
201 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
202 typedef union YYSTYPE
203 {
204
205 /* Line 293 of yacc.c */
206 #line 34 "gram.y"
207
208 List *lst;
209 Node *node;
210 Cons *cons;
211 Stmt *stmt;
212 Expr *expr;
213
214
215
216 /* Line 293 of yacc.c */
217 #line 218 "gram.c"
218 } YYSTYPE;
219 # define YYSTYPE_IS_TRIVIAL 1
220 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
221 # define YYSTYPE_IS_DECLARED 1
222 #endif
223
224
225 /* Copy the second part of user declarations. */
226
227
228 /* Line 343 of yacc.c */
229 #line 230 "gram.c"
230
231 #ifdef short
232 # undef short
233 #endif
234
235 #ifdef YYTYPE_UINT8
236 typedef YYTYPE_UINT8 yytype_uint8;
237 #else
238 typedef unsigned char yytype_uint8;
239 #endif
240
241 #ifdef YYTYPE_INT8
242 typedef YYTYPE_INT8 yytype_int8;
243 #elif (defined __STDC__ || defined __C99__FUNC__ \
244 || defined __cplusplus || defined _MSC_VER)
245 typedef signed char yytype_int8;
246 #else
247 typedef short int yytype_int8;
248 #endif
249
250 #ifdef YYTYPE_UINT16
251 typedef YYTYPE_UINT16 yytype_uint16;
252 #else
253 typedef unsigned short int yytype_uint16;
254 #endif
255
256 #ifdef YYTYPE_INT16
257 typedef YYTYPE_INT16 yytype_int16;
258 #else
259 typedef short int yytype_int16;
260 #endif
261
262 #ifndef YYSIZE_T
263 # ifdef __SIZE_TYPE__
264 # define YYSIZE_T __SIZE_TYPE__
265 # elif defined size_t
266 # define YYSIZE_T size_t
267 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
268 || defined __cplusplus || defined _MSC_VER)
269 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
270 # define YYSIZE_T size_t
271 # else
272 # define YYSIZE_T unsigned int
273 # endif
274 #endif
275
276 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
277
278 #ifndef YY_
279 # if defined YYENABLE_NLS && YYENABLE_NLS
280 # if ENABLE_NLS
281 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
282 # define YY_(msgid) dgettext ("bison-runtime", msgid)
283 # endif
284 # endif
285 # ifndef YY_
286 # define YY_(msgid) msgid
287 # endif
288 #endif
289
290 /* Suppress unused-variable warnings by "using" E. */
291 #if ! defined lint || defined __GNUC__
292 # define YYUSE(e) ((void) (e))
293 #else
294 # define YYUSE(e) /* empty */
295 #endif
296
297 /* Identity function, used to suppress warnings about constant conditions. */
298 #ifndef lint
299 # define YYID(n) (n)
300 #else
301 #if (defined __STDC__ || defined __C99__FUNC__ \
302 || defined __cplusplus || defined _MSC_VER)
303 static int
YYID(int yyi)304 YYID (int yyi)
305 #else
306 static int
307 YYID (yyi)
308 int yyi;
309 #endif
310 {
311 return yyi;
312 }
313 #endif
314
315 #if ! defined yyoverflow || YYERROR_VERBOSE
316
317 /* The parser invokes alloca or malloc; define the necessary symbols. */
318
319 # ifdef YYSTACK_USE_ALLOCA
320 # if YYSTACK_USE_ALLOCA
321 # ifdef __GNUC__
322 # define YYSTACK_ALLOC __builtin_alloca
323 # elif defined __BUILTIN_VA_ARG_INCR
324 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
325 # elif defined _AIX
326 # define YYSTACK_ALLOC __alloca
327 # elif defined _MSC_VER
328 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
329 # define alloca _alloca
330 # else
331 # define YYSTACK_ALLOC alloca
332 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
333 || defined __cplusplus || defined _MSC_VER)
334 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
335 # ifndef EXIT_SUCCESS
336 # define EXIT_SUCCESS 0
337 # endif
338 # endif
339 # endif
340 # endif
341 # endif
342
343 # ifdef YYSTACK_ALLOC
344 /* Pacify GCC's `empty if-body' warning. */
345 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
346 # ifndef YYSTACK_ALLOC_MAXIMUM
347 /* The OS might guarantee only one guard page at the bottom of the stack,
348 and a page size can be as small as 4096 bytes. So we cannot safely
349 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
350 to allow for a few compiler-allocated temporary stack slots. */
351 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
352 # endif
353 # else
354 # define YYSTACK_ALLOC YYMALLOC
355 # define YYSTACK_FREE YYFREE
356 # ifndef YYSTACK_ALLOC_MAXIMUM
357 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
358 # endif
359 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
360 && ! ((defined YYMALLOC || defined malloc) \
361 && (defined YYFREE || defined free)))
362 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
363 # ifndef EXIT_SUCCESS
364 # define EXIT_SUCCESS 0
365 # endif
366 # endif
367 # ifndef YYMALLOC
368 # define YYMALLOC malloc
369 # if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
370 || defined __cplusplus || defined _MSC_VER)
371 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
372 # endif
373 # endif
374 # ifndef YYFREE
375 # define YYFREE free
376 # if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
377 || defined __cplusplus || defined _MSC_VER)
378 void free (void *); /* INFRINGES ON USER NAME SPACE */
379 # endif
380 # endif
381 # endif
382 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
383
384
385 #if (! defined yyoverflow \
386 && (! defined __cplusplus \
387 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
388
389 /* A type that is properly aligned for any stack member. */
390 union yyalloc
391 {
392 yytype_int16 yyss_alloc;
393 YYSTYPE yyvs_alloc;
394 };
395
396 /* The size of the maximum gap between one aligned stack and the next. */
397 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
398
399 /* The size of an array large to enough to hold all stacks, each with
400 N elements. */
401 # define YYSTACK_BYTES(N) \
402 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
403 + YYSTACK_GAP_MAXIMUM)
404
405 # define YYCOPY_NEEDED 1
406
407 /* Relocate STACK from its old location to the new one. The
408 local variables YYSIZE and YYSTACKSIZE give the old and new number of
409 elements in the stack, and YYPTR gives the new location of the
410 stack. Advance YYPTR to a properly aligned location for the next
411 stack. */
412 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
413 do \
414 { \
415 YYSIZE_T yynewbytes; \
416 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
417 Stack = &yyptr->Stack_alloc; \
418 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
419 yyptr += yynewbytes / sizeof (*yyptr); \
420 } \
421 while (YYID (0))
422
423 #endif
424
425 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
426 /* Copy COUNT objects from FROM to TO. The source and destination do
427 not overlap. */
428 # ifndef YYCOPY
429 # if defined __GNUC__ && 1 < __GNUC__
430 # define YYCOPY(To, From, Count) \
431 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
432 # else
433 # define YYCOPY(To, From, Count) \
434 do \
435 { \
436 YYSIZE_T yyi; \
437 for (yyi = 0; yyi < (Count); yyi++) \
438 (To)[yyi] = (From)[yyi]; \
439 } \
440 while (YYID (0))
441 # endif
442 # endif
443 #endif /* !YYCOPY_NEEDED */
444
445 /* YYFINAL -- State number of the termination state. */
446 #define YYFINAL 2
447 /* YYLAST -- Last index in YYTABLE. */
448 #define YYLAST 571
449
450 /* YYNTOKENS -- Number of terminals. */
451 #define YYNTOKENS 52
452 /* YYNNTS -- Number of nonterminals. */
453 #define YYNNTS 17
454 /* YYNRULES -- Number of rules. */
455 #define YYNRULES 76
456 /* YYNRULES -- Number of states. */
457 #define YYNSTATES 167
458
459 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
460 #define YYUNDEFTOK 2
461 #define YYMAXUTOK 289
462
463 #define YYTRANSLATE(YYX) \
464 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
465
466 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
467 static const yytype_uint8 yytranslate[] =
468 {
469 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
470 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
471 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
472 2, 2, 2, 41, 2, 2, 2, 2, 2, 2,
473 50, 51, 39, 37, 49, 38, 2, 2, 2, 2,
474 2, 2, 2, 2, 2, 2, 2, 2, 28, 48,
475 33, 22, 34, 27, 2, 2, 2, 2, 2, 2,
476 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
477 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
478 2, 44, 2, 45, 2, 2, 2, 2, 2, 2,
479 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
480 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
481 2, 2, 2, 46, 2, 47, 2, 2, 2, 2,
482 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
483 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
484 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
485 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
486 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
487 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
488 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
489 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
490 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
491 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
492 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
493 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
494 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
495 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
496 15, 16, 17, 18, 19, 20, 21, 23, 24, 25,
497 26, 29, 30, 31, 32, 35, 36, 40, 42, 43
498 };
499
500 #if YYDEBUG
501 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
502 YYRHS. */
503 static const yytype_uint16 yyprhs[] =
504 {
505 0, 0, 3, 4, 7, 12, 17, 22, 28, 36,
506 38, 39, 44, 45, 48, 53, 58, 63, 68, 69,
507 71, 73, 77, 78, 82, 84, 88, 90, 94, 95,
508 98, 101, 105, 115, 119, 125, 133, 139, 149, 152,
509 154, 156, 158, 160, 162, 165, 169, 173, 178, 182,
510 186, 190, 194, 198, 201, 204, 207, 210, 217, 221,
511 226, 232, 236, 240, 244, 248, 252, 256, 260, 264,
512 268, 272, 273, 275, 276, 278, 280
513 };
514
515 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
516 static const yytype_int8 yyrhs[] =
517 {
518 53, 0, -1, -1, 53, 54, -1, 10, 46, 63,
519 47, -1, 11, 46, 55, 47, -1, 12, 46, 55,
520 47, -1, 9, 3, 46, 56, 47, -1, 9, 3,
521 21, 3, 46, 56, 47, -1, 64, -1, -1, 55,
522 4, 3, 48, -1, -1, 56, 57, -1, 13, 46,
523 63, 47, -1, 14, 46, 63, 47, -1, 4, 46,
524 63, 47, -1, 3, 46, 63, 47, -1, -1, 59,
525 -1, 3, -1, 59, 49, 3, -1, -1, 18, 61,
526 48, -1, 62, -1, 61, 49, 62, -1, 3, -1,
527 3, 22, 65, -1, -1, 63, 64, -1, 15, 48,
528 -1, 15, 65, 48, -1, 8, 3, 50, 58, 51,
529 46, 60, 63, 47, -1, 46, 63, 47, -1, 16,
530 50, 65, 51, 64, -1, 16, 50, 65, 51, 64,
531 17, 64, -1, 19, 50, 65, 51, 64, -1, 20,
532 50, 66, 48, 65, 48, 66, 51, 64, -1, 65,
533 48, -1, 5, -1, 4, -1, 6, -1, 7, -1,
534 3, -1, 41, 65, -1, 65, 30, 65, -1, 65,
535 29, 65, -1, 3, 50, 67, 51, -1, 3, 22,
536 65, -1, 3, 26, 65, -1, 3, 25, 65, -1,
537 3, 24, 65, -1, 3, 23, 65, -1, 3, 43,
538 -1, 3, 42, -1, 43, 3, -1, 42, 3, -1,
539 65, 44, 65, 45, 22, 65, -1, 50, 65, 51,
540 -1, 65, 44, 65, 45, -1, 65, 27, 65, 28,
541 65, -1, 65, 39, 65, -1, 65, 40, 65, -1,
542 65, 37, 65, -1, 65, 38, 65, -1, 65, 33,
543 65, -1, 65, 34, 65, -1, 65, 32, 65, -1,
544 65, 31, 65, -1, 65, 36, 65, -1, 65, 35,
545 65, -1, -1, 65, -1, -1, 68, -1, 65, -1,
546 68, 49, 65, -1
547 };
548
549 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
550 static const yytype_uint8 yyrline[] =
551 {
552 0, 65, 65, 66, 69, 70, 72, 74, 76, 78,
553 81, 82, 86, 87, 89, 90, 91, 92, 95, 96,
554 99, 100, 103, 104, 107, 108, 111, 112, 115, 116,
555 119, 121, 123, 128, 130, 132, 135, 137, 140, 144,
556 146, 148, 150, 152, 154, 156, 157, 158, 160, 162,
557 164, 166, 168, 170, 172, 174, 176, 178, 180, 181,
558 183, 185, 186, 187, 188, 190, 191, 192, 193, 194,
559 195, 198, 199, 202, 203, 206, 207
560 };
561 #endif
562
563 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
564 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
565 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
566 static const char *const yytname[] =
567 {
568 "$end", "error", "$undefined", "tSYMBOL", "tREGEXP", "tSTRING",
569 "tINTEGER", "tREAL", "tSUB", "tSTATE", "tSTART", "tSTARTRULES",
570 "tNAMERULES", "tBEGIN", "tEND", "tRETURN", "tIF", "tELSE", "tLOCAL",
571 "tWHILE", "tFOR", "tEXTENDS", "'='", "tDIVASSIGN", "tMULASSIGN",
572 "tSUBASSIGN", "tADDASSIGN", "'?'", "':'", "tOR", "tAND", "tNE", "tEQ",
573 "'<'", "'>'", "tLE", "tGE", "'+'", "'-'", "'*'", "tDIV", "'!'",
574 "tMINUSMINUS", "tPLUSPLUS", "'['", "']'", "'{'", "'}'", "';'", "','",
575 "'('", "')'", "$accept", "file", "toplevel", "regexp_sym_list",
576 "staterules", "staterule", "symbol_list", "rest_symbol_list", "locals",
577 "locals_rest", "local_def", "stmt_list", "stmt", "expr", "cond_expr",
578 "expr_list", "rest_expr_list", 0
579 };
580 #endif
581
582 # ifdef YYPRINT
583 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
584 token YYLEX-NUM. */
585 static const yytype_uint16 yytoknum[] =
586 {
587 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
588 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
589 275, 276, 61, 277, 278, 279, 280, 63, 58, 281,
590 282, 283, 284, 60, 62, 285, 286, 43, 45, 42,
591 287, 33, 288, 289, 91, 93, 123, 125, 59, 44,
592 40, 41
593 };
594 # endif
595
596 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
597 static const yytype_uint8 yyr1[] =
598 {
599 0, 52, 53, 53, 54, 54, 54, 54, 54, 54,
600 55, 55, 56, 56, 57, 57, 57, 57, 58, 58,
601 59, 59, 60, 60, 61, 61, 62, 62, 63, 63,
602 64, 64, 64, 64, 64, 64, 64, 64, 64, 65,
603 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
604 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
605 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
606 65, 66, 66, 67, 67, 68, 68
607 };
608
609 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
610 static const yytype_uint8 yyr2[] =
611 {
612 0, 2, 0, 2, 4, 4, 4, 5, 7, 1,
613 0, 4, 0, 2, 4, 4, 4, 4, 0, 1,
614 1, 3, 0, 3, 1, 3, 1, 3, 0, 2,
615 2, 3, 9, 3, 5, 7, 5, 9, 2, 1,
616 1, 1, 1, 1, 2, 3, 3, 4, 3, 3,
617 3, 3, 3, 2, 2, 2, 2, 6, 3, 4,
618 5, 3, 3, 3, 3, 3, 3, 3, 3, 3,
619 3, 0, 1, 0, 1, 1, 3
620 };
621
622 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
623 Performed when YYTABLE doesn't specify something else to do. Zero
624 means the default is an error. */
625 static const yytype_uint8 yydefact[] =
626 {
627 2, 0, 1, 43, 40, 39, 41, 42, 0, 0,
628 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
629 28, 0, 3, 9, 0, 0, 0, 0, 0, 0,
630 54, 53, 73, 0, 0, 28, 10, 10, 30, 0,
631 0, 0, 71, 44, 56, 55, 0, 0, 0, 0,
632 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
633 0, 0, 38, 48, 52, 51, 50, 49, 75, 0,
634 74, 18, 0, 12, 0, 0, 0, 31, 0, 0,
635 72, 0, 33, 29, 58, 0, 46, 45, 68, 67,
636 65, 66, 70, 69, 63, 64, 61, 62, 0, 47,
637 0, 20, 0, 19, 0, 0, 4, 0, 5, 6,
638 0, 0, 0, 0, 59, 76, 0, 0, 12, 0,
639 0, 0, 0, 7, 13, 0, 34, 36, 0, 60,
640 0, 22, 21, 0, 28, 28, 28, 28, 11, 0,
641 71, 57, 0, 28, 8, 0, 0, 0, 0, 35,
642 0, 26, 0, 24, 0, 17, 16, 14, 15, 0,
643 0, 23, 0, 32, 37, 27, 25
644 };
645
646 /* YYDEFGOTO[NTERM-NUM]. */
647 static const yytype_int16 yydefgoto[] =
648 {
649 -1, 1, 22, 75, 105, 124, 102, 103, 143, 152,
650 153, 46, 83, 24, 81, 69, 70
651 };
652
653 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
654 STATE-NUM. */
655 #define YYPACT_NINF -41
656 static const yytype_int16 yypact[] =
657 {
658 -41, 71, -41, 300, -41, -41, -41, -41, 1, 9,
659 -40, -28, -27, 18, -24, -18, -17, 296, 28, 31,
660 -41, 296, -41, -41, 391, 296, 296, 296, 296, 296,
661 -41, -41, 296, -15, -19, -41, -41, -41, -41, 411,
662 296, 296, 296, 12, -41, -41, 126, 322, 296, 296,
663 296, 296, 296, 296, 296, 296, 296, 296, 296, 296,
664 296, 296, -41, 486, 486, 486, 486, 486, 486, 6,
665 20, 64, 67, -41, 146, 3, 4, -41, 345, 368,
666 486, 10, -41, -41, -41, 470, 501, 515, 527, 527,
667 55, 55, 55, 55, 45, 45, 12, 12, 451, -41,
668 296, -41, 21, 24, 60, 49, -41, 94, -41, -41,
669 290, 290, 296, 296, 85, 486, 62, 112, -41, 70,
670 73, 74, 76, -41, -41, 75, 107, -41, 431, 486,
671 296, 108, -41, 51, -41, -41, -41, -41, -41, 290,
672 296, 486, 122, -41, -41, 175, 194, 223, 242, -41,
673 84, 105, -38, -41, 271, -41, -41, -41, -41, 290,
674 296, -41, 122, -41, -41, 486, -41
675 };
676
677 /* YYPGOTO[NTERM-NUM]. */
678 static const yytype_int8 yypgoto[] =
679 {
680 -41, -41, -41, 99, 19, -41, -41, -41, -41, -41,
681 -23, -32, -1, -12, 0, -41, -41
682 };
683
684 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
685 positive, shift that token. If negative, reduce the rule which
686 number is the opposite. If YYTABLE_NINF, syntax error. */
687 #define YYTABLE_NINF -1
688 static const yytype_uint8 yytable[] =
689 {
690 23, 39, 72, 74, 33, 43, 35, 107, 107, 47,
691 161, 162, 34, 63, 64, 65, 66, 67, 36, 37,
692 68, 3, 4, 5, 6, 7, 40, 73, 78, 79,
693 80, 44, 41, 42, 45, 71, 85, 86, 87, 88,
694 89, 90, 91, 92, 93, 94, 95, 96, 97, 98,
695 108, 109, 119, 120, 119, 120, 61, 99, 112, 17,
696 18, 19, 121, 122, 121, 122, 38, 101, 21, 100,
697 104, 2, 116, 117, 3, 4, 5, 6, 7, 8,
698 9, 10, 11, 12, 59, 60, 13, 14, 115, 61,
699 15, 16, 57, 58, 59, 60, 123, 125, 144, 61,
700 128, 129, 145, 146, 147, 148, 118, 130, 131, 126,
701 127, 154, 17, 18, 19, 132, 134, 20, 141, 135,
702 136, 21, 137, 138, 139, 151, 142, 160, 80, 3,
703 4, 5, 6, 7, 8, 159, 76, 133, 149, 166,
704 150, 13, 14, 0, 0, 15, 16, 0, 165, 3,
705 4, 5, 6, 7, 8, 0, 0, 0, 164, 0,
706 0, 13, 14, 0, 0, 15, 16, 17, 18, 19,
707 0, 0, 20, 82, 0, 0, 21, 0, 3, 4,
708 5, 6, 7, 8, 0, 0, 0, 17, 18, 19,
709 13, 14, 20, 106, 15, 16, 21, 3, 4, 5,
710 6, 7, 8, 0, 0, 0, 0, 0, 0, 13,
711 14, 0, 0, 15, 16, 0, 17, 18, 19, 0,
712 0, 20, 155, 0, 0, 21, 3, 4, 5, 6,
713 7, 8, 0, 0, 0, 17, 18, 19, 13, 14,
714 20, 156, 15, 16, 21, 3, 4, 5, 6, 7,
715 8, 0, 0, 0, 0, 0, 0, 13, 14, 0,
716 0, 15, 16, 0, 17, 18, 19, 0, 0, 20,
717 157, 0, 0, 21, 3, 4, 5, 6, 7, 8,
718 0, 0, 0, 17, 18, 19, 13, 14, 20, 158,
719 15, 16, 21, 3, 4, 5, 6, 7, 8, 3,
720 4, 5, 6, 7, 0, 13, 14, 0, 0, 15,
721 16, 0, 17, 18, 19, 0, 0, 20, 163, 0,
722 0, 21, 25, 26, 27, 28, 29, 0, 0, 0,
723 0, 17, 18, 19, 0, 0, 20, 17, 18, 19,
724 21, 0, 30, 31, 0, 0, 21, 0, 0, 48,
725 32, 49, 50, 51, 52, 53, 54, 55, 56, 57,
726 58, 59, 60, 0, 0, 0, 61, 0, 0, 0,
727 0, 0, 48, 84, 49, 50, 51, 52, 53, 54,
728 55, 56, 57, 58, 59, 60, 0, 0, 0, 61,
729 0, 0, 0, 0, 0, 48, 110, 49, 50, 51,
730 52, 53, 54, 55, 56, 57, 58, 59, 60, 0,
731 0, 0, 61, 0, 0, 0, 0, 0, 48, 111,
732 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
733 59, 60, 0, 0, 0, 61, 0, 0, 48, 62,
734 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
735 59, 60, 0, 0, 0, 61, 0, 0, 48, 77,
736 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
737 59, 60, 0, 0, 0, 61, 0, 0, 48, 140,
738 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
739 59, 60, 0, 0, 0, 61, 114, 48, 113, 49,
740 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
741 60, 0, 0, 48, 61, 49, 50, 51, 52, 53,
742 54, 55, 56, 57, 58, 59, 60, 0, 0, 0,
743 61, 50, 51, 52, 53, 54, 55, 56, 57, 58,
744 59, 60, 0, 0, 0, 61, 51, 52, 53, 54,
745 55, 56, 57, 58, 59, 60, 0, 0, 0, 61,
746 53, 54, 55, 56, 57, 58, 59, 60, 0, 0,
747 0, 61
748 };
749
750 #define yypact_value_is_default(yystate) \
751 ((yystate) == (-41))
752
753 #define yytable_value_is_error(yytable_value) \
754 YYID (0)
755
756 static const yytype_int16 yycheck[] =
757 {
758 1, 13, 21, 35, 3, 17, 46, 4, 4, 21,
759 48, 49, 3, 25, 26, 27, 28, 29, 46, 46,
760 32, 3, 4, 5, 6, 7, 50, 46, 40, 41,
761 42, 3, 50, 50, 3, 50, 48, 49, 50, 51,
762 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
763 47, 47, 3, 4, 3, 4, 44, 51, 48, 41,
764 42, 43, 13, 14, 13, 14, 48, 3, 50, 49,
765 3, 0, 51, 49, 3, 4, 5, 6, 7, 8,
766 9, 10, 11, 12, 39, 40, 15, 16, 100, 44,
767 19, 20, 37, 38, 39, 40, 47, 3, 47, 44,
768 112, 113, 134, 135, 136, 137, 46, 22, 46, 110,
769 111, 143, 41, 42, 43, 3, 46, 46, 130, 46,
770 46, 50, 46, 48, 17, 3, 18, 22, 140, 3,
771 4, 5, 6, 7, 8, 51, 37, 118, 139, 162,
772 140, 15, 16, -1, -1, 19, 20, -1, 160, 3,
773 4, 5, 6, 7, 8, -1, -1, -1, 159, -1,
774 -1, 15, 16, -1, -1, 19, 20, 41, 42, 43,
775 -1, -1, 46, 47, -1, -1, 50, -1, 3, 4,
776 5, 6, 7, 8, -1, -1, -1, 41, 42, 43,
777 15, 16, 46, 47, 19, 20, 50, 3, 4, 5,
778 6, 7, 8, -1, -1, -1, -1, -1, -1, 15,
779 16, -1, -1, 19, 20, -1, 41, 42, 43, -1,
780 -1, 46, 47, -1, -1, 50, 3, 4, 5, 6,
781 7, 8, -1, -1, -1, 41, 42, 43, 15, 16,
782 46, 47, 19, 20, 50, 3, 4, 5, 6, 7,
783 8, -1, -1, -1, -1, -1, -1, 15, 16, -1,
784 -1, 19, 20, -1, 41, 42, 43, -1, -1, 46,
785 47, -1, -1, 50, 3, 4, 5, 6, 7, 8,
786 -1, -1, -1, 41, 42, 43, 15, 16, 46, 47,
787 19, 20, 50, 3, 4, 5, 6, 7, 8, 3,
788 4, 5, 6, 7, -1, 15, 16, -1, -1, 19,
789 20, -1, 41, 42, 43, -1, -1, 46, 47, -1,
790 -1, 50, 22, 23, 24, 25, 26, -1, -1, -1,
791 -1, 41, 42, 43, -1, -1, 46, 41, 42, 43,
792 50, -1, 42, 43, -1, -1, 50, -1, -1, 27,
793 50, 29, 30, 31, 32, 33, 34, 35, 36, 37,
794 38, 39, 40, -1, -1, -1, 44, -1, -1, -1,
795 -1, -1, 27, 51, 29, 30, 31, 32, 33, 34,
796 35, 36, 37, 38, 39, 40, -1, -1, -1, 44,
797 -1, -1, -1, -1, -1, 27, 51, 29, 30, 31,
798 32, 33, 34, 35, 36, 37, 38, 39, 40, -1,
799 -1, -1, 44, -1, -1, -1, -1, -1, 27, 51,
800 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
801 39, 40, -1, -1, -1, 44, -1, -1, 27, 48,
802 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
803 39, 40, -1, -1, -1, 44, -1, -1, 27, 48,
804 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
805 39, 40, -1, -1, -1, 44, -1, -1, 27, 48,
806 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
807 39, 40, -1, -1, -1, 44, 45, 27, 28, 29,
808 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
809 40, -1, -1, 27, 44, 29, 30, 31, 32, 33,
810 34, 35, 36, 37, 38, 39, 40, -1, -1, -1,
811 44, 30, 31, 32, 33, 34, 35, 36, 37, 38,
812 39, 40, -1, -1, -1, 44, 31, 32, 33, 34,
813 35, 36, 37, 38, 39, 40, -1, -1, -1, 44,
814 33, 34, 35, 36, 37, 38, 39, 40, -1, -1,
815 -1, 44
816 };
817
818 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
819 symbol of state STATE-NUM. */
820 static const yytype_uint8 yystos[] =
821 {
822 0, 53, 0, 3, 4, 5, 6, 7, 8, 9,
823 10, 11, 12, 15, 16, 19, 20, 41, 42, 43,
824 46, 50, 54, 64, 65, 22, 23, 24, 25, 26,
825 42, 43, 50, 3, 3, 46, 46, 46, 48, 65,
826 50, 50, 50, 65, 3, 3, 63, 65, 27, 29,
827 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
828 40, 44, 48, 65, 65, 65, 65, 65, 65, 67,
829 68, 50, 21, 46, 63, 55, 55, 48, 65, 65,
830 65, 66, 47, 64, 51, 65, 65, 65, 65, 65,
831 65, 65, 65, 65, 65, 65, 65, 65, 65, 51,
832 49, 3, 58, 59, 3, 56, 47, 4, 47, 47,
833 51, 51, 48, 28, 45, 65, 51, 49, 46, 3,
834 4, 13, 14, 47, 57, 3, 64, 64, 65, 65,
835 22, 46, 3, 56, 46, 46, 46, 46, 48, 17,
836 48, 65, 18, 60, 47, 63, 63, 63, 63, 64,
837 66, 3, 61, 62, 63, 47, 47, 47, 47, 51,
838 22, 48, 49, 47, 64, 65, 62
839 };
840
841 #define yyerrok (yyerrstatus = 0)
842 #define yyclearin (yychar = YYEMPTY)
843 #define YYEMPTY (-2)
844 #define YYEOF 0
845
846 #define YYACCEPT goto yyacceptlab
847 #define YYABORT goto yyabortlab
848 #define YYERROR goto yyerrorlab
849
850
851 /* Like YYERROR except do call yyerror. This remains here temporarily
852 to ease the transition to the new meaning of YYERROR, for GCC.
853 Once GCC version 2 has supplanted version 1, this can go. However,
854 YYFAIL appears to be in use. Nevertheless, it is formally deprecated
855 in Bison 2.4.2's NEWS entry, where a plan to phase it out is
856 discussed. */
857
858 #define YYFAIL goto yyerrlab
859 #if defined YYFAIL
860 /* This is here to suppress warnings from the GCC cpp's
861 -Wunused-macros. Normally we don't worry about that warning, but
862 some users do, and we want to make it easy for users to remove
863 YYFAIL uses, which will produce warnings from Bison 2.5. */
864 #endif
865
866 #define YYRECOVERING() (!!yyerrstatus)
867
868 #define YYBACKUP(Token, Value) \
869 do \
870 if (yychar == YYEMPTY && yylen == 1) \
871 { \
872 yychar = (Token); \
873 yylval = (Value); \
874 YYPOPSTACK (1); \
875 goto yybackup; \
876 } \
877 else \
878 { \
879 yyerror (YY_("syntax error: cannot back up")); \
880 YYERROR; \
881 } \
882 while (YYID (0))
883
884
885 #define YYTERROR 1
886 #define YYERRCODE 256
887
888
889 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
890 If N is 0, then set CURRENT to the empty location which ends
891 the previous symbol: RHS[0] (always defined). */
892
893 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
894 #ifndef YYLLOC_DEFAULT
895 # define YYLLOC_DEFAULT(Current, Rhs, N) \
896 do \
897 if (YYID (N)) \
898 { \
899 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
900 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
901 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
902 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
903 } \
904 else \
905 { \
906 (Current).first_line = (Current).last_line = \
907 YYRHSLOC (Rhs, 0).last_line; \
908 (Current).first_column = (Current).last_column = \
909 YYRHSLOC (Rhs, 0).last_column; \
910 } \
911 while (YYID (0))
912 #endif
913
914
915 /* This macro is provided for backward compatibility. */
916
917 #ifndef YY_LOCATION_PRINT
918 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
919 #endif
920
921
922 /* YYLEX -- calling `yylex' with the right arguments. */
923
924 #ifdef YYLEX_PARAM
925 # define YYLEX yylex (YYLEX_PARAM)
926 #else
927 # define YYLEX yylex ()
928 #endif
929
930 /* Enable debugging if requested. */
931 #if YYDEBUG
932
933 # ifndef YYFPRINTF
934 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
935 # define YYFPRINTF fprintf
936 # endif
937
938 # define YYDPRINTF(Args) \
939 do { \
940 if (yydebug) \
941 YYFPRINTF Args; \
942 } while (YYID (0))
943
944 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
945 do { \
946 if (yydebug) \
947 { \
948 YYFPRINTF (stderr, "%s ", Title); \
949 yy_symbol_print (stderr, \
950 Type, Value); \
951 YYFPRINTF (stderr, "\n"); \
952 } \
953 } while (YYID (0))
954
955
956 /*--------------------------------.
957 | Print this symbol on YYOUTPUT. |
958 `--------------------------------*/
959
960 /*ARGSUSED*/
961 #if (defined __STDC__ || defined __C99__FUNC__ \
962 || defined __cplusplus || defined _MSC_VER)
963 static void
yy_symbol_value_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep)964 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
965 #else
966 static void
967 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
968 FILE *yyoutput;
969 int yytype;
970 YYSTYPE const * const yyvaluep;
971 #endif
972 {
973 if (!yyvaluep)
974 return;
975 # ifdef YYPRINT
976 if (yytype < YYNTOKENS)
977 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
978 # else
979 YYUSE (yyoutput);
980 # endif
981 switch (yytype)
982 {
983 default:
984 break;
985 }
986 }
987
988
989 /*--------------------------------.
990 | Print this symbol on YYOUTPUT. |
991 `--------------------------------*/
992
993 #if (defined __STDC__ || defined __C99__FUNC__ \
994 || defined __cplusplus || defined _MSC_VER)
995 static void
yy_symbol_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep)996 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
997 #else
998 static void
999 yy_symbol_print (yyoutput, yytype, yyvaluep)
1000 FILE *yyoutput;
1001 int yytype;
1002 YYSTYPE const * const yyvaluep;
1003 #endif
1004 {
1005 if (yytype < YYNTOKENS)
1006 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1007 else
1008 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1009
1010 yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1011 YYFPRINTF (yyoutput, ")");
1012 }
1013
1014 /*------------------------------------------------------------------.
1015 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1016 | TOP (included). |
1017 `------------------------------------------------------------------*/
1018
1019 #if (defined __STDC__ || defined __C99__FUNC__ \
1020 || defined __cplusplus || defined _MSC_VER)
1021 static void
yy_stack_print(yytype_int16 * yybottom,yytype_int16 * yytop)1022 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1023 #else
1024 static void
1025 yy_stack_print (yybottom, yytop)
1026 yytype_int16 *yybottom;
1027 yytype_int16 *yytop;
1028 #endif
1029 {
1030 YYFPRINTF (stderr, "Stack now");
1031 for (; yybottom <= yytop; yybottom++)
1032 {
1033 int yybot = *yybottom;
1034 YYFPRINTF (stderr, " %d", yybot);
1035 }
1036 YYFPRINTF (stderr, "\n");
1037 }
1038
1039 # define YY_STACK_PRINT(Bottom, Top) \
1040 do { \
1041 if (yydebug) \
1042 yy_stack_print ((Bottom), (Top)); \
1043 } while (YYID (0))
1044
1045
1046 /*------------------------------------------------.
1047 | Report that the YYRULE is going to be reduced. |
1048 `------------------------------------------------*/
1049
1050 #if (defined __STDC__ || defined __C99__FUNC__ \
1051 || defined __cplusplus || defined _MSC_VER)
1052 static void
yy_reduce_print(YYSTYPE * yyvsp,int yyrule)1053 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1054 #else
1055 static void
1056 yy_reduce_print (yyvsp, yyrule)
1057 YYSTYPE *yyvsp;
1058 int yyrule;
1059 #endif
1060 {
1061 int yynrhs = yyr2[yyrule];
1062 int yyi;
1063 unsigned long int yylno = yyrline[yyrule];
1064 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1065 yyrule - 1, yylno);
1066 /* The symbols being reduced. */
1067 for (yyi = 0; yyi < yynrhs; yyi++)
1068 {
1069 YYFPRINTF (stderr, " $%d = ", yyi + 1);
1070 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1071 &(yyvsp[(yyi + 1) - (yynrhs)])
1072 );
1073 YYFPRINTF (stderr, "\n");
1074 }
1075 }
1076
1077 # define YY_REDUCE_PRINT(Rule) \
1078 do { \
1079 if (yydebug) \
1080 yy_reduce_print (yyvsp, Rule); \
1081 } while (YYID (0))
1082
1083 /* Nonzero means print parse trace. It is left uninitialized so that
1084 multiple parsers can coexist. */
1085 int yydebug;
1086 #else /* !YYDEBUG */
1087 # define YYDPRINTF(Args)
1088 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1089 # define YY_STACK_PRINT(Bottom, Top)
1090 # define YY_REDUCE_PRINT(Rule)
1091 #endif /* !YYDEBUG */
1092
1093
1094 /* YYINITDEPTH -- initial size of the parser's stacks. */
1095 #ifndef YYINITDEPTH
1096 # define YYINITDEPTH 200
1097 #endif
1098
1099 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1100 if the built-in stack extension method is used).
1101
1102 Do not make this value too large; the results are undefined if
1103 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1104 evaluated with infinite-precision integer arithmetic. */
1105
1106 #ifndef YYMAXDEPTH
1107 # define YYMAXDEPTH 10000
1108 #endif
1109
1110
1111 #if YYERROR_VERBOSE
1112
1113 # ifndef yystrlen
1114 # if defined __GLIBC__ && defined _STRING_H
1115 # define yystrlen strlen
1116 # else
1117 /* Return the length of YYSTR. */
1118 #if (defined __STDC__ || defined __C99__FUNC__ \
1119 || defined __cplusplus || defined _MSC_VER)
1120 static YYSIZE_T
yystrlen(const char * yystr)1121 yystrlen (const char *yystr)
1122 #else
1123 static YYSIZE_T
1124 yystrlen (yystr)
1125 const char *yystr;
1126 #endif
1127 {
1128 YYSIZE_T yylen;
1129 for (yylen = 0; yystr[yylen]; yylen++)
1130 continue;
1131 return yylen;
1132 }
1133 # endif
1134 # endif
1135
1136 # ifndef yystpcpy
1137 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1138 # define yystpcpy stpcpy
1139 # else
1140 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1141 YYDEST. */
1142 #if (defined __STDC__ || defined __C99__FUNC__ \
1143 || defined __cplusplus || defined _MSC_VER)
1144 static char *
yystpcpy(char * yydest,const char * yysrc)1145 yystpcpy (char *yydest, const char *yysrc)
1146 #else
1147 static char *
1148 yystpcpy (yydest, yysrc)
1149 char *yydest;
1150 const char *yysrc;
1151 #endif
1152 {
1153 char *yyd = yydest;
1154 const char *yys = yysrc;
1155
1156 while ((*yyd++ = *yys++) != '\0')
1157 continue;
1158
1159 return yyd - 1;
1160 }
1161 # endif
1162 # endif
1163
1164 # ifndef yytnamerr
1165 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1166 quotes and backslashes, so that it's suitable for yyerror. The
1167 heuristic is that double-quoting is unnecessary unless the string
1168 contains an apostrophe, a comma, or backslash (other than
1169 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1170 null, do not copy; instead, return the length of what the result
1171 would have been. */
1172 static YYSIZE_T
yytnamerr(char * yyres,const char * yystr)1173 yytnamerr (char *yyres, const char *yystr)
1174 {
1175 if (*yystr == '"')
1176 {
1177 YYSIZE_T yyn = 0;
1178 char const *yyp = yystr;
1179
1180 for (;;)
1181 switch (*++yyp)
1182 {
1183 case '\'':
1184 case ',':
1185 goto do_not_strip_quotes;
1186
1187 case '\\':
1188 if (*++yyp != '\\')
1189 goto do_not_strip_quotes;
1190 /* Fall through. */
1191 default:
1192 if (yyres)
1193 yyres[yyn] = *yyp;
1194 yyn++;
1195 break;
1196
1197 case '"':
1198 if (yyres)
1199 yyres[yyn] = '\0';
1200 return yyn;
1201 }
1202 do_not_strip_quotes: ;
1203 }
1204
1205 if (! yyres)
1206 return yystrlen (yystr);
1207
1208 return yystpcpy (yyres, yystr) - yyres;
1209 }
1210 # endif
1211
1212 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1213 about the unexpected token YYTOKEN for the state stack whose top is
1214 YYSSP.
1215
1216 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1217 not large enough to hold the message. In that case, also set
1218 *YYMSG_ALLOC to the required number of bytes. Return 2 if the
1219 required number of bytes is too large to store. */
1220 static int
yysyntax_error(YYSIZE_T * yymsg_alloc,char ** yymsg,yytype_int16 * yyssp,int yytoken)1221 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1222 yytype_int16 *yyssp, int yytoken)
1223 {
1224 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
1225 YYSIZE_T yysize = yysize0;
1226 YYSIZE_T yysize1;
1227 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1228 /* Internationalized format string. */
1229 const char *yyformat = 0;
1230 /* Arguments of yyformat. */
1231 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1232 /* Number of reported tokens (one for the "unexpected", one per
1233 "expected"). */
1234 int yycount = 0;
1235
1236 /* There are many possibilities here to consider:
1237 - Assume YYFAIL is not used. It's too flawed to consider. See
1238 <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
1239 for details. YYERROR is fine as it does not invoke this
1240 function.
1241 - If this state is a consistent state with a default action, then
1242 the only way this function was invoked is if the default action
1243 is an error action. In that case, don't check for expected
1244 tokens because there are none.
1245 - The only way there can be no lookahead present (in yychar) is if
1246 this state is a consistent state with a default action. Thus,
1247 detecting the absence of a lookahead is sufficient to determine
1248 that there is no unexpected or expected token to report. In that
1249 case, just report a simple "syntax error".
1250 - Don't assume there isn't a lookahead just because this state is a
1251 consistent state with a default action. There might have been a
1252 previous inconsistent state, consistent state with a non-default
1253 action, or user semantic action that manipulated yychar.
1254 - Of course, the expected token list depends on states to have
1255 correct lookahead information, and it depends on the parser not
1256 to perform extra reductions after fetching a lookahead from the
1257 scanner and before detecting a syntax error. Thus, state merging
1258 (from LALR or IELR) and default reductions corrupt the expected
1259 token list. However, the list is correct for canonical LR with
1260 one exception: it will still contain any token that will not be
1261 accepted due to an error action in a later state.
1262 */
1263 if (yytoken != YYEMPTY)
1264 {
1265 int yyn = yypact[*yyssp];
1266 yyarg[yycount++] = yytname[yytoken];
1267 if (!yypact_value_is_default (yyn))
1268 {
1269 /* Start YYX at -YYN if negative to avoid negative indexes in
1270 YYCHECK. In other words, skip the first -YYN actions for
1271 this state because they are default actions. */
1272 int yyxbegin = yyn < 0 ? -yyn : 0;
1273 /* Stay within bounds of both yycheck and yytname. */
1274 int yychecklim = YYLAST - yyn + 1;
1275 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1276 int yyx;
1277
1278 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1279 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1280 && !yytable_value_is_error (yytable[yyx + yyn]))
1281 {
1282 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1283 {
1284 yycount = 1;
1285 yysize = yysize0;
1286 break;
1287 }
1288 yyarg[yycount++] = yytname[yyx];
1289 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1290 if (! (yysize <= yysize1
1291 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1292 return 2;
1293 yysize = yysize1;
1294 }
1295 }
1296 }
1297
1298 switch (yycount)
1299 {
1300 # define YYCASE_(N, S) \
1301 case N: \
1302 yyformat = S; \
1303 break
1304 YYCASE_(0, YY_("syntax error"));
1305 YYCASE_(1, YY_("syntax error, unexpected %s"));
1306 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1307 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1308 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1309 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1310 # undef YYCASE_
1311 }
1312
1313 yysize1 = yysize + yystrlen (yyformat);
1314 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1315 return 2;
1316 yysize = yysize1;
1317
1318 if (*yymsg_alloc < yysize)
1319 {
1320 *yymsg_alloc = 2 * yysize;
1321 if (! (yysize <= *yymsg_alloc
1322 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1323 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1324 return 1;
1325 }
1326
1327 /* Avoid sprintf, as that infringes on the user's name space.
1328 Don't have undefined behavior even if the translation
1329 produced a string with the wrong number of "%s"s. */
1330 {
1331 char *yyp = *yymsg;
1332 int yyi = 0;
1333 while ((*yyp = *yyformat) != '\0')
1334 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1335 {
1336 yyp += yytnamerr (yyp, yyarg[yyi++]);
1337 yyformat += 2;
1338 }
1339 else
1340 {
1341 yyp++;
1342 yyformat++;
1343 }
1344 }
1345 return 0;
1346 }
1347 #endif /* YYERROR_VERBOSE */
1348
1349 /*-----------------------------------------------.
1350 | Release the memory associated to this symbol. |
1351 `-----------------------------------------------*/
1352
1353 /*ARGSUSED*/
1354 #if (defined __STDC__ || defined __C99__FUNC__ \
1355 || defined __cplusplus || defined _MSC_VER)
1356 static void
yydestruct(const char * yymsg,int yytype,YYSTYPE * yyvaluep)1357 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1358 #else
1359 static void
1360 yydestruct (yymsg, yytype, yyvaluep)
1361 const char *yymsg;
1362 int yytype;
1363 YYSTYPE *yyvaluep;
1364 #endif
1365 {
1366 YYUSE (yyvaluep);
1367
1368 if (!yymsg)
1369 yymsg = "Deleting";
1370 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1371
1372 switch (yytype)
1373 {
1374
1375 default:
1376 break;
1377 }
1378 }
1379
1380
1381 /* Prevent warnings from -Wmissing-prototypes. */
1382 #ifdef YYPARSE_PARAM
1383 #if defined __STDC__ || defined __cplusplus
1384 int yyparse (void *YYPARSE_PARAM);
1385 #else
1386 int yyparse ();
1387 #endif
1388 #else /* ! YYPARSE_PARAM */
1389 #if defined __STDC__ || defined __cplusplus
1390 int yyparse (void);
1391 #else
1392 int yyparse ();
1393 #endif
1394 #endif /* ! YYPARSE_PARAM */
1395
1396
1397 /* The lookahead symbol. */
1398 int yychar;
1399
1400 /* The semantic value of the lookahead symbol. */
1401 YYSTYPE yylval;
1402
1403 /* Number of syntax errors so far. */
1404 int yynerrs;
1405
1406
1407 /*----------.
1408 | yyparse. |
1409 `----------*/
1410
1411 #ifdef YYPARSE_PARAM
1412 #if (defined __STDC__ || defined __C99__FUNC__ \
1413 || defined __cplusplus || defined _MSC_VER)
1414 int
yyparse(void * YYPARSE_PARAM)1415 yyparse (void *YYPARSE_PARAM)
1416 #else
1417 int
1418 yyparse (YYPARSE_PARAM)
1419 void *YYPARSE_PARAM;
1420 #endif
1421 #else /* ! YYPARSE_PARAM */
1422 #if (defined __STDC__ || defined __C99__FUNC__ \
1423 || defined __cplusplus || defined _MSC_VER)
1424 int
1425 yyparse (void)
1426 #else
1427 int
1428 yyparse ()
1429
1430 #endif
1431 #endif
1432 {
1433 int yystate;
1434 /* Number of tokens to shift before error messages enabled. */
1435 int yyerrstatus;
1436
1437 /* The stacks and their tools:
1438 `yyss': related to states.
1439 `yyvs': related to semantic values.
1440
1441 Refer to the stacks thru separate pointers, to allow yyoverflow
1442 to reallocate them elsewhere. */
1443
1444 /* The state stack. */
1445 yytype_int16 yyssa[YYINITDEPTH];
1446 yytype_int16 *yyss;
1447 yytype_int16 *yyssp;
1448
1449 /* The semantic value stack. */
1450 YYSTYPE yyvsa[YYINITDEPTH];
1451 YYSTYPE *yyvs;
1452 YYSTYPE *yyvsp;
1453
1454 YYSIZE_T yystacksize;
1455
1456 int yyn;
1457 int yyresult;
1458 /* Lookahead token as an internal (translated) token number. */
1459 int yytoken;
1460 /* The variables used to return semantic value and location from the
1461 action routines. */
1462 YYSTYPE yyval;
1463
1464 #if YYERROR_VERBOSE
1465 /* Buffer for error messages, and its allocated size. */
1466 char yymsgbuf[128];
1467 char *yymsg = yymsgbuf;
1468 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1469 #endif
1470
1471 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1472
1473 /* The number of symbols on the RHS of the reduced rule.
1474 Keep to zero when no symbol should be popped. */
1475 int yylen = 0;
1476
1477 yytoken = 0;
1478 yyss = yyssa;
1479 yyvs = yyvsa;
1480 yystacksize = YYINITDEPTH;
1481
1482 YYDPRINTF ((stderr, "Starting parse\n"));
1483
1484 yystate = 0;
1485 yyerrstatus = 0;
1486 yynerrs = 0;
1487 yychar = YYEMPTY; /* Cause a token to be read. */
1488
1489 /* Initialize stack pointers.
1490 Waste one element of value and location stack
1491 so that they stay on the same level as the state stack.
1492 The wasted elements are never initialized. */
1493 yyssp = yyss;
1494 yyvsp = yyvs;
1495
1496 goto yysetstate;
1497
1498 /*------------------------------------------------------------.
1499 | yynewstate -- Push a new state, which is found in yystate. |
1500 `------------------------------------------------------------*/
1501 yynewstate:
1502 /* In all cases, when you get here, the value and location stacks
1503 have just been pushed. So pushing a state here evens the stacks. */
1504 yyssp++;
1505
1506 yysetstate:
1507 *yyssp = yystate;
1508
1509 if (yyss + yystacksize - 1 <= yyssp)
1510 {
1511 /* Get the current used size of the three stacks, in elements. */
1512 YYSIZE_T yysize = yyssp - yyss + 1;
1513
1514 #ifdef yyoverflow
1515 {
1516 /* Give user a chance to reallocate the stack. Use copies of
1517 these so that the &'s don't force the real ones into
1518 memory. */
1519 YYSTYPE *yyvs1 = yyvs;
1520 yytype_int16 *yyss1 = yyss;
1521
1522 /* Each stack pointer address is followed by the size of the
1523 data in use in that stack, in bytes. This used to be a
1524 conditional around just the two extra args, but that might
1525 be undefined if yyoverflow is a macro. */
1526 yyoverflow (YY_("memory exhausted"),
1527 &yyss1, yysize * sizeof (*yyssp),
1528 &yyvs1, yysize * sizeof (*yyvsp),
1529 &yystacksize);
1530
1531 yyss = yyss1;
1532 yyvs = yyvs1;
1533 }
1534 #else /* no yyoverflow */
1535 # ifndef YYSTACK_RELOCATE
1536 goto yyexhaustedlab;
1537 # else
1538 /* Extend the stack our own way. */
1539 if (YYMAXDEPTH <= yystacksize)
1540 goto yyexhaustedlab;
1541 yystacksize *= 2;
1542 if (YYMAXDEPTH < yystacksize)
1543 yystacksize = YYMAXDEPTH;
1544
1545 {
1546 yytype_int16 *yyss1 = yyss;
1547 union yyalloc *yyptr =
1548 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1549 if (! yyptr)
1550 goto yyexhaustedlab;
1551 YYSTACK_RELOCATE (yyss_alloc, yyss);
1552 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1553 # undef YYSTACK_RELOCATE
1554 if (yyss1 != yyssa)
1555 YYSTACK_FREE (yyss1);
1556 }
1557 # endif
1558 #endif /* no yyoverflow */
1559
1560 yyssp = yyss + yysize - 1;
1561 yyvsp = yyvs + yysize - 1;
1562
1563 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1564 (unsigned long int) yystacksize));
1565
1566 if (yyss + yystacksize - 1 <= yyssp)
1567 YYABORT;
1568 }
1569
1570 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1571
1572 if (yystate == YYFINAL)
1573 YYACCEPT;
1574
1575 goto yybackup;
1576
1577 /*-----------.
1578 | yybackup. |
1579 `-----------*/
1580 yybackup:
1581
1582 /* Do appropriate processing given the current state. Read a
1583 lookahead token if we need one and don't already have one. */
1584
1585 /* First try to decide what to do without reference to lookahead token. */
1586 yyn = yypact[yystate];
1587 if (yypact_value_is_default (yyn))
1588 goto yydefault;
1589
1590 /* Not known => get a lookahead token if don't already have one. */
1591
1592 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1593 if (yychar == YYEMPTY)
1594 {
1595 YYDPRINTF ((stderr, "Reading a token: "));
1596 yychar = YYLEX;
1597 }
1598
1599 if (yychar <= YYEOF)
1600 {
1601 yychar = yytoken = YYEOF;
1602 YYDPRINTF ((stderr, "Now at end of input.\n"));
1603 }
1604 else
1605 {
1606 yytoken = YYTRANSLATE (yychar);
1607 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1608 }
1609
1610 /* If the proper action on seeing token YYTOKEN is to reduce or to
1611 detect an error, take that action. */
1612 yyn += yytoken;
1613 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1614 goto yydefault;
1615 yyn = yytable[yyn];
1616 if (yyn <= 0)
1617 {
1618 if (yytable_value_is_error (yyn))
1619 goto yyerrlab;
1620 yyn = -yyn;
1621 goto yyreduce;
1622 }
1623
1624 /* Count tokens shifted since error; after three, turn off error
1625 status. */
1626 if (yyerrstatus)
1627 yyerrstatus--;
1628
1629 /* Shift the lookahead token. */
1630 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1631
1632 /* Discard the shifted token. */
1633 yychar = YYEMPTY;
1634
1635 yystate = yyn;
1636 *++yyvsp = yylval;
1637
1638 goto yynewstate;
1639
1640
1641 /*-----------------------------------------------------------.
1642 | yydefault -- do the default action for the current state. |
1643 `-----------------------------------------------------------*/
1644 yydefault:
1645 yyn = yydefact[yystate];
1646 if (yyn == 0)
1647 goto yyerrlab;
1648 goto yyreduce;
1649
1650
1651 /*-----------------------------.
1652 | yyreduce -- Do a reduction. |
1653 `-----------------------------*/
1654 yyreduce:
1655 /* yyn is the number of a rule to reduce with. */
1656 yylen = yyr2[yyn];
1657
1658 /* If YYLEN is nonzero, implement the default value of the action:
1659 `$$ = $1'.
1660
1661 Otherwise, the following line sets YYVAL to garbage.
1662 This behavior is undocumented and Bison
1663 users should not rely upon it. Assigning to YYVAL
1664 unconditionally makes the parser a bit smaller, and it avoids a
1665 GCC warning that YYVAL may be used uninitialized. */
1666 yyval = yyvsp[1-yylen];
1667
1668
1669 YY_REDUCE_PRINT (yyn);
1670 switch (yyn)
1671 {
1672 case 4:
1673
1674 /* Line 1806 of yacc.c */
1675 #line 69 "gram.y"
1676 { start_stmts = (yyvsp[(3) - (4)].lst); }
1677 break;
1678
1679 case 5:
1680
1681 /* Line 1806 of yacc.c */
1682 #line 71 "gram.y"
1683 { startrules = (yyvsp[(3) - (4)].lst); }
1684 break;
1685
1686 case 6:
1687
1688 /* Line 1806 of yacc.c */
1689 #line 73 "gram.y"
1690 { namerules = (yyvsp[(3) - (4)].lst); }
1691 break;
1692
1693 case 7:
1694
1695 /* Line 1806 of yacc.c */
1696 #line 75 "gram.y"
1697 { define_state ((yyvsp[(2) - (5)].node), NULL, (yyvsp[(4) - (5)].lst)); }
1698 break;
1699
1700 case 8:
1701
1702 /* Line 1806 of yacc.c */
1703 #line 77 "gram.y"
1704 { define_state ((yyvsp[(2) - (7)].node), (yyvsp[(4) - (7)].node), (yyvsp[(6) - (7)].lst)); }
1705 break;
1706
1707 case 9:
1708
1709 /* Line 1806 of yacc.c */
1710 #line 78 "gram.y"
1711 { list_append (global_stmts, (yyvsp[(1) - (1)].stmt)); }
1712 break;
1713
1714 case 10:
1715
1716 /* Line 1806 of yacc.c */
1717 #line 81 "gram.y"
1718 { (yyval.lst) = list (); }
1719 break;
1720
1721 case 11:
1722
1723 /* Line 1806 of yacc.c */
1724 #line 83 "gram.y"
1725 { list_append ((yyvsp[(1) - (4)].lst), cons ((yyvsp[(2) - (4)].node), (yyvsp[(3) - (4)].node))); }
1726 break;
1727
1728 case 12:
1729
1730 /* Line 1806 of yacc.c */
1731 #line 86 "gram.y"
1732 { (yyval.lst) = list (); }
1733 break;
1734
1735 case 13:
1736
1737 /* Line 1806 of yacc.c */
1738 #line 87 "gram.y"
1739 { list_append ((yyvsp[(1) - (2)].lst), (yyvsp[(2) - (2)].cons)); }
1740 break;
1741
1742 case 14:
1743
1744 /* Line 1806 of yacc.c */
1745 #line 89 "gram.y"
1746 { (yyval.cons) = cons (RULE_BEGIN, (yyvsp[(3) - (4)].lst)); }
1747 break;
1748
1749 case 15:
1750
1751 /* Line 1806 of yacc.c */
1752 #line 90 "gram.y"
1753 { (yyval.cons) = cons (RULE_END, (yyvsp[(3) - (4)].lst)); }
1754 break;
1755
1756 case 16:
1757
1758 /* Line 1806 of yacc.c */
1759 #line 91 "gram.y"
1760 { (yyval.cons) = cons ((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].lst)); }
1761 break;
1762
1763 case 17:
1764
1765 /* Line 1806 of yacc.c */
1766 #line 92 "gram.y"
1767 { (yyval.cons) = cons ((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].lst)); }
1768 break;
1769
1770 case 18:
1771
1772 /* Line 1806 of yacc.c */
1773 #line 95 "gram.y"
1774 { (yyval.lst) = list (); }
1775 break;
1776
1777 case 19:
1778
1779 /* Line 1806 of yacc.c */
1780 #line 96 "gram.y"
1781 { (yyval.lst) = (yyvsp[(1) - (1)].lst); }
1782 break;
1783
1784 case 20:
1785
1786 /* Line 1806 of yacc.c */
1787 #line 99 "gram.y"
1788 { (yyval.lst) = list (); list_append ((yyval.lst), (yyvsp[(1) - (1)].node)); }
1789 break;
1790
1791 case 21:
1792
1793 /* Line 1806 of yacc.c */
1794 #line 100 "gram.y"
1795 { list_append ((yyvsp[(1) - (3)].lst), (yyvsp[(3) - (3)].node)); }
1796 break;
1797
1798 case 22:
1799
1800 /* Line 1806 of yacc.c */
1801 #line 103 "gram.y"
1802 { (yyval.lst) = list (); }
1803 break;
1804
1805 case 23:
1806
1807 /* Line 1806 of yacc.c */
1808 #line 104 "gram.y"
1809 { (yyval.lst) = (yyvsp[(2) - (3)].lst); }
1810 break;
1811
1812 case 24:
1813
1814 /* Line 1806 of yacc.c */
1815 #line 107 "gram.y"
1816 { (yyval.lst) = list (); list_append ((yyval.lst), (yyvsp[(1) - (1)].cons)); }
1817 break;
1818
1819 case 25:
1820
1821 /* Line 1806 of yacc.c */
1822 #line 108 "gram.y"
1823 { list_append ((yyvsp[(1) - (3)].lst), (yyvsp[(3) - (3)].cons)); }
1824 break;
1825
1826 case 26:
1827
1828 /* Line 1806 of yacc.c */
1829 #line 111 "gram.y"
1830 { (yyval.cons) = cons ((yyvsp[(1) - (1)].node), NULL); }
1831 break;
1832
1833 case 27:
1834
1835 /* Line 1806 of yacc.c */
1836 #line 112 "gram.y"
1837 { (yyval.cons) = cons ((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].expr)); }
1838 break;
1839
1840 case 28:
1841
1842 /* Line 1806 of yacc.c */
1843 #line 115 "gram.y"
1844 { (yyval.lst) = list (); }
1845 break;
1846
1847 case 29:
1848
1849 /* Line 1806 of yacc.c */
1850 #line 116 "gram.y"
1851 { list_append ((yyvsp[(1) - (2)].lst), (yyvsp[(2) - (2)].stmt)); }
1852 break;
1853
1854 case 30:
1855
1856 /* Line 1806 of yacc.c */
1857 #line 119 "gram.y"
1858 { (yyval.stmt) = mk_stmt (sRETURN, NULL, NULL,
1859 NULL, NULL); }
1860 break;
1861
1862 case 31:
1863
1864 /* Line 1806 of yacc.c */
1865 #line 121 "gram.y"
1866 { (yyval.stmt) = mk_stmt (sRETURN, (yyvsp[(2) - (3)].expr), NULL,
1867 NULL, NULL); }
1868 break;
1869
1870 case 32:
1871
1872 /* Line 1806 of yacc.c */
1873 #line 124 "gram.y"
1874 { (yyval.stmt) = mk_stmt (sDEFSUB, (yyvsp[(2) - (9)].node),
1875 cons (cons ((yyvsp[(4) - (9)].lst), (yyvsp[(7) - (9)].lst)),
1876 (yyvsp[(8) - (9)].lst)),
1877 NULL, NULL); }
1878 break;
1879
1880 case 33:
1881
1882 /* Line 1806 of yacc.c */
1883 #line 128 "gram.y"
1884 { (yyval.stmt) = mk_stmt (sBLOCK, (yyvsp[(2) - (3)].lst), NULL,
1885 NULL, NULL); }
1886 break;
1887
1888 case 34:
1889
1890 /* Line 1806 of yacc.c */
1891 #line 130 "gram.y"
1892 { (yyval.stmt) = mk_stmt (sIF, (yyvsp[(3) - (5)].expr), (yyvsp[(5) - (5)].stmt), NULL,
1893 NULL); }
1894 break;
1895
1896 case 35:
1897
1898 /* Line 1806 of yacc.c */
1899 #line 133 "gram.y"
1900 { (yyval.stmt) = mk_stmt (sIF, (yyvsp[(3) - (7)].expr), (yyvsp[(5) - (7)].stmt), (yyvsp[(7) - (7)].stmt),
1901 NULL); }
1902 break;
1903
1904 case 36:
1905
1906 /* Line 1806 of yacc.c */
1907 #line 135 "gram.y"
1908 { (yyval.stmt) = mk_stmt (sWHILE, (yyvsp[(3) - (5)].expr), (yyvsp[(5) - (5)].stmt),
1909 NULL, NULL); }
1910 break;
1911
1912 case 37:
1913
1914 /* Line 1806 of yacc.c */
1915 #line 138 "gram.y"
1916 { (yyval.stmt) = mk_stmt (sFOR, (yyvsp[(3) - (9)].expr), (yyvsp[(5) - (9)].expr), (yyvsp[(7) - (9)].expr),
1917 (yyvsp[(9) - (9)].stmt)); }
1918 break;
1919
1920 case 38:
1921
1922 /* Line 1806 of yacc.c */
1923 #line 140 "gram.y"
1924 { (yyval.stmt) = mk_stmt (sEXPR, (yyvsp[(1) - (2)].expr), NULL,
1925 NULL, NULL); }
1926 break;
1927
1928 case 39:
1929
1930 /* Line 1806 of yacc.c */
1931 #line 144 "gram.y"
1932 { (yyval.expr) = mk_expr (eSTRING, (yyvsp[(1) - (1)].node), NULL,
1933 NULL); }
1934 break;
1935
1936 case 40:
1937
1938 /* Line 1806 of yacc.c */
1939 #line 146 "gram.y"
1940 { (yyval.expr) = mk_expr (eREGEXP, (yyvsp[(1) - (1)].node), NULL,
1941 NULL); }
1942 break;
1943
1944 case 41:
1945
1946 /* Line 1806 of yacc.c */
1947 #line 148 "gram.y"
1948 { (yyval.expr) = mk_expr (eINTEGER, (yyvsp[(1) - (1)].node), NULL,
1949 NULL); }
1950 break;
1951
1952 case 42:
1953
1954 /* Line 1806 of yacc.c */
1955 #line 150 "gram.y"
1956 { (yyval.expr) = mk_expr (eREAL, (yyvsp[(1) - (1)].node), NULL,
1957 NULL); }
1958 break;
1959
1960 case 43:
1961
1962 /* Line 1806 of yacc.c */
1963 #line 152 "gram.y"
1964 { (yyval.expr) = mk_expr (eSYMBOL, (yyvsp[(1) - (1)].node), NULL,
1965 NULL); }
1966 break;
1967
1968 case 44:
1969
1970 /* Line 1806 of yacc.c */
1971 #line 154 "gram.y"
1972 { (yyval.expr) = mk_expr (eNOT, (yyvsp[(2) - (2)].expr), NULL,
1973 NULL); }
1974 break;
1975
1976 case 45:
1977
1978 /* Line 1806 of yacc.c */
1979 #line 156 "gram.y"
1980 { (yyval.expr) = mk_expr (eAND, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), NULL); }
1981 break;
1982
1983 case 46:
1984
1985 /* Line 1806 of yacc.c */
1986 #line 157 "gram.y"
1987 { (yyval.expr) = mk_expr (eOR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), NULL); }
1988 break;
1989
1990 case 47:
1991
1992 /* Line 1806 of yacc.c */
1993 #line 158 "gram.y"
1994 { (yyval.expr) = mk_expr (eFCALL, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].lst),
1995 NULL); }
1996 break;
1997
1998 case 48:
1999
2000 /* Line 1806 of yacc.c */
2001 #line 160 "gram.y"
2002 { (yyval.expr) = mk_expr (eASSIGN, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].expr),
2003 NULL); }
2004 break;
2005
2006 case 49:
2007
2008 /* Line 1806 of yacc.c */
2009 #line 162 "gram.y"
2010 { (yyval.expr) = mk_expr (eADDASSIGN, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].expr),
2011 NULL); }
2012 break;
2013
2014 case 50:
2015
2016 /* Line 1806 of yacc.c */
2017 #line 164 "gram.y"
2018 { (yyval.expr) = mk_expr (eSUBASSIGN, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].expr),
2019 NULL); }
2020 break;
2021
2022 case 51:
2023
2024 /* Line 1806 of yacc.c */
2025 #line 166 "gram.y"
2026 { (yyval.expr) = mk_expr (eMULASSIGN, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].expr),
2027 NULL); }
2028 break;
2029
2030 case 52:
2031
2032 /* Line 1806 of yacc.c */
2033 #line 168 "gram.y"
2034 { (yyval.expr) = mk_expr (eDIVASSIGN, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].expr),
2035 NULL); }
2036 break;
2037
2038 case 53:
2039
2040 /* Line 1806 of yacc.c */
2041 #line 170 "gram.y"
2042 { (yyval.expr) = mk_expr (ePOSTFIXADD, (yyvsp[(1) - (2)].node), NULL,
2043 NULL); }
2044 break;
2045
2046 case 54:
2047
2048 /* Line 1806 of yacc.c */
2049 #line 172 "gram.y"
2050 { (yyval.expr) = mk_expr (ePOSTFIXSUB, (yyvsp[(1) - (2)].node), NULL,
2051 NULL); }
2052 break;
2053
2054 case 55:
2055
2056 /* Line 1806 of yacc.c */
2057 #line 174 "gram.y"
2058 { (yyval.expr) = mk_expr (ePREFIXADD, (yyvsp[(2) - (2)].node), NULL,
2059 NULL); }
2060 break;
2061
2062 case 56:
2063
2064 /* Line 1806 of yacc.c */
2065 #line 176 "gram.y"
2066 { (yyval.expr) = mk_expr (ePREFIXSUB, (yyvsp[(2) - (2)].node), NULL,
2067 NULL); }
2068 break;
2069
2070 case 57:
2071
2072 /* Line 1806 of yacc.c */
2073 #line 178 "gram.y"
2074 { (yyval.expr) = mk_expr (eARRAYASSIGN, (yyvsp[(1) - (6)].expr), (yyvsp[(3) - (6)].expr),
2075 (yyvsp[(6) - (6)].expr)); }
2076 break;
2077
2078 case 58:
2079
2080 /* Line 1806 of yacc.c */
2081 #line 180 "gram.y"
2082 { (yyval.expr) = (yyvsp[(2) - (3)].expr); }
2083 break;
2084
2085 case 59:
2086
2087 /* Line 1806 of yacc.c */
2088 #line 181 "gram.y"
2089 { (yyval.expr) = mk_expr (eARRAYREF, (yyvsp[(1) - (4)].expr), (yyvsp[(3) - (4)].expr),
2090 NULL); }
2091 break;
2092
2093 case 60:
2094
2095 /* Line 1806 of yacc.c */
2096 #line 183 "gram.y"
2097 { (yyval.expr) = mk_expr (eQUESTCOLON, (yyvsp[(1) - (5)].expr), (yyvsp[(3) - (5)].expr),
2098 (yyvsp[(5) - (5)].expr)); }
2099 break;
2100
2101 case 61:
2102
2103 /* Line 1806 of yacc.c */
2104 #line 185 "gram.y"
2105 { (yyval.expr) = mk_expr (eMULT, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), NULL); }
2106 break;
2107
2108 case 62:
2109
2110 /* Line 1806 of yacc.c */
2111 #line 186 "gram.y"
2112 { (yyval.expr) = mk_expr (eDIV, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), NULL); }
2113 break;
2114
2115 case 63:
2116
2117 /* Line 1806 of yacc.c */
2118 #line 187 "gram.y"
2119 { (yyval.expr) = mk_expr (ePLUS, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), NULL); }
2120 break;
2121
2122 case 64:
2123
2124 /* Line 1806 of yacc.c */
2125 #line 188 "gram.y"
2126 { (yyval.expr) = mk_expr (eMINUS, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr),
2127 NULL); }
2128 break;
2129
2130 case 65:
2131
2132 /* Line 1806 of yacc.c */
2133 #line 190 "gram.y"
2134 { (yyval.expr) = mk_expr (eLT, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), NULL); }
2135 break;
2136
2137 case 66:
2138
2139 /* Line 1806 of yacc.c */
2140 #line 191 "gram.y"
2141 { (yyval.expr) = mk_expr (eGT, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), NULL); }
2142 break;
2143
2144 case 67:
2145
2146 /* Line 1806 of yacc.c */
2147 #line 192 "gram.y"
2148 { (yyval.expr) = mk_expr (eEQ, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), NULL); }
2149 break;
2150
2151 case 68:
2152
2153 /* Line 1806 of yacc.c */
2154 #line 193 "gram.y"
2155 { (yyval.expr) = mk_expr (eNE, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), NULL); }
2156 break;
2157
2158 case 69:
2159
2160 /* Line 1806 of yacc.c */
2161 #line 194 "gram.y"
2162 { (yyval.expr) = mk_expr (eGE, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), NULL); }
2163 break;
2164
2165 case 70:
2166
2167 /* Line 1806 of yacc.c */
2168 #line 195 "gram.y"
2169 { (yyval.expr) = mk_expr (eLE, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), NULL); }
2170 break;
2171
2172 case 71:
2173
2174 /* Line 1806 of yacc.c */
2175 #line 198 "gram.y"
2176 { (yyval.expr) = NULL; }
2177 break;
2178
2179 case 72:
2180
2181 /* Line 1806 of yacc.c */
2182 #line 199 "gram.y"
2183 { (yyval.expr) = (yyvsp[(1) - (1)].expr); }
2184 break;
2185
2186 case 73:
2187
2188 /* Line 1806 of yacc.c */
2189 #line 202 "gram.y"
2190 { (yyval.lst) = list (); }
2191 break;
2192
2193 case 74:
2194
2195 /* Line 1806 of yacc.c */
2196 #line 203 "gram.y"
2197 { (yyval.lst) = (yyvsp[(1) - (1)].lst); }
2198 break;
2199
2200 case 75:
2201
2202 /* Line 1806 of yacc.c */
2203 #line 206 "gram.y"
2204 { (yyval.lst) = list (); list_append ((yyval.lst), (yyvsp[(1) - (1)].expr)); }
2205 break;
2206
2207 case 76:
2208
2209 /* Line 1806 of yacc.c */
2210 #line 207 "gram.y"
2211 { list_append ((yyvsp[(1) - (3)].lst), (yyvsp[(3) - (3)].expr)); }
2212 break;
2213
2214
2215
2216 /* Line 1806 of yacc.c */
2217 #line 2218 "gram.c"
2218 default: break;
2219 }
2220 /* User semantic actions sometimes alter yychar, and that requires
2221 that yytoken be updated with the new translation. We take the
2222 approach of translating immediately before every use of yytoken.
2223 One alternative is translating here after every semantic action,
2224 but that translation would be missed if the semantic action invokes
2225 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
2226 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
2227 incorrect destructor might then be invoked immediately. In the
2228 case of YYERROR or YYBACKUP, subsequent parser actions might lead
2229 to an incorrect destructor call or verbose syntax error message
2230 before the lookahead is translated. */
2231 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
2232
2233 YYPOPSTACK (yylen);
2234 yylen = 0;
2235 YY_STACK_PRINT (yyss, yyssp);
2236
2237 *++yyvsp = yyval;
2238
2239 /* Now `shift' the result of the reduction. Determine what state
2240 that goes to, based on the state we popped back to and the rule
2241 number reduced by. */
2242
2243 yyn = yyr1[yyn];
2244
2245 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2246 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2247 yystate = yytable[yystate];
2248 else
2249 yystate = yydefgoto[yyn - YYNTOKENS];
2250
2251 goto yynewstate;
2252
2253
2254 /*------------------------------------.
2255 | yyerrlab -- here on detecting error |
2256 `------------------------------------*/
2257 yyerrlab:
2258 /* Make sure we have latest lookahead translation. See comments at
2259 user semantic actions for why this is necessary. */
2260 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
2261
2262 /* If not already recovering from an error, report this error. */
2263 if (!yyerrstatus)
2264 {
2265 ++yynerrs;
2266 #if ! YYERROR_VERBOSE
2267 yyerror (YY_("syntax error"));
2268 #else
2269 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
2270 yyssp, yytoken)
2271 {
2272 char const *yymsgp = YY_("syntax error");
2273 int yysyntax_error_status;
2274 yysyntax_error_status = YYSYNTAX_ERROR;
2275 if (yysyntax_error_status == 0)
2276 yymsgp = yymsg;
2277 else if (yysyntax_error_status == 1)
2278 {
2279 if (yymsg != yymsgbuf)
2280 YYSTACK_FREE (yymsg);
2281 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
2282 if (!yymsg)
2283 {
2284 yymsg = yymsgbuf;
2285 yymsg_alloc = sizeof yymsgbuf;
2286 yysyntax_error_status = 2;
2287 }
2288 else
2289 {
2290 yysyntax_error_status = YYSYNTAX_ERROR;
2291 yymsgp = yymsg;
2292 }
2293 }
2294 yyerror (yymsgp);
2295 if (yysyntax_error_status == 2)
2296 goto yyexhaustedlab;
2297 }
2298 # undef YYSYNTAX_ERROR
2299 #endif
2300 }
2301
2302
2303
2304 if (yyerrstatus == 3)
2305 {
2306 /* If just tried and failed to reuse lookahead token after an
2307 error, discard it. */
2308
2309 if (yychar <= YYEOF)
2310 {
2311 /* Return failure if at end of input. */
2312 if (yychar == YYEOF)
2313 YYABORT;
2314 }
2315 else
2316 {
2317 yydestruct ("Error: discarding",
2318 yytoken, &yylval);
2319 yychar = YYEMPTY;
2320 }
2321 }
2322
2323 /* Else will try to reuse lookahead token after shifting the error
2324 token. */
2325 goto yyerrlab1;
2326
2327
2328 /*---------------------------------------------------.
2329 | yyerrorlab -- error raised explicitly by YYERROR. |
2330 `---------------------------------------------------*/
2331 yyerrorlab:
2332
2333 /* Pacify compilers like GCC when the user code never invokes
2334 YYERROR and the label yyerrorlab therefore never appears in user
2335 code. */
2336 if (/*CONSTCOND*/ 0)
2337 goto yyerrorlab;
2338
2339 /* Do not reclaim the symbols of the rule which action triggered
2340 this YYERROR. */
2341 YYPOPSTACK (yylen);
2342 yylen = 0;
2343 YY_STACK_PRINT (yyss, yyssp);
2344 yystate = *yyssp;
2345 goto yyerrlab1;
2346
2347
2348 /*-------------------------------------------------------------.
2349 | yyerrlab1 -- common code for both syntax error and YYERROR. |
2350 `-------------------------------------------------------------*/
2351 yyerrlab1:
2352 yyerrstatus = 3; /* Each real token shifted decrements this. */
2353
2354 for (;;)
2355 {
2356 yyn = yypact[yystate];
2357 if (!yypact_value_is_default (yyn))
2358 {
2359 yyn += YYTERROR;
2360 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
2361 {
2362 yyn = yytable[yyn];
2363 if (0 < yyn)
2364 break;
2365 }
2366 }
2367
2368 /* Pop the current state because it cannot handle the error token. */
2369 if (yyssp == yyss)
2370 YYABORT;
2371
2372
2373 yydestruct ("Error: popping",
2374 yystos[yystate], yyvsp);
2375 YYPOPSTACK (1);
2376 yystate = *yyssp;
2377 YY_STACK_PRINT (yyss, yyssp);
2378 }
2379
2380 *++yyvsp = yylval;
2381
2382
2383 /* Shift the error token. */
2384 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
2385
2386 yystate = yyn;
2387 goto yynewstate;
2388
2389
2390 /*-------------------------------------.
2391 | yyacceptlab -- YYACCEPT comes here. |
2392 `-------------------------------------*/
2393 yyacceptlab:
2394 yyresult = 0;
2395 goto yyreturn;
2396
2397 /*-----------------------------------.
2398 | yyabortlab -- YYABORT comes here. |
2399 `-----------------------------------*/
2400 yyabortlab:
2401 yyresult = 1;
2402 goto yyreturn;
2403
2404 #if !defined(yyoverflow) || YYERROR_VERBOSE
2405 /*-------------------------------------------------.
2406 | yyexhaustedlab -- memory exhaustion comes here. |
2407 `-------------------------------------------------*/
2408 yyexhaustedlab:
2409 yyerror (YY_("memory exhausted"));
2410 yyresult = 2;
2411 /* Fall through. */
2412 #endif
2413
2414 yyreturn:
2415 if (yychar != YYEMPTY)
2416 {
2417 /* Make sure we have latest lookahead translation. See comments at
2418 user semantic actions for why this is necessary. */
2419 yytoken = YYTRANSLATE (yychar);
2420 yydestruct ("Cleanup: discarding lookahead",
2421 yytoken, &yylval);
2422 }
2423 /* Do not reclaim the symbols of the rule which action triggered
2424 this YYABORT or YYACCEPT. */
2425 YYPOPSTACK (yylen);
2426 YY_STACK_PRINT (yyss, yyssp);
2427 while (yyssp != yyss)
2428 {
2429 yydestruct ("Cleanup: popping",
2430 yystos[*yyssp], yyvsp);
2431 YYPOPSTACK (1);
2432 }
2433 #ifndef yyoverflow
2434 if (yyss != yyssa)
2435 YYSTACK_FREE (yyss);
2436 #endif
2437 #if YYERROR_VERBOSE
2438 if (yymsg != yymsgbuf)
2439 YYSTACK_FREE (yymsg);
2440 #endif
2441 /* Make sure YYID is used. */
2442 return YYID (yyresult);
2443 }
2444
2445
2446
2447 /* Line 2067 of yacc.c */
2448 #line 210 "gram.y"
2449
2450
2451 void
yyerror(msg)2452 yyerror (msg)
2453 char *msg;
2454 {
2455 fprintf (stderr, "%s:%d: %s\n", yyin_name, linenum, msg);
2456 }
2457
2458