projects / platform / upstream / groff.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Imported Upstream version 1.22.4
[platform/upstream/groff.git] / src / preproc / eqn / eqn.cpp
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
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
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
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
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
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 *
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
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
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
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
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
Domain: System / Base;