chiark / gitweb /
~mdw / mup / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Import upstream version 5.3.
[mup] / mup / mup / ifgram.c
CommitLineData
69695f33
MW		 1/* A Bison parser, made from ifgram.y, by GNU bison 1.75. */
2
3/* Skeleton parser for Yacc-like parsing with Bison,
4 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
20
21/* As a special exception, when this file is copied by Bison into a
22 Bison output file, you may use that output file without restriction.
23 This special exception was added by the Free Software Foundation
24 in version 1.24 of Bison. */
25
26/* Written by Richard Stallman by simplifying the original so called
27 ``semantic'' parser. */
28
29/* All symbols defined below should begin with yy or YY, to avoid
30 infringing on user name space. This should be done even for local
31 variables, as they might otherwise be expanded by user macros.
32 There are some unavoidable exceptions within include files to
33 define necessary library symbols; they are noted "INFRINGES ON
34 USER NAME SPACE" below. */
35
36/* Identify Bison output. */
37#define YYBISON 1
38
39/* Pure parsers. */
40#define YYPURE 0
41
42/* Using locations. */
43#define YYLSP_NEEDED 0
44
45/* If NAME_PREFIX is specified substitute the variables and functions
46 names. */
47#define yyparse ifparse
48#define yylex iflex
49#define yyerror iferror
50#define yylval iflval
51#define yychar ifchar
52#define yydebug ifdebug
53#define yynerrs ifnerrs
54
55
56/* Tokens. */
57#ifndef YYTOKENTYPE
58# define YYTOKENTYPE
59 /* Put the tokens into the symbol table, so that GDB and other debuggers
60 know about them. */
61 enum yytokentype {
62 ICT_AND = 258,
63 ICT_BITAND = 259,
64 ICT_BITCOMPLEMENT = 260,
65 ICT_BITOR = 261,
66 ICT_BITXOR = 262,
67 ICT_COLON = 263,
68 ICT_DIVIDE = 264,
69 ICT_END = 265,
70 ICT_ERROR = 266,
71 ICT_EQ = 267,
72 ICT_FALSE = 268,
73 ICT_GT = 269,
74 ICT_GE = 270,
75 ICT_LPAREN = 271,
76 ICT_LE = 272,
77 ICT_LT = 273,
78 ICT_MINUS = 274,
79 ICT_MOD = 275,
80 ICT_MULT = 276,
81 ICT_NE = 277,
82 ICT_NOT = 278,
83 ICT_OR = 279,
84 ICT_PLUS = 280,
85 ICT_QUESTION = 281,
86 ICT_RPAREN = 282,
87 ICT_SHLEFT = 283,
88 ICT_SHRIGHT = 284,
89 ICT_TRUE = 285,
90 ICT_VALUE = 286
91 };
92#endif
93#define ICT_AND 258
94#define ICT_BITAND 259
95#define ICT_BITCOMPLEMENT 260
96#define ICT_BITOR 261
97#define ICT_BITXOR 262
98#define ICT_COLON 263
99#define ICT_DIVIDE 264
100#define ICT_END 265
101#define ICT_ERROR 266
102#define ICT_EQ 267
103#define ICT_FALSE 268
104#define ICT_GT 269
105#define ICT_GE 270
106#define ICT_LPAREN 271
107#define ICT_LE 272
108#define ICT_LT 273
109#define ICT_MINUS 274
110#define ICT_MOD 275
111#define ICT_MULT 276
112#define ICT_NE 277
113#define ICT_NOT 278
114#define ICT_OR 279
115#define ICT_PLUS 280
116#define ICT_QUESTION 281
117#define ICT_RPAREN 282
118#define ICT_SHLEFT 283
119#define ICT_SHRIGHT 284
120#define ICT_TRUE 285
121#define ICT_VALUE 286
122
123
124
125
126/* Copy the first part of user declarations. */
127#line 2 "ifgram.y"
128
129/* Copyright 2005 by Arkkra Enterprises */
130/* All rights reserved. */
131
132/* This is a "mini-parser" that handles "if" clauses.
133 * It uses a buffer containing a compressed form of the user's input.
134 * The compressed format is described in lex.c above add_ifclause().
135 * This tries to follow the ANSI C preprocessor rules as much as is reasonable.
136 * It uses C operator precedences and associativity.
137 * We do use 32-bit ints rather than longs to try to avoid any
138 * incompatibilities if someone creates a Mup file on a 32-bit machine
139 * and then tries to run it on 64-bit or vice-versa.
140 */
141
142#include "defines.h"
143#include "globals.h"
144
145#define YYDEBUG 1
146
147
148
149/* Enabling traces. */
150#ifndef YYDEBUG
151# define YYDEBUG 0
152#endif
153
154/* Enabling verbose error messages. */
155#ifdef YYERROR_VERBOSE
156# undef YYERROR_VERBOSE
157# define YYERROR_VERBOSE 1
158#else
159# define YYERROR_VERBOSE 0
160#endif
161
162#ifndef YYSTYPE
163typedef int yystype;
164# define YYSTYPE yystype
165# define YYSTYPE_IS_TRIVIAL 1
166#endif
167
168#ifndef YYLTYPE
169typedef struct yyltype
170{
171 int first_line;
172 int first_column;
173 int last_line;
174 int last_column;
175} yyltype;
176# define YYLTYPE yyltype
177# define YYLTYPE_IS_TRIVIAL 1
178#endif
179
180/* Copy the second part of user declarations. */
181
182
183/* Line 213 of /usr/share/bison/yacc.c. */
184#line 185 "ifgram.tab.c"
185
186#if ! defined (yyoverflow) || YYERROR_VERBOSE
187
188/* The parser invokes alloca or malloc; define the necessary symbols. */
189
190# if YYSTACK_USE_ALLOCA
191# define YYSTACK_ALLOC alloca
192# else
193# ifndef YYSTACK_USE_ALLOCA
194# if defined (alloca) || defined (_ALLOCA_H)
195# define YYSTACK_ALLOC alloca
196# else
197# ifdef __GNUC__
198# define YYSTACK_ALLOC __builtin_alloca
199# endif
200# endif
201# endif
202# endif
203
204# ifdef YYSTACK_ALLOC
205 /* Pacify GCC's `empty if-body' warning. */
206# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
207# else
208# if defined (__STDC__) || defined (__cplusplus)
209# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
210# define YYSIZE_T size_t
211# endif
212# define YYSTACK_ALLOC malloc
213# define YYSTACK_FREE free
214# endif
215#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
216
217
218#if (! defined (yyoverflow) \
219 && (! defined (__cplusplus) \
220 || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
221
222/* A type that is properly aligned for any stack member. */
223union yyalloc
224{
225 short yyss;
226 YYSTYPE yyvs;
227 };
228
229/* The size of the maximum gap between one aligned stack and the next. */
230# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
231
232/* The size of an array large to enough to hold all stacks, each with
233 N elements. */
234# define YYSTACK_BYTES(N) \
235 ((N) * (sizeof (short) + sizeof (YYSTYPE)) \
236 + YYSTACK_GAP_MAX)
237
238/* Copy COUNT objects from FROM to TO. The source and destination do
239 not overlap. */
240# ifndef YYCOPY
241# if 1 < __GNUC__
242# define YYCOPY(To, From, Count) \
243 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
244# else
245# define YYCOPY(To, From, Count) \
246 do \
247 { \
248 register YYSIZE_T yyi; \
249 for (yyi = 0; yyi < (Count); yyi++) \
250 (To)[yyi] = (From)[yyi]; \
251 } \
252 while (0)
253# endif
254# endif
255
256/* Relocate STACK from its old location to the new one. The
257 local variables YYSIZE and YYSTACKSIZE give the old and new number of
258 elements in the stack, and YYPTR gives the new location of the
259 stack. Advance YYPTR to a properly aligned location for the next
260 stack. */
261# define YYSTACK_RELOCATE(Stack) \
262 do \
263 { \
264 YYSIZE_T yynewbytes; \
265 YYCOPY (&yyptr->Stack, Stack, yysize); \
266 Stack = &yyptr->Stack; \
267 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX; \
268 yyptr += yynewbytes / sizeof (*yyptr); \
269 } \
270 while (0)
271
272#endif
273
274#if defined (__STDC__) || defined (__cplusplus)
275 typedef signed char yysigned_char;
276#else
277 typedef short yysigned_char;
278#endif
279
280/* YYFINAL -- State number of the termination state. */
281#define YYFINAL 19
282#define YYLAST 327
283
284/* YYNTOKENS -- Number of terminals. */
285#define YYNTOKENS 32
286/* YYNNTS -- Number of nonterminals. */
287#define YYNNTS 4
288/* YYNRULES -- Number of rules. */
289#define YYNRULES 32
290/* YYNRULES -- Number of states. */
291#define YYNSTATES 62
292
293/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
294#define YYUNDEFTOK 2
295#define YYMAXUTOK 286
296
297#define YYTRANSLATE(X) \
298 ((unsigned)(X) <= YYMAXUTOK ? yytranslate[X] : YYUNDEFTOK)
299
300/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
301static const unsigned char yytranslate[] =
302{
303 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
304 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
305 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
306 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
307 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
308 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
309 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
310 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
311 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
312 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
313 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
314 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
315 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
316 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
317 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
318 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
319 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
320 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
321 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
322 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
323 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
324 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
325 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
326 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
327 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
328 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
329 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
330 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
331 25, 26, 27, 28, 29, 30, 31
332};
333
334#if YYDEBUG
335/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
336 YYRHS. */
337static const unsigned char yyprhs[] =
338{
339 0, 0, 3, 6, 8, 10, 14, 17, 20, 23,
340 26, 30, 34, 38, 42, 46, 50, 54, 58, 62,
341 66, 70, 74, 78, 82, 86, 90, 94, 98, 104,
342 106, 108, 110
343};
344
345/* YYRHS -- A `-1'-separated list of the rules' RHS. */
346static const yysigned_char yyrhs[] =
347{
348 33, 0, -1, 34, 10, -1, 11, -1, 1, -1,
349 16, 34, 27, -1, 23, 34, -1, 5, 34, -1,
350 19, 34, -1, 25, 34, -1, 34, 21, 34, -1,
351 34, 9, 34, -1, 34, 20, 34, -1, 34, 25,
352 34, -1, 34, 19, 34, -1, 34, 28, 34, -1,
353 34, 29, 34, -1, 34, 18, 34, -1, 34, 17,
354 34, -1, 34, 14, 34, -1, 34, 15, 34, -1,
355 34, 12, 34, -1, 34, 22, 34, -1, 34, 4,
356 34, -1, 34, 7, 34, -1, 34, 6, 34, -1,
357 34, 24, 34, -1, 34, 3, 34, -1, 34, 26,
358 34, 8, 34, -1, 31, -1, 35, -1, 30, -1,
359 13, -1
360};
361
362/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
363static const unsigned short yyrline[] =
364{
365 0, 68, 68, 73, 79, 87, 92, 98, 104, 111,
366 118, 124, 138, 150, 156, 162, 168, 174, 180, 186,
367 192, 198, 204, 210, 216, 222, 228, 234, 240, 246,
368 252, 259, 264
369};
370#endif
371
372#if YYDEBUG || YYERROR_VERBOSE
373/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
374 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
375static const char *const yytname[] =
376{
377 "$end", "error", "$undefined", "ICT_AND", "ICT_BITAND",
378 "ICT_BITCOMPLEMENT", "ICT_BITOR", "ICT_BITXOR", "ICT_COLON",
379 "ICT_DIVIDE", "ICT_END", "ICT_ERROR", "ICT_EQ", "ICT_FALSE", "ICT_GT",
380 "ICT_GE", "ICT_LPAREN", "ICT_LE", "ICT_LT", "ICT_MINUS", "ICT_MOD",
381 "ICT_MULT", "ICT_NE", "ICT_NOT", "ICT_OR", "ICT_PLUS", "ICT_QUESTION",
382 "ICT_RPAREN", "ICT_SHLEFT", "ICT_SHRIGHT", "ICT_TRUE", "ICT_VALUE",
383 "$accept", "ifclause", "expr", "boolval", 0
384};
385#endif
386
387# ifdef YYPRINT
388/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
389 token YYLEX-NUM. */
390static const unsigned short yytoknum[] =
391{
392 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
393 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
394 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
395 285, 286
396};
397# endif
398
399/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
400static const unsigned char yyr1[] =
401{
402 0, 32, 33, 33, 33, 34, 34, 34, 34, 34,
403 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
404 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
405 34, 35, 35
406};
407
408/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
409static const unsigned char yyr2[] =
410{
411 0, 2, 2, 1, 1, 3, 2, 2, 2, 2,
412 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
413 3, 3, 3, 3, 3, 3, 3, 3, 5, 1,
414 1, 1, 1
415};
416
417/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
418 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
419 means the default is an error. */
420static const unsigned char yydefact[] =
421{
422 0, 4, 0, 3, 32, 0, 0, 0, 0, 31,
423 29, 0, 0, 30, 7, 0, 8, 6, 9, 1,
424 0, 0, 0, 0, 0, 2, 0, 0, 0, 0,
425 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
426 5, 27, 23, 25, 24, 11, 21, 19, 20, 18,
427 17, 14, 12, 10, 22, 26, 13, 0, 15, 16,
428 0, 28
429};
430
431/* YYDEFGOTO[NTERM-NUM]. */
432static const yysigned_char yydefgoto[] =
433{
434 -1, 11, 12, 13
435};
436
437/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
438 STATE-NUM. */
439#define YYPACT_NINF -9
440static const short yypact[] =
441{
442 37, -9, 185, -9, -9, 185, 185, 185, 185, -9,
443 -9, 2, 66, -9, -9, 93, -9, -9, -9, -9,
444 185, 185, 185, 185, 185, -9, 185, 185, 185, 185,
445 185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
446 -9, 205, 268, 228, 250, -9, 285, 298, 298, 298,
447 298, 31, -9, -9, 285, 174, 31, 120, -8, -8,
448 185, 147
449};
450
451/* YYPGOTO[NTERM-NUM]. */
452static const yysigned_char yypgoto[] =
453{
454 -9, -9, -2, -9
455};
456
457/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
458 positive, shift that token. If negative, reduce the rule which
459 number is the opposite. If zero, do what YYDEFACT says.
460 If YYTABLE_NINF, parse error. */
461#define YYTABLE_NINF -1
462static const unsigned char yytable[] =
463{
464 14, 24, 19, 15, 16, 17, 18, 0, 0, 0,
465 0, 31, 32, 33, 0, 0, 0, 36, 41, 42,
466 43, 44, 45, 0, 46, 47, 48, 49, 50, 51,
467 52, 53, 54, 55, 56, 57, 58, 59, 1, 0,
468 24, 0, 2, 0, 0, 0, 0, 0, 3, 0,
469 4, 32, 33, 5, 0, 0, 6, 0, 61, 0,
470 7, 0, 8, 0, 0, 0, 0, 9, 10, 20,
471 21, 0, 22, 23, 0, 24, 25, 0, 26, 0,
472 27, 28, 0, 29, 30, 31, 32, 33, 34, 0,
473 35, 36, 37, 0, 38, 39, 20, 21, 0, 22,
474 23, 0, 24, 0, 0, 26, 0, 27, 28, 0,
475 29, 30, 31, 32, 33, 34, 0, 35, 36, 37,
476 40, 38, 39, 20, 21, 0, 22, 23, 60, 24,
477 0, 0, 26, 0, 27, 28, 0, 29, 30, 31,
478 32, 33, 34, 0, 35, 36, 37, 0, 38, 39,
479 20, 21, 0, 22, 23, 0, 24, 0, 0, 26,
480 0, 27, 28, 0, 29, 30, 31, 32, 33, 34,
481 0, 35, 36, 37, 0, 38, 39, 20, 21, 0,
482 22, 23, 0, 24, 0, 0, 26, 0, 27, 28,
483 2, 29, 30, 31, 32, 33, 34, 0, 4, 36,
484 0, 5, 38, 39, 6, 0, 0, 0, 7, 21,
485 8, 22, 23, 0, 24, 9, 10, 26, 0, 27,
486 28, 0, 29, 30, 31, 32, 33, 34, 0, 0,
487 36, 0, 21, 38, 39, 23, 0, 24, 0, 0,
488 26, 0, 27, 28, 0, 29, 30, 31, 32, 33,
489 34, 0, 0, 36, 21, 0, 38, 39, 0, 24,
490 0, 0, 26, 0, 27, 28, 0, 29, 30, 31,
491 32, 33, 34, 0, 0, 36, 0, 24, 38, 39,
492 26, 0, 27, 28, 0, 29, 30, 31, 32, 33,
493 34, 0, 0, 36, 24, 0, 38, 39, 0, 27,
494 28, 0, 29, 30, 31, 32, 33, 24, 0, 0,
495 36, 0, 0, 38, 39, 0, 0, 31, 32, 33,
496 0, 0, 0, 36, 0, 0, 38, 39
497};
498
499static const yysigned_char yycheck[] =
500{
501 2, 9, 0, 5, 6, 7, 8, -1, -1, -1,
502 -1, 19, 20, 21, -1, -1, -1, 25, 20, 21,
503 22, 23, 24, -1, 26, 27, 28, 29, 30, 31,
504 32, 33, 34, 35, 36, 37, 38, 39, 1, -1,
505 9, -1, 5, -1, -1, -1, -1, -1, 11, -1,
506 13, 20, 21, 16, -1, -1, 19, -1, 60, -1,
507 23, -1, 25, -1, -1, -1, -1, 30, 31, 3,
508 4, -1, 6, 7, -1, 9, 10, -1, 12, -1,
509 14, 15, -1, 17, 18, 19, 20, 21, 22, -1,
510 24, 25, 26, -1, 28, 29, 3, 4, -1, 6,
511 7, -1, 9, -1, -1, 12, -1, 14, 15, -1,
512 17, 18, 19, 20, 21, 22, -1, 24, 25, 26,
513 27, 28, 29, 3, 4, -1, 6, 7, 8, 9,
514 -1, -1, 12, -1, 14, 15, -1, 17, 18, 19,
515 20, 21, 22, -1, 24, 25, 26, -1, 28, 29,
516 3, 4, -1, 6, 7, -1, 9, -1, -1, 12,
517 -1, 14, 15, -1, 17, 18, 19, 20, 21, 22,
518 -1, 24, 25, 26, -1, 28, 29, 3, 4, -1,
519 6, 7, -1, 9, -1, -1, 12, -1, 14, 15,
520 5, 17, 18, 19, 20, 21, 22, -1, 13, 25,
521 -1, 16, 28, 29, 19, -1, -1, -1, 23, 4,
522 25, 6, 7, -1, 9, 30, 31, 12, -1, 14,
523 15, -1, 17, 18, 19, 20, 21, 22, -1, -1,
524 25, -1, 4, 28, 29, 7, -1, 9, -1, -1,
525 12, -1, 14, 15, -1, 17, 18, 19, 20, 21,
526 22, -1, -1, 25, 4, -1, 28, 29, -1, 9,
527 -1, -1, 12, -1, 14, 15, -1, 17, 18, 19,
528 20, 21, 22, -1, -1, 25, -1, 9, 28, 29,
529 12, -1, 14, 15, -1, 17, 18, 19, 20, 21,
530 22, -1, -1, 25, 9, -1, 28, 29, -1, 14,
531 15, -1, 17, 18, 19, 20, 21, 9, -1, -1,
532 25, -1, -1, 28, 29, -1, -1, 19, 20, 21,
533 -1, -1, -1, 25, -1, -1, 28, 29
534};
535
536/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
537 symbol of state STATE-NUM. */
538static const unsigned char yystos[] =
539{
540 0, 1, 5, 11, 13, 16, 19, 23, 25, 30,
541 31, 33, 34, 35, 34, 34, 34, 34, 34, 0,
542 3, 4, 6, 7, 9, 10, 12, 14, 15, 17,
543 18, 19, 20, 21, 22, 24, 25, 26, 28, 29,
544 27, 34, 34, 34, 34, 34, 34, 34, 34, 34,
545 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
546 8, 34
547};
548
549#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
550# define YYSIZE_T __SIZE_TYPE__
551#endif
552#if ! defined (YYSIZE_T) && defined (size_t)
553# define YYSIZE_T size_t
554#endif
555#if ! defined (YYSIZE_T)
556# if defined (__STDC__) || defined (__cplusplus)
557# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
558# define YYSIZE_T size_t
559# endif
560#endif
561#if ! defined (YYSIZE_T)
562# define YYSIZE_T unsigned int
563#endif
564
565#define yyerrok (yyerrstatus = 0)
566#define yyclearin (yychar = YYEMPTY)
567#define YYEMPTY -2
568#define YYEOF 0
569
570#define YYACCEPT goto yyacceptlab
571#define YYABORT goto yyabortlab
572#define YYERROR goto yyerrlab1
573
574/* Like YYERROR except do call yyerror. This remains here temporarily
575 to ease the transition to the new meaning of YYERROR, for GCC.
576 Once GCC version 2 has supplanted version 1, this can go. */
577
578#define YYFAIL goto yyerrlab
579
580#define YYRECOVERING() (!!yyerrstatus)
581
582#define YYBACKUP(Token, Value) \
583do \
584 if (yychar == YYEMPTY && yylen == 1) \
585 { \
586 yychar = (Token); \
587 yylval = (Value); \
588 yychar1 = YYTRANSLATE (yychar); \
589 YYPOPSTACK; \
590 goto yybackup; \
591 } \
592 else \
593 { \
594 yyerror ("syntax error: cannot back up"); \
595 YYERROR; \
596 } \
597while (0)
598
599#define YYTERROR 1
600#define YYERRCODE 256
601
602/* YYLLOC_DEFAULT -- Compute the default location (before the actions
603 are run). */
604
605#ifndef YYLLOC_DEFAULT
606# define YYLLOC_DEFAULT(Current, Rhs, N) \
607 Current.first_line = Rhs[1].first_line; \
608 Current.first_column = Rhs[1].first_column; \
609 Current.last_line = Rhs[N].last_line; \
610 Current.last_column = Rhs[N].last_column;
611#endif
612
613/* YYLEX -- calling `yylex' with the right arguments. */
614
615#define YYLEX yylex ()
616
617/* Enable debugging if requested. */
618#if YYDEBUG
619
620# ifndef YYFPRINTF
621# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
622# define YYFPRINTF fprintf
623# endif
624
625# define YYDPRINTF(Args) \
626do { \
627 if (yydebug) \
628 YYFPRINTF Args; \
629} while (0)
630# define YYDSYMPRINT(Args) \
631do { \
632 if (yydebug) \
633 yysymprint Args; \
634} while (0)
635/* Nonzero means print parse trace. It is left uninitialized so that
636 multiple parsers can coexist. */
637int yydebug;
638#else /* !YYDEBUG */
639# define YYDPRINTF(Args)
640# define YYDSYMPRINT(Args)
641#endif /* !YYDEBUG */
642
643/* YYINITDEPTH -- initial size of the parser's stacks. */
644#ifndef YYINITDEPTH
645# define YYINITDEPTH 200
646#endif
647
648/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
649 if the built-in stack extension method is used).
650
651 Do not make this value too large; the results are undefined if
652 SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
653 evaluated with infinite-precision integer arithmetic. */
654
655#if YYMAXDEPTH == 0
656# undef YYMAXDEPTH
657#endif
658
659#ifndef YYMAXDEPTH
660# define YYMAXDEPTH 10000
661#endif
662
663\f
664
665#if YYERROR_VERBOSE
666
667# ifndef yystrlen
668# if defined (__GLIBC__) && defined (_STRING_H)
669# define yystrlen strlen
670# else
671/* Return the length of YYSTR. */
672static YYSIZE_T
673# if defined (__STDC__) || defined (__cplusplus)
674yystrlen (const char *yystr)
675# else
676yystrlen (yystr)
677 const char *yystr;
678# endif
679{
680 register const char *yys = yystr;
681
682 while (*yys++ != '\0')
683 continue;
684
685 return yys - yystr - 1;
686}
687# endif
688# endif
689
690# ifndef yystpcpy
691# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
692# define yystpcpy stpcpy
693# else
694/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
695 YYDEST. */
696static char *
697# if defined (__STDC__) || defined (__cplusplus)
698yystpcpy (char *yydest, const char *yysrc)
699# else
700yystpcpy (yydest, yysrc)
701 char *yydest;
702 const char *yysrc;
703# endif
704{
705 register char *yyd = yydest;
706 register const char *yys = yysrc;
707
708 while ((*yyd++ = *yys++) != '\0')
709 continue;
710
711 return yyd - 1;
712}
713# endif
714# endif
715
716#endif /* !YYERROR_VERBOSE */
717
718\f
719
720#if YYDEBUG
721/*-----------------------------.
722| Print this symbol on YYOUT. |
723`-----------------------------*/
724
725static void
726#if defined (__STDC__) || defined (__cplusplus)
727yysymprint (FILE* yyout, int yytype, YYSTYPE yyvalue)
728#else
729yysymprint (yyout, yytype, yyvalue)
730 FILE* yyout;
731 int yytype;
732 YYSTYPE yyvalue;
733#endif
734{
735 /* Pacify ``unused variable'' warnings. */
736 (void) yyvalue;
737
738 if (yytype < YYNTOKENS)
739 {
740 YYFPRINTF (yyout, "token %s (", yytname[yytype]);
741# ifdef YYPRINT
742 YYPRINT (yyout, yytoknum[yytype], yyvalue);
743# endif
744 }
745 else
746 YYFPRINTF (yyout, "nterm %s (", yytname[yytype]);
747
748 switch (yytype)
749 {
750 default:
751 break;
752 }
753 YYFPRINTF (yyout, ")");
754}
755#endif /* YYDEBUG. */
756
757
758/*-----------------------------------------------.
759| Release the memory associated to this symbol. |
760`-----------------------------------------------*/
761
762static void
763#if defined (__STDC__) || defined (__cplusplus)
764yydestruct (int yytype, YYSTYPE yyvalue)
765#else
766yydestruct (yytype, yyvalue)
767 int yytype;
768 YYSTYPE yyvalue;
769#endif
770{
771 /* Pacify ``unused variable'' warnings. */
772 (void) yyvalue;
773
774 switch (yytype)
775 {
776 default:
777 break;
778 }
779}
780
781\f
782
783/* The user can define YYPARSE_PARAM as the name of an argument to be passed
784 into yyparse. The argument should have type void *.
785 It should actually point to an object.
786 Grammar actions can access the variable by casting it
787 to the proper pointer type. */
788
789#ifdef YYPARSE_PARAM
790# if defined (__STDC__) || defined (__cplusplus)
791# define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
792# define YYPARSE_PARAM_DECL
793# else
794# define YYPARSE_PARAM_ARG YYPARSE_PARAM
795# define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
796# endif
797#else /* !YYPARSE_PARAM */
798# define YYPARSE_PARAM_ARG
799# define YYPARSE_PARAM_DECL
800#endif /* !YYPARSE_PARAM */
801
802/* Prevent warning if -Wstrict-prototypes. */
803#ifdef __GNUC__
804# ifdef YYPARSE_PARAM
805int yyparse (void *);
806# else
807int yyparse (void);
808# endif
809#endif
810
811
812/* The lookahead symbol. */
813int yychar;
814
815/* The semantic value of the lookahead symbol. */
816YYSTYPE yylval;
817
818/* Number of parse errors so far. */
819int yynerrs;
820
821
822int
823yyparse (YYPARSE_PARAM_ARG)
824 YYPARSE_PARAM_DECL
825{
826
827 register int yystate;
828 register int yyn;
829 int yyresult;
830 /* Number of tokens to shift before error messages enabled. */
831 int yyerrstatus;
832 /* Lookahead token as an internal (translated) token number. */
833 int yychar1 = 0;
834
835 /* Three stacks and their tools:
836 `yyss': related to states,
837 `yyvs': related to semantic values,
838 `yyls': related to locations.
839
840 Refer to the stacks thru separate pointers, to allow yyoverflow
841 to reallocate them elsewhere. */
842
843 /* The state stack. */
844 short yyssa[YYINITDEPTH];
845 short *yyss = yyssa;
846 register short *yyssp;
847
848 /* The semantic value stack. */
849 YYSTYPE yyvsa[YYINITDEPTH];
850 YYSTYPE *yyvs = yyvsa;
851 register YYSTYPE *yyvsp;
852
853
854
855#define YYPOPSTACK (yyvsp--, yyssp--)
856
857 YYSIZE_T yystacksize = YYINITDEPTH;
858
859 /* The variables used to return semantic value and location from the
860 action routines. */
861 YYSTYPE yyval;
862
863
864 /* When reducing, the number of symbols on the RHS of the reduced
865 rule. */
866 int yylen;
867
868 YYDPRINTF ((stderr, "Starting parse\n"));
869
870 yystate = 0;
871 yyerrstatus = 0;
872 yynerrs = 0;
873 yychar = YYEMPTY; /* Cause a token to be read. */
874
875 /* Initialize stack pointers.
876 Waste one element of value and location stack
877 so that they stay on the same level as the state stack.
878 The wasted elements are never initialized. */
879
880 yyssp = yyss;
881 yyvsp = yyvs;
882
883 goto yysetstate;
884
885/*------------------------------------------------------------.
886| yynewstate -- Push a new state, which is found in yystate. |
887`------------------------------------------------------------*/
888 yynewstate:
889 /* In all cases, when you get here, the value and location stacks
890 have just been pushed. so pushing a state here evens the stacks.
891 */
892 yyssp++;
893
894 yysetstate:
895 *yyssp = yystate;
896
897 if (yyssp >= yyss + yystacksize - 1)
898 {
899 /* Get the current used size of the three stacks, in elements. */
900 YYSIZE_T yysize = yyssp - yyss + 1;
901
902#ifdef yyoverflow
903 {
904 /* Give user a chance to reallocate the stack. Use copies of
905 these so that the &'s don't force the real ones into
906 memory. */
907 YYSTYPE *yyvs1 = yyvs;
908 short *yyss1 = yyss;
909
910
911 /* Each stack pointer address is followed by the size of the
912 data in use in that stack, in bytes. This used to be a
913 conditional around just the two extra args, but that might
914 be undefined if yyoverflow is a macro. */
915 yyoverflow ("parser stack overflow",
916 &yyss1, yysize * sizeof (*yyssp),
917 &yyvs1, yysize * sizeof (*yyvsp),
918
919 &yystacksize);
920
921 yyss = yyss1;
922 yyvs = yyvs1;
923 }
924#else /* no yyoverflow */
925# ifndef YYSTACK_RELOCATE
926 goto yyoverflowlab;
927# else
928 /* Extend the stack our own way. */
929 if (yystacksize >= YYMAXDEPTH)
930 goto yyoverflowlab;
931 yystacksize *= 2;
932 if (yystacksize > YYMAXDEPTH)
933 yystacksize = YYMAXDEPTH;
934
935 {
936 short *yyss1 = yyss;
937 union yyalloc *yyptr =
938 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
939 if (! yyptr)
940 goto yyoverflowlab;
941 YYSTACK_RELOCATE (yyss);
942 YYSTACK_RELOCATE (yyvs);
943
944# undef YYSTACK_RELOCATE
945 if (yyss1 != yyssa)
946 YYSTACK_FREE (yyss1);
947 }
948# endif
949#endif /* no yyoverflow */
950
951 yyssp = yyss + yysize - 1;
952 yyvsp = yyvs + yysize - 1;
953
954
955 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
956 (unsigned long int) yystacksize));
957
958 if (yyssp >= yyss + yystacksize - 1)
959 YYABORT;
960 }
961
962 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
963
964 goto yybackup;
965
966/*-----------.
967| yybackup. |
968`-----------*/
969yybackup:
970
971/* Do appropriate processing given the current state. */
972/* Read a lookahead token if we need one and don't already have one. */
973/* yyresume: */
974
975 /* First try to decide what to do without reference to lookahead token. */
976
977 yyn = yypact[yystate];
978 if (yyn == YYPACT_NINF)
979 goto yydefault;
980
981 /* Not known => get a lookahead token if don't already have one. */
982
983 /* yychar is either YYEMPTY or YYEOF
984 or a valid token in external form. */
985
986 if (yychar == YYEMPTY)
987 {
988 YYDPRINTF ((stderr, "Reading a token: "));
989 yychar = YYLEX;
990 }
991
992 /* Convert token to internal form (in yychar1) for indexing tables with. */
993
994 if (yychar <= 0) /* This means end of input. */
995 {
996 yychar1 = 0;
997 yychar = YYEOF; /* Don't call YYLEX any more. */
998
999 YYDPRINTF ((stderr, "Now at end of input.\n"));
1000 }
1001 else
1002 {
1003 yychar1 = YYTRANSLATE (yychar);
1004
1005 /* We have to keep this `#if YYDEBUG', since we use variables
1006 which are defined only if `YYDEBUG' is set. */
1007 YYDPRINTF ((stderr, "Next token is "));
1008 YYDSYMPRINT ((stderr, yychar1, yylval));
1009 YYDPRINTF ((stderr, "\n"));
1010 }
1011
1012 /* If the proper action on seeing token YYCHAR1 is to reduce or to
1013 detect an error, take that action. */
1014 yyn += yychar1;
1015 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1)
1016 goto yydefault;
1017 yyn = yytable[yyn];
1018 if (yyn <= 0)
1019 {
1020 if (yyn == 0 || yyn == YYTABLE_NINF)
1021 goto yyerrlab;
1022 yyn = -yyn;
1023 goto yyreduce;
1024 }
1025
1026 if (yyn == YYFINAL)
1027 YYACCEPT;
1028
1029 /* Shift the lookahead token. */
1030 YYDPRINTF ((stderr, "Shifting token %d (%s), ",
1031 yychar, yytname[yychar1]));
1032
1033 /* Discard the token being shifted unless it is eof. */
1034 if (yychar != YYEOF)
1035 yychar = YYEMPTY;
1036
1037 *++yyvsp = yylval;
1038
1039
1040 /* Count tokens shifted since error; after three, turn off error
1041 status. */
1042 if (yyerrstatus)
1043 yyerrstatus--;
1044
1045 yystate = yyn;
1046 goto yynewstate;
1047
1048
1049/*-----------------------------------------------------------.
1050| yydefault -- do the default action for the current state. |
1051`-----------------------------------------------------------*/
1052yydefault:
1053 yyn = yydefact[yystate];
1054 if (yyn == 0)
1055 goto yyerrlab;
1056 goto yyreduce;
1057
1058
1059/*-----------------------------.
1060| yyreduce -- Do a reduction. |
1061`-----------------------------*/
1062yyreduce:
1063 /* yyn is the number of a rule to reduce with. */
1064 yylen = yyr2[yyn];
1065
1066 /* If YYLEN is nonzero, implement the default value of the action:
1067 `$$ = $1'.
1068
1069 Otherwise, the following line sets YYVAL to garbage.
1070 This behavior is undocumented and Bison
1071 users should not rely upon it. Assigning to YYVAL
1072 unconditionally makes the parser a bit smaller, and it avoids a
1073 GCC warning that YYVAL may be used uninitialized. */
1074 yyval = yyvsp[1-yylen];
1075
1076
1077
1078#if YYDEBUG
1079 /* We have to keep this `#if YYDEBUG', since we use variables which
1080 are defined only if `YYDEBUG' is set. */
1081 if (yydebug)
1082 {
1083 int yyi;
1084
1085 YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
1086 yyn - 1, yyrline[yyn]);
1087
1088 /* Print the symbols being reduced, and their result. */
1089 for (yyi = yyprhs[yyn]; yyrhs[yyi] >= 0; yyi++)
1090 YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
1091 YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
1092 }
1093#endif
1094 switch (yyn)
1095 {
1096 case 2:
1097#line 69 "ifgram.y"
1098 {
1099 return(yyvsp[-1] ? YES : NO);
1100 }
1101 break;
1102
1103 case 3:
1104#line 75 "ifgram.y"
1105 {
1106 pfatal("if clause parser received unknown token type");
1107 }
1108 break;
1109
1110 case 4:
1111#line 81 "ifgram.y"
1112 {
1113 l_yyerror(Curr_filename, yylineno, "syntax error in 'if' condition");
1114 return(NO);
1115 }
1116 break;
1117
1118 case 5:
1119#line 88 "ifgram.y"
1120 {
1121 yyval = yyvsp[-1];
1122 }
1123 break;
1124
1125 case 6:
1126#line 94 "ifgram.y"
1127 {
1128 yyval = !(yyvsp[0]);
1129 }
1130 break;
1131
1132 case 7:
1133#line 100 "ifgram.y"
1134 {
1135 yyval = ~(yyvsp[0]);
1136 }
1137 break;
1138
1139 case 8:
1140#line 106 "ifgram.y"
1141 {
1142 /* unary minus */
1143 yyval = -(yyvsp[0]);
1144 }
1145 break;
1146
1147 case 9:
1148#line 113 "ifgram.y"
1149 {
1150 /* unary plus. Not very useful, but ANSI C supports it... */
1151 yyval = (yyvsp[0]);
1152 }
1153 break;
1154
1155 case 10:
1156#line 120 "ifgram.y"
1157 {
1158 yyval = yyvsp[-2] * yyvsp[0];
1159 }
1160 break;
1161
1162 case 11:
1163#line 126 "ifgram.y"
1164 {
1165 if (yyvsp[0] == 0) {
1166 yyerror("attempt to divide by 0");
1167 /* gcc appears to return the numerator in this case,
1168 * so we do the same */
1169 yyval = yyvsp[-2];
1170 }
1171 else {
1172 yyval = yyvsp[-2] / yyvsp[0];
1173 }
1174 }
1175 break;
1176
1177 case 12:
1178#line 140 "ifgram.y"
1179 {
1180 if (yyvsp[0] == 0) {
1181 yyerror("attempt to modulo by 0");
1182 yyval = yyvsp[-2];
1183 }
1184 else {
1185 yyval = yyvsp[-2] % yyvsp[0];
1186 }
1187 }
1188 break;
1189
1190 case 13:
1191#line 152 "ifgram.y"
1192 {
1193 yyval = yyvsp[-2] + yyvsp[0];
1194 }
1195 break;
1196
1197 case 14:
1198#line 158 "ifgram.y"
1199 {
1200 yyval = yyvsp[-2] - yyvsp[0];
1201 }
1202 break;
1203
1204 case 15:
1205#line 164 "ifgram.y"
1206 {
1207 yyval = yyvsp[-2] << yyvsp[0];
1208 }
1209 break;
1210
1211 case 16:
1212#line 170 "ifgram.y"
1213 {
1214 yyval = yyvsp[-2] >> yyvsp[0];
1215 }
1216 break;
1217
1218 case 17:
1219#line 176 "ifgram.y"
1220 {
1221 yyval = (yyvsp[-2] < yyvsp[0]);
1222 }
1223 break;
1224
1225 case 18:
1226#line 182 "ifgram.y"
1227 {
1228 yyval = (yyvsp[-2] <= yyvsp[0]);
1229 }
1230 break;
1231
1232 case 19:
1233#line 188 "ifgram.y"
1234 {
1235 yyval = (yyvsp[-2] > yyvsp[0]);
1236 }
1237 break;
1238
1239 case 20:
1240#line 194 "ifgram.y"
1241 {
1242 yyval = (yyvsp[-2] >= yyvsp[0]);
1243 }
1244 break;
1245
1246 case 21:
1247#line 200 "ifgram.y"
1248 {
1249 yyval = (yyvsp[-2] == yyvsp[0]);
1250 }
1251 break;
1252
1253 case 22:
1254#line 206 "ifgram.y"
1255 {
1256 yyval = (yyvsp[-2] != yyvsp[0]);
1257 }
1258 break;
1259
1260 case 23:
1261#line 212 "ifgram.y"
1262 {
1263 yyval = yyvsp[-2] & yyvsp[0];
1264 }
1265 break;
1266
1267 case 24:
1268#line 218 "ifgram.y"
1269 {
1270 yyval = yyvsp[-2] ^ yyvsp[0];
1271 }
1272 break;
1273
1274 case 25:
1275#line 224 "ifgram.y"
1276 {
1277 yyval = yyvsp[-2] | yyvsp[0];
1278 }
1279 break;
1280
1281 case 26:
1282#line 230 "ifgram.y"
1283 {
1284 yyval = yyvsp[-2] || yyvsp[0];
1285 }
1286 break;
1287
1288 case 27:
1289#line 236 "ifgram.y"
1290 {
1291 yyval = yyvsp[-2] && yyvsp[0];
1292 }
1293 break;
1294
1295 case 28:
1296#line 242 "ifgram.y"
1297 {
1298 yyval = ( yyvsp[-4] ? yyvsp[-2] : yyvsp[0] );
1299 }
1300 break;
1301
1302 case 29:
1303#line 248 "ifgram.y"
1304 {
1305 yyval = yyvsp[0];
1306 }
1307 break;
1308
1309 case 30:
1310#line 254 "ifgram.y"
1311 {
1312 yyval = yyvsp[0];
1313 }
1314 break;
1315
1316 case 31:
1317#line 260 "ifgram.y"
1318 {
1319 yyval = 1;
1320 }
1321 break;
1322
1323 case 32:
1324#line 266 "ifgram.y"
1325 {
1326 yyval = 0;
1327 }
1328 break;
1329
1330
1331 }
1332
1333/* Line 1016 of /usr/share/bison/yacc.c. */
1334#line 1335 "ifgram.tab.c"
1335\f
1336 yyvsp -= yylen;
1337 yyssp -= yylen;
1338
1339
1340#if YYDEBUG
1341 if (yydebug)
1342 {
1343 short *yyssp1 = yyss - 1;
1344 YYFPRINTF (stderr, "state stack now");
1345 while (yyssp1 != yyssp)
1346 YYFPRINTF (stderr, " %d", *++yyssp1);
1347 YYFPRINTF (stderr, "\n");
1348 }
1349#endif
1350
1351 *++yyvsp = yyval;
1352
1353
1354 /* Now `shift' the result of the reduction. Determine what state
1355 that goes to, based on the state we popped back to and the rule
1356 number reduced by. */
1357
1358 yyn = yyr1[yyn];
1359
1360 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1361 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1362 yystate = yytable[yystate];
1363 else
1364 yystate = yydefgoto[yyn - YYNTOKENS];
1365
1366 goto yynewstate;
1367
1368
1369/*------------------------------------.
1370| yyerrlab -- here on detecting error |
1371`------------------------------------*/
1372yyerrlab:
1373 /* If not already recovering from an error, report this error. */
1374 if (!yyerrstatus)
1375 {
1376 ++yynerrs;
1377#if YYERROR_VERBOSE
1378 yyn = yypact[yystate];
1379
1380 if (YYPACT_NINF < yyn && yyn < YYLAST)
1381 {
1382 YYSIZE_T yysize = 0;
1383 int yytype = YYTRANSLATE (yychar);
1384 char *yymsg;
1385 int yyx, yycount;
1386
1387 yycount = 0;
1388 /* Start YYX at -YYN if negative to avoid negative indexes in
1389 YYCHECK. */
1390 for (yyx = yyn < 0 ? -yyn : 0;
1391 yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
1392 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1393 yysize += yystrlen (yytname[yyx]) + 15, yycount++;
1394 yysize += yystrlen ("parse error, unexpected ") + 1;
1395 yysize += yystrlen (yytname[yytype]);
1396 yymsg = (char *) YYSTACK_ALLOC (yysize);
1397 if (yymsg != 0)
1398 {
1399 char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
1400 yyp = yystpcpy (yyp, yytname[yytype]);
1401
1402 if (yycount < 5)
1403 {
1404 yycount = 0;
1405 for (yyx = yyn < 0 ? -yyn : 0;
1406 yyx < (int) (sizeof (yytname) / sizeof (char *));
1407 yyx++)
1408 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1409 {
1410 const char *yyq = ! yycount ? ", expecting " : " or ";
1411 yyp = yystpcpy (yyp, yyq);
1412 yyp = yystpcpy (yyp, yytname[yyx]);
1413 yycount++;
1414 }
1415 }
1416 yyerror (yymsg);
1417 YYSTACK_FREE (yymsg);
1418 }
1419 else
1420 yyerror ("parse error; also virtual memory exhausted");
1421 }
1422 else
1423#endif /* YYERROR_VERBOSE */
1424 yyerror ("parse error");
1425 }
1426 goto yyerrlab1;
1427
1428
1429/*----------------------------------------------------.
1430| yyerrlab1 -- error raised explicitly by an action. |
1431`----------------------------------------------------*/
1432yyerrlab1:
1433 if (yyerrstatus == 3)
1434 {
1435 /* If just tried and failed to reuse lookahead token after an
1436 error, discard it. */
1437
1438 /* Return failure if at end of input. */
1439 if (yychar == YYEOF)
1440 {
1441 /* Pop the error token. */
1442 YYPOPSTACK;
1443 /* Pop the rest of the stack. */
1444 while (yyssp > yyss)
1445 {
1446 YYDPRINTF ((stderr, "Error: popping "));
1447 YYDSYMPRINT ((stderr,
1448 yystos[*yyssp],
1449 *yyvsp));
1450 YYDPRINTF ((stderr, "\n"));
1451 yydestruct (yystos[*yyssp], *yyvsp);
1452 YYPOPSTACK;
1453 }
1454 YYABORT;
1455 }
1456
1457 YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
1458 yychar, yytname[yychar1]));
1459 yydestruct (yychar1, yylval);
1460 yychar = YYEMPTY;
1461 }
1462
1463 /* Else will try to reuse lookahead token after shifting the error
1464 token. */
1465
1466 yyerrstatus = 3; /* Each real token shifted decrements this. */
1467
1468 for (;;)
1469 {
1470 yyn = yypact[yystate];
1471 if (yyn != YYPACT_NINF)
1472 {
1473 yyn += YYTERROR;
1474 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1475 {
1476 yyn = yytable[yyn];
1477 if (0 < yyn)
1478 break;
1479 }
1480 }
1481
1482 /* Pop the current state because it cannot handle the error token. */
1483 if (yyssp == yyss)
1484 YYABORT;
1485
1486 YYDPRINTF ((stderr, "Error: popping "));
1487 YYDSYMPRINT ((stderr,
1488 yystos[*yyssp], *yyvsp));
1489 YYDPRINTF ((stderr, "\n"));
1490
1491 yydestruct (yystos[yystate], *yyvsp);
1492 yyvsp--;
1493 yystate = *--yyssp;
1494
1495
1496#if YYDEBUG
1497 if (yydebug)
1498 {
1499 short *yyssp1 = yyss - 1;
1500 YYFPRINTF (stderr, "Error: state stack now");
1501 while (yyssp1 != yyssp)
1502 YYFPRINTF (stderr, " %d", *++yyssp1);
1503 YYFPRINTF (stderr, "\n");
1504 }
1505#endif
1506 }
1507
1508 if (yyn == YYFINAL)
1509 YYACCEPT;
1510
1511 YYDPRINTF ((stderr, "Shifting error token, "));
1512
1513 *++yyvsp = yylval;
1514
1515
1516 yystate = yyn;
1517 goto yynewstate;
1518
1519
1520/*-------------------------------------.
1521| yyacceptlab -- YYACCEPT comes here. |
1522`-------------------------------------*/
1523yyacceptlab:
1524 yyresult = 0;
1525 goto yyreturn;
1526
1527/*-----------------------------------.
1528| yyabortlab -- YYABORT comes here. |
1529`-----------------------------------*/
1530yyabortlab:
1531 yyresult = 1;
1532 goto yyreturn;
1533
1534#ifndef yyoverflow
1535/*----------------------------------------------.
1536| yyoverflowlab -- parser overflow comes here. |
1537`----------------------------------------------*/
1538yyoverflowlab:
1539 yyerror ("parser stack overflow");
1540 yyresult = 2;
1541 /* Fall through. */
1542#endif
1543
1544yyreturn:
1545#ifndef yyoverflow
1546 if (yyss != yyssa)
1547 YYSTACK_FREE (yyss);
1548#endif
1549 return yyresult;
1550}
1551
1552
1553#line 272 "ifgram.y"
1554
1555
1556/* This is a pointer to the buffer containing the clause in compressed form.
1557 * A call to set_ifclause_buffer() sets this to point to an actual array */
1558static unsigned char * Buffer;
1559
1560/* Our current position in Buffer */
1561static int Offset;
1562
1563/* length of Buffer */
1564static int Length;
1565
1566
1567
1568/* To use this mini-parser, put the clause in compressed internal form
1569 * in an array, and pass that array and its length to this function,
1570 * then call ifparse().
1571 */
1572
1573void
1574set_ifclause_buffer(buff, len)
1575
1576unsigned char * buff;
1577int len;
1578
1579{
1580 Buffer = buff;
1581 Length = len;
1582 Offset = 0;
1583}
1584
1585
1586/* The compressed if-clause format is described in lex.c above add_ifclause().
1587 * Since it's very simple (everything except numbers
1588 * are single character tokens), we have a hand-coded lexer.
1589 * It maps the compressed format tokens to bison tokens.
1590 */
1591
1592int
1593iflex()
1594{
1595 if (Offset == Length) {
1596 return(ICT_END);
1597 }
1598
1599 switch(Buffer[Offset++]) {
1600
1601 case '(':
1602 return(ICT_LPAREN);
1603 case ')':
1604 return(ICT_RPAREN);
1605
1606 case '!':
1607 return(ICT_NOT);
1608 case '~':
1609 return(ICT_BITCOMPLEMENT);
1610
1611 case '*':
1612 return(ICT_MULT);
1613 case '/':
1614 return(ICT_DIVIDE);
1615 case '%':
1616 return(ICT_MOD);
1617
1618 case '+':
1619 return(ICT_PLUS);
1620 case '-':
1621 return(ICT_MINUS);
1622
1623 case 'l':
1624 return(ICT_SHLEFT);
1625 case 'r':
1626 return(ICT_SHRIGHT);
1627
1628 case '<':
1629 return(ICT_LT);
1630 case '>':
1631 return(ICT_GT);
1632 case 'L':
1633 return(ICT_LE);
1634 case 'G':
1635 return(ICT_GE);
1636
1637 case 'E':
1638 return(ICT_EQ);
1639 case 'N':
1640 return(ICT_NE);
1641
1642 case '&':
1643 return(ICT_BITAND);
1644
1645 case '^':
1646 return(ICT_BITXOR);
1647
1648 case '|':
1649 return(ICT_BITOR);
1650
1651 case 'a':
1652 return(ICT_AND);
1653
1654 case 'o':
1655 return(ICT_OR);
1656
1657 case '?':
1658 return(ICT_QUESTION);
1659 case ':':
1660 return(ICT_COLON);
1661
1662 case 'T':
1663 return(ICT_TRUE);
1664 case 'F':
1665 return(ICT_FALSE);
1666 case '#':
1667 iflval = ((Buffer[Offset] << 24) & 0xff000000)
1668 | ((Buffer[Offset+1] << 16) & 0xff0000)
1669 | ((Buffer[Offset+2] << 8) & 0xff00)
1670 | (Buffer[Offset+3] & 0xff);
1671 Offset += 4;
1672 return(ICT_VALUE);
1673
1674 default:
1675 return(ICT_ERROR);
1676 }
1677}
1678
1679
1680
1681/* Error message printer for syntax/semantic errors in 'if' clauses.
1682 * WARNING: bison appears to somehow use yyerror even when using a prefix
1683 * other than yy. So if this function calls yyerror, it gets into an
1684 * infinite loop! So don't do that...
1685 */
1686
1687int
1688iferror(msg)
1689
1690char * msg;
1691
1692{
1693 l_yyerror(Curr_filename, yylineno, msg);
1694 return(0);
1695}
1696
1697
Music publishing software, including Debian packaging.