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