Bug Summary

File:laygram.c
Location:line 1183, column 5
Description:Value stored to 'yymsg' is never read

Annotated Source Code

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