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