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