|
0
|
1 /* A Bison parser, made from plural.y
|
|
|
2 by GNU bison 1.35. */
|
|
|
3
|
|
|
4 #define YYBISON 1 /* Identify Bison output. */
|
|
|
5
|
|
|
6 #define yyparse __gettextparse
|
|
|
7 #define yylex __gettextlex
|
|
|
8 #define yyerror __gettexterror
|
|
|
9 #define yylval __gettextlval
|
|
|
10 #define yychar __gettextchar
|
|
|
11 #define yydebug __gettextdebug
|
|
|
12 #define yynerrs __gettextnerrs
|
|
|
13 # define EQUOP2 257
|
|
|
14 # define CMPOP2 258
|
|
|
15 # define ADDOP2 259
|
|
|
16 # define MULOP2 260
|
|
|
17 # define NUMBER 261
|
|
|
18
|
|
|
19 #line 1 "plural.y"
|
|
|
20
|
|
|
21 /* Expression parsing for plural form selection.
|
|
|
22 Copyright (C) 2000, 2001 Free Software Foundation, Inc.
|
|
|
23 Written by Ulrich Drepper <drepper@cygnus.com>, 2000.
|
|
|
24
|
|
|
25 This program is free software; you can redistribute it and/or modify it
|
|
|
26 under the terms of the GNU Library General Public License as published
|
|
|
27 by the Free Software Foundation; either version 2, or (at your option)
|
|
|
28 any later version.
|
|
|
29
|
|
|
30 This program is distributed in the hope that it will be useful,
|
|
|
31 but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
32 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
33 Library General Public License for more details.
|
|
|
34
|
|
|
35 You should have received a copy of the GNU Library General Public
|
|
|
36 License along with this program; if not, write to the Free Software
|
|
|
37 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301,
|
|
|
38 USA. */
|
|
|
39
|
|
|
40 /* The bison generated parser uses alloca. AIX 3 forces us to put this
|
|
|
41 declaration at the beginning of the file. The declaration in bison's
|
|
|
42 skeleton file comes too late. This must come before <config.h>
|
|
|
43 because <config.h> may include arbitrary system headers. */
|
|
|
44 #if defined _AIX && !defined __GNUC__
|
|
|
45 #pragma alloca
|
|
|
46 #endif
|
|
|
47
|
|
|
48 #ifdef HAVE_CONFIG_H
|
|
|
49 # include <config.h>
|
|
|
50 #endif
|
|
|
51
|
|
|
52 #include <stddef.h>
|
|
|
53 #include <stdlib.h>
|
|
|
54 #include "plural-exp.h"
|
|
|
55
|
|
|
56 /* The main function generated by the parser is called __gettextparse,
|
|
|
57 but we want it to be called PLURAL_PARSE. */
|
|
|
58 #ifndef _LIBC
|
|
|
59 # define __gettextparse PLURAL_PARSE
|
|
|
60 #endif
|
|
|
61
|
|
|
62 #define YYLEX_PARAM &((struct parse_args *) arg)->cp
|
|
|
63 #define YYPARSE_PARAM arg
|
|
|
64
|
|
|
65 #line 49 "plural.y"
|
|
|
66 #ifndef YYSTYPE
|
|
|
67 typedef union {
|
|
|
68 unsigned long int num;
|
|
|
69 enum operator op;
|
|
|
70 struct expression *exp;
|
|
|
71 } yystype;
|
|
|
72 # define YYSTYPE yystype
|
|
|
73 # define YYSTYPE_IS_TRIVIAL 1
|
|
|
74 #endif
|
|
|
75 #line 55 "plural.y"
|
|
|
76
|
|
|
77 /* Prototypes for local functions. */
|
|
|
78 static struct expression *new_exp PARAMS ((int nargs, enum operator op,
|
|
|
79 struct expression * const *args));
|
|
|
80 static inline struct expression *new_exp_0 PARAMS ((enum operator op));
|
|
|
81 static inline struct expression *new_exp_1 PARAMS ((enum operator op,
|
|
|
82 struct expression *right));
|
|
|
83 static struct expression *new_exp_2 PARAMS ((enum operator op,
|
|
|
84 struct expression *left,
|
|
|
85 struct expression *right));
|
|
|
86 static inline struct expression *new_exp_3 PARAMS ((enum operator op,
|
|
|
87 struct expression *bexp,
|
|
|
88 struct expression *tbranch,
|
|
|
89 struct expression *fbranch));
|
|
|
90 static int yylex PARAMS ((YYSTYPE *lval, const char **pexp));
|
|
|
91 static void yyerror PARAMS ((const char *str));
|
|
|
92
|
|
|
93 /* Allocation of expressions. */
|
|
|
94
|
|
|
95 static struct expression *
|
|
|
96 new_exp (nargs, op, args)
|
|
|
97 int nargs;
|
|
|
98 enum operator op;
|
|
|
99 struct expression * const *args;
|
|
|
100 {
|
|
|
101 int i;
|
|
|
102 struct expression *newp;
|
|
|
103
|
|
|
104 /* If any of the argument could not be malloc'ed, just return NULL. */
|
|
|
105 for (i = nargs - 1; i >= 0; i--)
|
|
|
106 if (args[i] == NULL)
|
|
|
107 goto fail;
|
|
|
108
|
|
|
109 /* Allocate a new expression. */
|
|
|
110 newp = (struct expression *) malloc (sizeof (*newp));
|
|
|
111 if (newp != NULL)
|
|
|
112 {
|
|
|
113 newp->nargs = nargs;
|
|
|
114 newp->operation = op;
|
|
|
115 for (i = nargs - 1; i >= 0; i--)
|
|
|
116 newp->val.args[i] = args[i];
|
|
|
117 return newp;
|
|
|
118 }
|
|
|
119
|
|
|
120 fail:
|
|
|
121 for (i = nargs - 1; i >= 0; i--)
|
|
|
122 FREE_EXPRESSION (args[i]);
|
|
|
123
|
|
|
124 return NULL;
|
|
|
125 }
|
|
|
126
|
|
|
127 static inline struct expression *
|
|
|
128 new_exp_0 (op)
|
|
|
129 enum operator op;
|
|
|
130 {
|
|
|
131 return new_exp (0, op, NULL);
|
|
|
132 }
|
|
|
133
|
|
|
134 static inline struct expression *
|
|
|
135 new_exp_1 (op, right)
|
|
|
136 enum operator op;
|
|
|
137 struct expression *right;
|
|
|
138 {
|
|
|
139 struct expression *args[1];
|
|
|
140
|
|
|
141 args[0] = right;
|
|
|
142 return new_exp (1, op, args);
|
|
|
143 }
|
|
|
144
|
|
|
145 static struct expression *
|
|
|
146 new_exp_2 (op, left, right)
|
|
|
147 enum operator op;
|
|
|
148 struct expression *left;
|
|
|
149 struct expression *right;
|
|
|
150 {
|
|
|
151 struct expression *args[2];
|
|
|
152
|
|
|
153 args[0] = left;
|
|
|
154 args[1] = right;
|
|
|
155 return new_exp (2, op, args);
|
|
|
156 }
|
|
|
157
|
|
|
158 static inline struct expression *
|
|
|
159 new_exp_3 (op, bexp, tbranch, fbranch)
|
|
|
160 enum operator op;
|
|
|
161 struct expression *bexp;
|
|
|
162 struct expression *tbranch;
|
|
|
163 struct expression *fbranch;
|
|
|
164 {
|
|
|
165 struct expression *args[3];
|
|
|
166
|
|
|
167 args[0] = bexp;
|
|
|
168 args[1] = tbranch;
|
|
|
169 args[2] = fbranch;
|
|
|
170 return new_exp (3, op, args);
|
|
|
171 }
|
|
|
172
|
|
|
173 #ifndef YYDEBUG
|
|
|
174 # define YYDEBUG 0
|
|
|
175 #endif
|
|
|
176
|
|
|
177
|
|
|
178
|
|
|
179 #define YYFINAL 27
|
|
|
180 #define YYFLAG -32768
|
|
|
181 #define YYNTBASE 16
|
|
|
182
|
|
|
183 /* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */
|
|
|
184 #define YYTRANSLATE(x) ((unsigned)(x) <= 261 ? yytranslate[x] : 18)
|
|
|
185
|
|
|
186 /* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */
|
|
|
187 static const char yytranslate[] =
|
|
|
188 {
|
|
|
189 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
190 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
191 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
192 2, 2, 2, 10, 2, 2, 2, 2, 5, 2,
|
|
|
193 14, 15, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
194 2, 2, 2, 2, 2, 2, 2, 2, 12, 2,
|
|
|
195 2, 2, 2, 3, 2, 2, 2, 2, 2, 2,
|
|
|
196 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
197 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
198 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
199 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
200 13, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
201 2, 2, 2, 2, 4, 2, 2, 2, 2, 2,
|
|
|
202 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
203 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
204 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
205 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
206 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
207 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
208 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
209 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
210 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
211 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
212 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
213 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
214 2, 2, 2, 2, 2, 2, 1, 6, 7, 8,
|
|
|
215 9, 11
|
|
|
216 };
|
|
|
217
|
|
|
218 #if YYDEBUG
|
|
|
219 static const short yyprhs[] =
|
|
|
220 {
|
|
|
221 0, 0, 2, 8, 12, 16, 20, 24, 28, 32,
|
|
|
222 35, 37, 39
|
|
|
223 };
|
|
|
224 static const short yyrhs[] =
|
|
|
225 {
|
|
|
226 17, 0, 17, 3, 17, 12, 17, 0, 17, 4,
|
|
|
227 17, 0, 17, 5, 17, 0, 17, 6, 17, 0,
|
|
|
228 17, 7, 17, 0, 17, 8, 17, 0, 17, 9,
|
|
|
229 17, 0, 10, 17, 0, 13, 0, 11, 0, 14,
|
|
|
230 17, 15, 0
|
|
|
231 };
|
|
|
232
|
|
|
233 #endif
|
|
|
234
|
|
|
235 #if YYDEBUG
|
|
|
236 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
|
|
|
237 static const short yyrline[] =
|
|
|
238 {
|
|
|
239 0, 174, 182, 186, 190, 194, 198, 202, 206, 210,
|
|
|
240 214, 218, 223
|
|
|
241 };
|
|
|
242 #endif
|
|
|
243
|
|
|
244
|
|
|
245 #if (YYDEBUG) || defined YYERROR_VERBOSE
|
|
|
246
|
|
|
247 /* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */
|
|
|
248 static const char *const yytname[] =
|
|
|
249 {
|
|
|
250 "$", "error", "$undefined.", "'?'", "'|'", "'&'", "EQUOP2", "CMPOP2",
|
|
|
251 "ADDOP2", "MULOP2", "'!'", "NUMBER", "':'", "'n'", "'('", "')'",
|
|
|
252 "start", "exp", 0
|
|
|
253 };
|
|
|
254 #endif
|
|
|
255
|
|
|
256 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
|
|
|
257 static const short yyr1[] =
|
|
|
258 {
|
|
|
259 0, 16, 17, 17, 17, 17, 17, 17, 17, 17,
|
|
|
260 17, 17, 17
|
|
|
261 };
|
|
|
262
|
|
|
263 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
|
|
|
264 static const short yyr2[] =
|
|
|
265 {
|
|
|
266 0, 1, 5, 3, 3, 3, 3, 3, 3, 2,
|
|
|
267 1, 1, 3
|
|
|
268 };
|
|
|
269
|
|
|
270 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
|
|
|
271 doesn't specify something else to do. Zero means the default is an
|
|
|
272 error. */
|
|
|
273 static const short yydefact[] =
|
|
|
274 {
|
|
|
275 0, 0, 11, 10, 0, 1, 9, 0, 0, 0,
|
|
|
276 0, 0, 0, 0, 0, 12, 0, 3, 4, 5,
|
|
|
277 6, 7, 8, 0, 2, 0, 0, 0
|
|
|
278 };
|
|
|
279
|
|
|
280 static const short yydefgoto[] =
|
|
|
281 {
|
|
|
282 25, 5
|
|
|
283 };
|
|
|
284
|
|
|
285 static const short yypact[] =
|
|
|
286 {
|
|
|
287 -9, -9,-32768,-32768, -9, 34,-32768, 11, -9, -9,
|
|
|
288 -9, -9, -9, -9, -9,-32768, 24, 39, 43, 16,
|
|
|
289 26, -3,-32768, -9, 34, 21, 53,-32768
|
|
|
290 };
|
|
|
291
|
|
|
292 static const short yypgoto[] =
|
|
|
293 {
|
|
|
294 -32768, -1
|
|
|
295 };
|
|
|
296
|
|
|
297
|
|
|
298 #define YYLAST 53
|
|
|
299
|
|
|
300
|
|
|
301 static const short yytable[] =
|
|
|
302 {
|
|
|
303 6, 1, 2, 7, 3, 4, 14, 16, 17, 18,
|
|
|
304 19, 20, 21, 22, 8, 9, 10, 11, 12, 13,
|
|
|
305 14, 26, 24, 12, 13, 14, 15, 8, 9, 10,
|
|
|
306 11, 12, 13, 14, 13, 14, 23, 8, 9, 10,
|
|
|
307 11, 12, 13, 14, 10, 11, 12, 13, 14, 11,
|
|
|
308 12, 13, 14, 27
|
|
|
309 };
|
|
|
310
|
|
|
311 static const short yycheck[] =
|
|
|
312 {
|
|
|
313 1, 10, 11, 4, 13, 14, 9, 8, 9, 10,
|
|
|
314 11, 12, 13, 14, 3, 4, 5, 6, 7, 8,
|
|
|
315 9, 0, 23, 7, 8, 9, 15, 3, 4, 5,
|
|
|
316 6, 7, 8, 9, 8, 9, 12, 3, 4, 5,
|
|
|
317 6, 7, 8, 9, 5, 6, 7, 8, 9, 6,
|
|
|
318 7, 8, 9, 0
|
|
|
319 };
|
|
|
320 #define YYPURE 1
|
|
|
321
|
|
|
322 /* -*-C-*- Note some compilers choke on comments on `#line' lines. */
|
|
|
323 #line 3 "/usr/local/share/bison/bison.simple"
|
|
|
324
|
|
|
325 /* Skeleton output parser for bison,
|
|
|
326
|
|
|
327 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software
|
|
|
328 Foundation, Inc.
|
|
|
329
|
|
|
330 This program is free software; you can redistribute it and/or modify
|
|
|
331 it under the terms of the GNU General Public License as published by
|
|
|
332 the Free Software Foundation; either version 2, or (at your option)
|
|
|
333 any later version.
|
|
|
334
|
|
|
335 This program is distributed in the hope that it will be useful,
|
|
|
336 but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
337 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
338 GNU General Public License for more details.
|
|
|
339
|
|
|
340 You should have received a copy of the GNU General Public License
|
|
|
341 along with this program; if not, write to the Free Software
|
|
|
342 Foundation, Inc., 51 Franklin Street - Fifth Floor,
|
|
|
343 Boston, MA 02110-1301, USA. */
|
|
|
344
|
|
|
345 /* As a special exception, when this file is copied by Bison into a
|
|
|
346 Bison output file, you may use that output file without restriction.
|
|
|
347 This special exception was added by the Free Software Foundation
|
|
|
348 in version 1.24 of Bison. */
|
|
|
349
|
|
|
350 /* This is the parser code that is written into each bison parser when
|
|
|
351 the %semantic_parser declaration is not specified in the grammar.
|
|
|
352 It was written by Richard Stallman by simplifying the hairy parser
|
|
|
353 used when %semantic_parser is specified. */
|
|
|
354
|
|
|
355 /* All symbols defined below should begin with yy or YY, to avoid
|
|
|
356 infringing on user name space. This should be done even for local
|
|
|
357 variables, as they might otherwise be expanded by user macros.
|
|
|
358 There are some unavoidable exceptions within include files to
|
|
|
359 define necessary library symbols; they are noted "INFRINGES ON
|
|
|
360 USER NAME SPACE" below. */
|
|
|
361
|
|
|
362 #if ! defined (yyoverflow) || defined (YYERROR_VERBOSE)
|
|
|
363
|
|
|
364 /* The parser invokes alloca or malloc; define the necessary symbols. */
|
|
|
365
|
|
|
366 # if YYSTACK_USE_ALLOCA
|
|
|
367 # define YYSTACK_ALLOC alloca
|
|
|
368 # else
|
|
|
369 # ifndef YYSTACK_USE_ALLOCA
|
|
|
370 # if defined (alloca) || defined (_ALLOCA_H)
|
|
|
371 # define YYSTACK_ALLOC alloca
|
|
|
372 # else
|
|
|
373 # ifdef __GNUC__
|
|
|
374 # define YYSTACK_ALLOC __builtin_alloca
|
|
|
375 # endif
|
|
|
376 # endif
|
|
|
377 # endif
|
|
|
378 # endif
|
|
|
379
|
|
|
380 # ifdef YYSTACK_ALLOC
|
|
|
381 /* Pacify GCC's `empty if-body' warning. */
|
|
|
382 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
|
|
|
383 # else
|
|
|
384 # if defined (__STDC__) || defined (__cplusplus)
|
|
|
385 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
|
|
|
386 # define YYSIZE_T size_t
|
|
|
387 # endif
|
|
|
388 # define YYSTACK_ALLOC malloc
|
|
|
389 # define YYSTACK_FREE free
|
|
|
390 # endif
|
|
|
391 #endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */
|
|
|
392
|
|
|
393
|
|
|
394 #if (! defined (yyoverflow) \
|
|
|
395 && (! defined (__cplusplus) \
|
|
|
396 || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
|
|
|
397
|
|
|
398 /* A type that is properly aligned for any stack member. */
|
|
|
399 union yyalloc
|
|
|
400 {
|
|
|
401 short yyss;
|
|
|
402 YYSTYPE yyvs;
|
|
|
403 # if YYLSP_NEEDED
|
|
|
404 YYLTYPE yyls;
|
|
|
405 # endif
|
|
|
406 };
|
|
|
407
|
|
|
408 /* The size of the maximum gap between one aligned stack and the next. */
|
|
|
409 # define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
|
|
|
410
|
|
|
411 /* The size of an array large to enough to hold all stacks, each with
|
|
|
412 N elements. */
|
|
|
413 # if YYLSP_NEEDED
|
|
|
414 # define YYSTACK_BYTES(N) \
|
|
|
415 ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
|
|
|
416 + 2 * YYSTACK_GAP_MAX)
|
|
|
417 # else
|
|
|
418 # define YYSTACK_BYTES(N) \
|
|
|
419 ((N) * (sizeof (short) + sizeof (YYSTYPE)) \
|
|
|
420 + YYSTACK_GAP_MAX)
|
|
|
421 # endif
|
|
|
422
|
|
|
423 /* Copy COUNT objects from FROM to TO. The source and destination do
|
|
|
424 not overlap. */
|
|
|
425 # ifndef YYCOPY
|
|
|
426 # if 1 < __GNUC__
|
|
|
427 # define YYCOPY(To, From, Count) \
|
|
|
428 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
|
|
|
429 # else
|
|
|
430 # define YYCOPY(To, From, Count) \
|
|
|
431 do \
|
|
|
432 { \
|
|
|
433 register YYSIZE_T yyi; \
|
|
|
434 for (yyi = 0; yyi < (Count); yyi++) \
|
|
|
435 (To)[yyi] = (From)[yyi]; \
|
|
|
436 } \
|
|
|
437 while (0)
|
|
|
438 # endif
|
|
|
439 # endif
|
|
|
440
|
|
|
441 /* Relocate STACK from its old location to the new one. The
|
|
|
442 local variables YYSIZE and YYSTACKSIZE give the old and new number of
|
|
|
443 elements in the stack, and YYPTR gives the new location of the
|
|
|
444 stack. Advance YYPTR to a properly aligned location for the next
|
|
|
445 stack. */
|
|
|
446 # define YYSTACK_RELOCATE(Stack) \
|
|
|
447 do \
|
|
|
448 { \
|
|
|
449 YYSIZE_T yynewbytes; \
|
|
|
450 YYCOPY (&yyptr->Stack, Stack, yysize); \
|
|
|
451 Stack = &yyptr->Stack; \
|
|
|
452 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX; \
|
|
|
453 yyptr += yynewbytes / sizeof (*yyptr); \
|
|
|
454 } \
|
|
|
455 while (0)
|
|
|
456
|
|
|
457 #endif
|
|
|
458
|
|
|
459
|
|
|
460 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
|
|
|
461 # define YYSIZE_T __SIZE_TYPE__
|
|
|
462 #endif
|
|
|
463 #if ! defined (YYSIZE_T) && defined (size_t)
|
|
|
464 # define YYSIZE_T size_t
|
|
|
465 #endif
|
|
|
466 #if ! defined (YYSIZE_T)
|
|
|
467 # if defined (__STDC__) || defined (__cplusplus)
|
|
|
468 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
|
|
|
469 # define YYSIZE_T size_t
|
|
|
470 # endif
|
|
|
471 #endif
|
|
|
472 #if ! defined (YYSIZE_T)
|
|
|
473 # define YYSIZE_T unsigned int
|
|
|
474 #endif
|
|
|
475
|
|
|
476 #define yyerrok (yyerrstatus = 0)
|
|
|
477 #define yyclearin (yychar = YYEMPTY)
|
|
|
478 #define YYEMPTY -2
|
|
|
479 #define YYEOF 0
|
|
|
480 #define YYACCEPT goto yyacceptlab
|
|
|
481 #define YYABORT goto yyabortlab
|
|
|
482 #define YYERROR goto yyerrlab1
|
|
|
483 /* Like YYERROR except do call yyerror. This remains here temporarily
|
|
|
484 to ease the transition to the new meaning of YYERROR, for GCC.
|
|
|
485 Once GCC version 2 has supplanted version 1, this can go. */
|
|
|
486 #define YYFAIL goto yyerrlab
|
|
|
487 #define YYRECOVERING() (!!yyerrstatus)
|
|
|
488 #define YYBACKUP(Token, Value) \
|
|
|
489 do \
|
|
|
490 if (yychar == YYEMPTY && yylen == 1) \
|
|
|
491 { \
|
|
|
492 yychar = (Token); \
|
|
|
493 yylval = (Value); \
|
|
|
494 yychar1 = YYTRANSLATE (yychar); \
|
|
|
495 YYPOPSTACK; \
|
|
|
496 goto yybackup; \
|
|
|
497 } \
|
|
|
498 else \
|
|
|
499 { \
|
|
|
500 yyerror ("syntax error: cannot back up"); \
|
|
|
501 YYERROR; \
|
|
|
502 } \
|
|
|
503 while (0)
|
|
|
504
|
|
|
505 #define YYTERROR 1
|
|
|
506 #define YYERRCODE 256
|
|
|
507
|
|
|
508
|
|
|
509 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
|
|
|
510 are run).
|
|
|
511
|
|
|
512 When YYLLOC_DEFAULT is run, CURRENT is set the location of the
|
|
|
513 first token. By default, to implement support for ranges, extend
|
|
|
514 its range to the last symbol. */
|
|
|
515
|
|
|
516 #ifndef YYLLOC_DEFAULT
|
|
|
517 # define YYLLOC_DEFAULT(Current, Rhs, N) \
|
|
|
518 Current.last_line = Rhs[N].last_line; \
|
|
|
519 Current.last_column = Rhs[N].last_column;
|
|
|
520 #endif
|
|
|
521
|
|
|
522
|
|
|
523 /* YYLEX -- calling `yylex' with the right arguments. */
|
|
|
524
|
|
|
525 #if YYPURE
|
|
|
526 # if YYLSP_NEEDED
|
|
|
527 # ifdef YYLEX_PARAM
|
|
|
528 # define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
|
|
|
529 # else
|
|
|
530 # define YYLEX yylex (&yylval, &yylloc)
|
|
|
531 # endif
|
|
|
532 # else /* !YYLSP_NEEDED */
|
|
|
533 # ifdef YYLEX_PARAM
|
|
|
534 # define YYLEX yylex (&yylval, YYLEX_PARAM)
|
|
|
535 # else
|
|
|
536 # define YYLEX yylex (&yylval)
|
|
|
537 # endif
|
|
|
538 # endif /* !YYLSP_NEEDED */
|
|
|
539 #else /* !YYPURE */
|
|
|
540 # define YYLEX yylex ()
|
|
|
541 #endif /* !YYPURE */
|
|
|
542
|
|
|
543
|
|
|
544 /* Enable debugging if requested. */
|
|
|
545 #if YYDEBUG
|
|
|
546
|
|
|
547 # ifndef YYFPRINTF
|
|
|
548 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
|
|
|
549 # define YYFPRINTF fprintf
|
|
|
550 # endif
|
|
|
551
|
|
|
552 # define YYDPRINTF(Args) \
|
|
|
553 do { \
|
|
|
554 if (yydebug) \
|
|
|
555 YYFPRINTF Args; \
|
|
|
556 } while (0)
|
|
|
557 /* Nonzero means print parse trace. It is left uninitialized so that
|
|
|
558 multiple parsers can coexist. */
|
|
|
559 int yydebug;
|
|
|
560 #else /* !YYDEBUG */
|
|
|
561 # define YYDPRINTF(Args)
|
|
|
562 #endif /* !YYDEBUG */
|
|
|
563
|
|
|
564 /* YYINITDEPTH -- initial size of the parser's stacks. */
|
|
|
565 #ifndef YYINITDEPTH
|
|
|
566 # define YYINITDEPTH 200
|
|
|
567 #endif
|
|
|
568
|
|
|
569 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
|
|
|
570 if the built-in stack extension method is used).
|
|
|
571
|
|
|
572 Do not make this value too large; the results are undefined if
|
|
|
573 SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
|
|
|
574 evaluated with infinite-precision integer arithmetic. */
|
|
|
575
|
|
|
576 #if YYMAXDEPTH == 0
|
|
|
577 # undef YYMAXDEPTH
|
|
|
578 #endif
|
|
|
579
|
|
|
580 #ifndef YYMAXDEPTH
|
|
|
581 # define YYMAXDEPTH 10000
|
|
|
582 #endif
|
|
|
583
|
|
|
584 #ifdef YYERROR_VERBOSE
|
|
|
585
|
|
|
586 # ifndef yystrlen
|
|
|
587 # if defined (__GLIBC__) && defined (_STRING_H)
|
|
|
588 # define yystrlen strlen
|
|
|
589 # else
|
|
|
590 /* Return the length of YYSTR. */
|
|
|
591 static YYSIZE_T
|
|
|
592 # if defined (__STDC__) || defined (__cplusplus)
|
|
|
593 yystrlen (const char *yystr)
|
|
|
594 # else
|
|
|
595 yystrlen (yystr)
|
|
|
596 const char *yystr;
|
|
|
597 # endif
|
|
|
598 {
|
|
|
599 register const char *yys = yystr;
|
|
|
600
|
|
|
601 while (*yys++ != '\0')
|
|
|
602 continue;
|
|
|
603
|
|
|
604 return yys - yystr - 1;
|
|
|
605 }
|
|
|
606 # endif
|
|
|
607 # endif
|
|
|
608
|
|
|
609 # ifndef yystpcpy
|
|
|
610 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
|
|
|
611 # define yystpcpy stpcpy
|
|
|
612 # else
|
|
|
613 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
|
|
|
614 YYDEST. */
|
|
|
615 static char *
|
|
|
616 # if defined (__STDC__) || defined (__cplusplus)
|
|
|
617 yystpcpy (char *yydest, const char *yysrc)
|
|
|
618 # else
|
|
|
619 yystpcpy (yydest, yysrc)
|
|
|
620 char *yydest;
|
|
|
621 const char *yysrc;
|
|
|
622 # endif
|
|
|
623 {
|
|
|
624 register char *yyd = yydest;
|
|
|
625 register const char *yys = yysrc;
|
|
|
626
|
|
|
627 while ((*yyd++ = *yys++) != '\0')
|
|
|
628 continue;
|
|
|
629
|
|
|
630 return yyd - 1;
|
|
|
631 }
|
|
|
632 # endif
|
|
|
633 # endif
|
|
|
634 #endif
|
|
|
635
|
|
|
636 #line 315 "/usr/local/share/bison/bison.simple"
|
|
|
637
|
|
|
638
|
|
|
639 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
|
|
|
640 into yyparse. The argument should have type void *.
|
|
|
641 It should actually point to an object.
|
|
|
642 Grammar actions can access the variable by casting it
|
|
|
643 to the proper pointer type. */
|
|
|
644
|
|
|
645 #ifdef YYPARSE_PARAM
|
|
|
646 # if defined (__STDC__) || defined (__cplusplus)
|
|
|
647 # define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
|
|
|
648 # define YYPARSE_PARAM_DECL
|
|
|
649 # else
|
|
|
650 # define YYPARSE_PARAM_ARG YYPARSE_PARAM
|
|
|
651 # define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
|
|
|
652 # endif
|
|
|
653 #else /* !YYPARSE_PARAM */
|
|
|
654 # define YYPARSE_PARAM_ARG
|
|
|
655 # define YYPARSE_PARAM_DECL
|
|
|
656 #endif /* !YYPARSE_PARAM */
|
|
|
657
|
|
|
658 /* Prevent warning if -Wstrict-prototypes. */
|
|
|
659 #ifdef __GNUC__
|
|
|
660 # ifdef YYPARSE_PARAM
|
|
|
661 int yyparse (void *);
|
|
|
662 # else
|
|
|
663 int yyparse (void);
|
|
|
664 # endif
|
|
|
665 #endif
|
|
|
666
|
|
|
667 /* YY_DECL_VARIABLES -- depending whether we use a pure parser,
|
|
|
668 variables are global, or local to YYPARSE. */
|
|
|
669
|
|
|
670 #define YY_DECL_NON_LSP_VARIABLES \
|
|
|
671 /* The lookahead symbol. */ \
|
|
|
672 int yychar; \
|
|
|
673 \
|
|
|
674 /* The semantic value of the lookahead symbol. */ \
|
|
|
675 YYSTYPE yylval; \
|
|
|
676 \
|
|
|
677 /* Number of parse errors so far. */ \
|
|
|
678 int yynerrs;
|
|
|
679
|
|
|
680 #if YYLSP_NEEDED
|
|
|
681 # define YY_DECL_VARIABLES \
|
|
|
682 YY_DECL_NON_LSP_VARIABLES \
|
|
|
683 \
|
|
|
684 /* Location data for the lookahead symbol. */ \
|
|
|
685 YYLTYPE yylloc;
|
|
|
686 #else
|
|
|
687 # define YY_DECL_VARIABLES \
|
|
|
688 YY_DECL_NON_LSP_VARIABLES
|
|
|
689 #endif
|
|
|
690
|
|
|
691
|
|
|
692 /* If nonreentrant, generate the variables here. */
|
|
|
693
|
|
|
694 #if !YYPURE
|
|
|
695 YY_DECL_VARIABLES
|
|
|
696 #endif /* !YYPURE */
|
|
|
697
|
|
|
698 int
|
|
|
699 yyparse (YYPARSE_PARAM_ARG)
|
|
|
700 YYPARSE_PARAM_DECL
|
|
|
701 {
|
|
|
702 /* If reentrant, generate the variables here. */
|
|
|
703 #if YYPURE
|
|
|
704 YY_DECL_VARIABLES
|
|
|
705 #endif /* !YYPURE */
|
|
|
706
|
|
|
707 register int yystate;
|
|
|
708 register int yyn;
|
|
|
709 int yyresult;
|
|
|
710 /* Number of tokens to shift before error messages enabled. */
|
|
|
711 int yyerrstatus;
|
|
|
712 /* Lookahead token as an internal (translated) token number. */
|
|
|
713 int yychar1 = 0;
|
|
|
714
|
|
|
715 /* Three stacks and their tools:
|
|
|
716 `yyss': related to states,
|
|
|
717 `yyvs': related to semantic values,
|
|
|
718 `yyls': related to locations.
|
|
|
719
|
|
|
720 Refer to the stacks thru separate pointers, to allow yyoverflow
|
|
|
721 to reallocate them elsewhere. */
|
|
|
722
|
|
|
723 /* The state stack. */
|
|
|
724 short yyssa[YYINITDEPTH];
|
|
|
725 short *yyss = yyssa;
|
|
|
726 register short *yyssp;
|
|
|
727
|
|
|
728 /* The semantic value stack. */
|
|
|
729 YYSTYPE yyvsa[YYINITDEPTH];
|
|
|
730 YYSTYPE *yyvs = yyvsa;
|
|
|
731 register YYSTYPE *yyvsp;
|
|
|
732
|
|
|
733 #if YYLSP_NEEDED
|
|
|
734 /* The location stack. */
|
|
|
735 YYLTYPE yylsa[YYINITDEPTH];
|
|
|
736 YYLTYPE *yyls = yylsa;
|
|
|
737 YYLTYPE *yylsp;
|
|
|
738 #endif
|
|
|
739
|
|
|
740 #if YYLSP_NEEDED
|
|
|
741 # define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
|
|
|
742 #else
|
|
|
743 # define YYPOPSTACK (yyvsp--, yyssp--)
|
|
|
744 #endif
|
|
|
745
|
|
|
746 YYSIZE_T yystacksize = YYINITDEPTH;
|
|
|
747
|
|
|
748
|
|
|
749 /* The variables used to return semantic value and location from the
|
|
|
750 action routines. */
|
|
|
751 YYSTYPE yyval;
|
|
|
752 #if YYLSP_NEEDED
|
|
|
753 YYLTYPE yyloc;
|
|
|
754 #endif
|
|
|
755
|
|
|
756 /* When reducing, the number of symbols on the RHS of the reduced
|
|
|
757 rule. */
|
|
|
758 int yylen;
|
|
|
759
|
|
|
760 YYDPRINTF ((stderr, "Starting parse\n"));
|
|
|
761
|
|
|
762 yystate = 0;
|
|
|
763 yyerrstatus = 0;
|
|
|
764 yynerrs = 0;
|
|
|
765 yychar = YYEMPTY; /* Cause a token to be read. */
|
|
|
766
|
|
|
767 /* Initialize stack pointers.
|
|
|
768 Waste one element of value and location stack
|
|
|
769 so that they stay on the same level as the state stack.
|
|
|
770 The wasted elements are never initialized. */
|
|
|
771
|
|
|
772 yyssp = yyss;
|
|
|
773 yyvsp = yyvs;
|
|
|
774 #if YYLSP_NEEDED
|
|
|
775 yylsp = yyls;
|
|
|
776 #endif
|
|
|
777 goto yysetstate;
|
|
|
778
|
|
|
779 /*------------------------------------------------------------.
|
|
|
780 | yynewstate -- Push a new state, which is found in yystate. |
|
|
|
781 `------------------------------------------------------------*/
|
|
|
782 yynewstate:
|
|
|
783 /* In all cases, when you get here, the value and location stacks
|
|
|
784 have just been pushed. so pushing a state here evens the stacks.
|
|
|
785 */
|
|
|
786 yyssp++;
|
|
|
787
|
|
|
788 yysetstate:
|
|
|
789 *yyssp = yystate;
|
|
|
790
|
|
|
791 if (yyssp >= yyss + yystacksize - 1)
|
|
|
792 {
|
|
|
793 /* Get the current used size of the three stacks, in elements. */
|
|
|
794 YYSIZE_T yysize = yyssp - yyss + 1;
|
|
|
795
|
|
|
796 #ifdef yyoverflow
|
|
|
797 {
|
|
|
798 /* Give user a chance to reallocate the stack. Use copies of
|
|
|
799 these so that the &'s don't force the real ones into
|
|
|
800 memory. */
|
|
|
801 YYSTYPE *yyvs1 = yyvs;
|
|
|
802 short *yyss1 = yyss;
|
|
|
803
|
|
|
804 /* Each stack pointer address is followed by the size of the
|
|
|
805 data in use in that stack, in bytes. */
|
|
|
806 # if YYLSP_NEEDED
|
|
|
807 YYLTYPE *yyls1 = yyls;
|
|
|
808 /* This used to be a conditional around just the two extra args,
|
|
|
809 but that might be undefined if yyoverflow is a macro. */
|
|
|
810 yyoverflow ("parser stack overflow",
|
|
|
811 &yyss1, yysize * sizeof (*yyssp),
|
|
|
812 &yyvs1, yysize * sizeof (*yyvsp),
|
|
|
813 &yyls1, yysize * sizeof (*yylsp),
|
|
|
814 &yystacksize);
|
|
|
815 yyls = yyls1;
|
|
|
816 # else
|
|
|
817 yyoverflow ("parser stack overflow",
|
|
|
818 &yyss1, yysize * sizeof (*yyssp),
|
|
|
819 &yyvs1, yysize * sizeof (*yyvsp),
|
|
|
820 &yystacksize);
|
|
|
821 # endif
|
|
|
822 yyss = yyss1;
|
|
|
823 yyvs = yyvs1;
|
|
|
824 }
|
|
|
825 #else /* no yyoverflow */
|
|
|
826 # ifndef YYSTACK_RELOCATE
|
|
|
827 goto yyoverflowlab;
|
|
|
828 # else
|
|
|
829 /* Extend the stack our own way. */
|
|
|
830 if (yystacksize >= YYMAXDEPTH)
|
|
|
831 goto yyoverflowlab;
|
|
|
832 yystacksize *= 2;
|
|
|
833 if (yystacksize > YYMAXDEPTH)
|
|
|
834 yystacksize = YYMAXDEPTH;
|
|
|
835
|
|
|
836 {
|
|
|
837 short *yyss1 = yyss;
|
|
|
838 union yyalloc *yyptr =
|
|
|
839 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
|
|
|
840 if (! yyptr)
|
|
|
841 goto yyoverflowlab;
|
|
|
842 YYSTACK_RELOCATE (yyss);
|
|
|
843 YYSTACK_RELOCATE (yyvs);
|
|
|
844 # if YYLSP_NEEDED
|
|
|
845 YYSTACK_RELOCATE (yyls);
|
|
|
846 # endif
|
|
|
847 # undef YYSTACK_RELOCATE
|
|
|
848 if (yyss1 != yyssa)
|
|
|
849 YYSTACK_FREE (yyss1);
|
|
|
850 }
|
|
|
851 # endif
|
|
|
852 #endif /* no yyoverflow */
|
|
|
853
|
|
|
854 yyssp = yyss + yysize - 1;
|
|
|
855 yyvsp = yyvs + yysize - 1;
|
|
|
856 #if YYLSP_NEEDED
|
|
|
857 yylsp = yyls + yysize - 1;
|
|
|
858 #endif
|
|
|
859
|
|
|
860 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
|
|
|
861 (unsigned long int) yystacksize));
|
|
|
862
|
|
|
863 if (yyssp >= yyss + yystacksize - 1)
|
|
|
864 YYABORT;
|
|
|
865 }
|
|
|
866
|
|
|
867 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
|
|
|
868
|
|
|
869 goto yybackup;
|
|
|
870
|
|
|
871
|
|
|
872 /*-----------.
|
|
|
873 | yybackup. |
|
|
|
874 `-----------*/
|
|
|
875 yybackup:
|
|
|
876
|
|
|
877 /* Do appropriate processing given the current state. */
|
|
|
878 /* Read a lookahead token if we need one and don't already have one. */
|
|
|
879 /* yyresume: */
|
|
|
880
|
|
|
881 /* First try to decide what to do without reference to lookahead token. */
|
|
|
882
|
|
|
883 yyn = yypact[yystate];
|
|
|
884 if (yyn == YYFLAG)
|
|
|
885 goto yydefault;
|
|
|
886
|
|
|
887 /* Not known => get a lookahead token if don't already have one. */
|
|
|
888
|
|
|
889 /* yychar is either YYEMPTY or YYEOF
|
|
|
890 or a valid token in external form. */
|
|
|
891
|
|
|
892 if (yychar == YYEMPTY)
|
|
|
893 {
|
|
|
894 YYDPRINTF ((stderr, "Reading a token: "));
|
|
|
895 yychar = YYLEX;
|
|
|
896 }
|
|
|
897
|
|
|
898 /* Convert token to internal form (in yychar1) for indexing tables with */
|
|
|
899
|
|
|
900 if (yychar <= 0) /* This means end of input. */
|
|
|
901 {
|
|
|
902 yychar1 = 0;
|
|
|
903 yychar = YYEOF; /* Don't call YYLEX any more */
|
|
|
904
|
|
|
905 YYDPRINTF ((stderr, "Now at end of input.\n"));
|
|
|
906 }
|
|
|
907 else
|
|
|
908 {
|
|
|
909 yychar1 = YYTRANSLATE (yychar);
|
|
|
910
|
|
|
911 #if YYDEBUG
|
|
|
912 /* We have to keep this `#if YYDEBUG', since we use variables
|
|
|
913 which are defined only if `YYDEBUG' is set. */
|
|
|
914 if (yydebug)
|
|
|
915 {
|
|
|
916 YYFPRINTF (stderr, "Next token is %d (%s",
|
|
|
917 yychar, yytname[yychar1]);
|
|
|
918 /* Give the individual parser a way to print the precise
|
|
|
919 meaning of a token, for further debugging info. */
|
|
|
920 # ifdef YYPRINT
|
|
|
921 YYPRINT (stderr, yychar, yylval);
|
|
|
922 # endif
|
|
|
923 YYFPRINTF (stderr, ")\n");
|
|
|
924 }
|
|
|
925 #endif
|
|
|
926 }
|
|
|
927
|
|
|
928 yyn += yychar1;
|
|
|
929 if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
|
|
|
930 goto yydefault;
|
|
|
931
|
|
|
932 yyn = yytable[yyn];
|
|
|
933
|
|
|
934 /* yyn is what to do for this token type in this state.
|
|
|
935 Negative => reduce, -yyn is rule number.
|
|
|
936 Positive => shift, yyn is new state.
|
|
|
937 New state is final state => don't bother to shift,
|
|
|
938 just return success.
|
|
|
939 0, or most negative number => error. */
|
|
|
940
|
|
|
941 if (yyn < 0)
|
|
|
942 {
|
|
|
943 if (yyn == YYFLAG)
|
|
|
944 goto yyerrlab;
|
|
|
945 yyn = -yyn;
|
|
|
946 goto yyreduce;
|
|
|
947 }
|
|
|
948 else if (yyn == 0)
|
|
|
949 goto yyerrlab;
|
|
|
950
|
|
|
951 if (yyn == YYFINAL)
|
|
|
952 YYACCEPT;
|
|
|
953
|
|
|
954 /* Shift the lookahead token. */
|
|
|
955 YYDPRINTF ((stderr, "Shifting token %d (%s), ",
|
|
|
956 yychar, yytname[yychar1]));
|
|
|
957
|
|
|
958 /* Discard the token being shifted unless it is eof. */
|
|
|
959 if (yychar != YYEOF)
|
|
|
960 yychar = YYEMPTY;
|
|
|
961
|
|
|
962 *++yyvsp = yylval;
|
|
|
963 #if YYLSP_NEEDED
|
|
|
964 *++yylsp = yylloc;
|
|
|
965 #endif
|
|
|
966
|
|
|
967 /* Count tokens shifted since error; after three, turn off error
|
|
|
968 status. */
|
|
|
969 if (yyerrstatus)
|
|
|
970 yyerrstatus--;
|
|
|
971
|
|
|
972 yystate = yyn;
|
|
|
973 goto yynewstate;
|
|
|
974
|
|
|
975
|
|
|
976 /*-----------------------------------------------------------.
|
|
|
977 | yydefault -- do the default action for the current state. |
|
|
|
978 `-----------------------------------------------------------*/
|
|
|
979 yydefault:
|
|
|
980 yyn = yydefact[yystate];
|
|
|
981 if (yyn == 0)
|
|
|
982 goto yyerrlab;
|
|
|
983 goto yyreduce;
|
|
|
984
|
|
|
985
|
|
|
986 /*-----------------------------.
|
|
|
987 | yyreduce -- Do a reduction. |
|
|
|
988 `-----------------------------*/
|
|
|
989 yyreduce:
|
|
|
990 /* yyn is the number of a rule to reduce with. */
|
|
|
991 yylen = yyr2[yyn];
|
|
|
992
|
|
|
993 /* If YYLEN is nonzero, implement the default value of the action:
|
|
|
994 `$$ = $1'.
|
|
|
995
|
|
|
996 Otherwise, the following line sets YYVAL to the semantic value of
|
|
|
997 the lookahead token. This behavior is undocumented and Bison
|
|
|
998 users should not rely upon it. Assigning to YYVAL
|
|
|
999 unconditionally makes the parser a bit smaller, and it avoids a
|
|
|
1000 GCC warning that YYVAL may be used uninitialized. */
|
|
|
1001 yyval = yyvsp[1-yylen];
|
|
|
1002
|
|
|
1003 #if YYLSP_NEEDED
|
|
|
1004 /* Similarly for the default location. Let the user run additional
|
|
|
1005 commands if for instance locations are ranges. */
|
|
|
1006 yyloc = yylsp[1-yylen];
|
|
|
1007 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
|
|
|
1008 #endif
|
|
|
1009
|
|
|
1010 #if YYDEBUG
|
|
|
1011 /* We have to keep this `#if YYDEBUG', since we use variables which
|
|
|
1012 are defined only if `YYDEBUG' is set. */
|
|
|
1013 if (yydebug)
|
|
|
1014 {
|
|
|
1015 int yyi;
|
|
|
1016
|
|
|
1017 YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
|
|
|
1018 yyn, yyrline[yyn]);
|
|
|
1019
|
|
|
1020 /* Print the symbols being reduced, and their result. */
|
|
|
1021 for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)
|
|
|
1022 YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
|
|
|
1023 YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
|
|
|
1024 }
|
|
|
1025 #endif
|
|
|
1026
|
|
|
1027 switch (yyn) {
|
|
|
1028
|
|
|
1029 case 1:
|
|
|
1030 #line 175 "plural.y"
|
|
|
1031 {
|
|
|
1032 if (yyvsp[0].exp == NULL)
|
|
|
1033 YYABORT;
|
|
|
1034 ((struct parse_args *) arg)->res = yyvsp[0].exp;
|
|
|
1035 }
|
|
|
1036 break;
|
|
|
1037 case 2:
|
|
|
1038 #line 183 "plural.y"
|
|
|
1039 {
|
|
|
1040 yyval.exp = new_exp_3 (qmop, yyvsp[-4].exp, yyvsp[-2].exp, yyvsp[0].exp);
|
|
|
1041 }
|
|
|
1042 break;
|
|
|
1043 case 3:
|
|
|
1044 #line 187 "plural.y"
|
|
|
1045 {
|
|
|
1046 yyval.exp = new_exp_2 (lor, yyvsp[-2].exp, yyvsp[0].exp);
|
|
|
1047 }
|
|
|
1048 break;
|
|
|
1049 case 4:
|
|
|
1050 #line 191 "plural.y"
|
|
|
1051 {
|
|
|
1052 yyval.exp = new_exp_2 (land, yyvsp[-2].exp, yyvsp[0].exp);
|
|
|
1053 }
|
|
|
1054 break;
|
|
|
1055 case 5:
|
|
|
1056 #line 195 "plural.y"
|
|
|
1057 {
|
|
|
1058 yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
|
|
|
1059 }
|
|
|
1060 break;
|
|
|
1061 case 6:
|
|
|
1062 #line 199 "plural.y"
|
|
|
1063 {
|
|
|
1064 yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
|
|
|
1065 }
|
|
|
1066 break;
|
|
|
1067 case 7:
|
|
|
1068 #line 203 "plural.y"
|
|
|
1069 {
|
|
|
1070 yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
|
|
|
1071 }
|
|
|
1072 break;
|
|
|
1073 case 8:
|
|
|
1074 #line 207 "plural.y"
|
|
|
1075 {
|
|
|
1076 yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
|
|
|
1077 }
|
|
|
1078 break;
|
|
|
1079 case 9:
|
|
|
1080 #line 211 "plural.y"
|
|
|
1081 {
|
|
|
1082 yyval.exp = new_exp_1 (lnot, yyvsp[0].exp);
|
|
|
1083 }
|
|
|
1084 break;
|
|
|
1085 case 10:
|
|
|
1086 #line 215 "plural.y"
|
|
|
1087 {
|
|
|
1088 yyval.exp = new_exp_0 (var);
|
|
|
1089 }
|
|
|
1090 break;
|
|
|
1091 case 11:
|
|
|
1092 #line 219 "plural.y"
|
|
|
1093 {
|
|
|
1094 if ((yyval.exp = new_exp_0 (num)) != NULL)
|
|
|
1095 yyval.exp->val.num = yyvsp[0].num;
|
|
|
1096 }
|
|
|
1097 break;
|
|
|
1098 case 12:
|
|
|
1099 #line 224 "plural.y"
|
|
|
1100 {
|
|
|
1101 yyval.exp = yyvsp[-1].exp;
|
|
|
1102 }
|
|
|
1103 break;
|
|
|
1104 }
|
|
|
1105
|
|
|
1106 #line 705 "/usr/local/share/bison/bison.simple"
|
|
|
1107
|
|
|
1108
|
|
|
1109 yyvsp -= yylen;
|
|
|
1110 yyssp -= yylen;
|
|
|
1111 #if YYLSP_NEEDED
|
|
|
1112 yylsp -= yylen;
|
|
|
1113 #endif
|
|
|
1114
|
|
|
1115 #if YYDEBUG
|
|
|
1116 if (yydebug)
|
|
|
1117 {
|
|
|
1118 short *yyssp1 = yyss - 1;
|
|
|
1119 YYFPRINTF (stderr, "state stack now");
|
|
|
1120 while (yyssp1 != yyssp)
|
|
|
1121 YYFPRINTF (stderr, " %d", *++yyssp1);
|
|
|
1122 YYFPRINTF (stderr, "\n");
|
|
|
1123 }
|
|
|
1124 #endif
|
|
|
1125
|
|
|
1126 *++yyvsp = yyval;
|
|
|
1127 #if YYLSP_NEEDED
|
|
|
1128 *++yylsp = yyloc;
|
|
|
1129 #endif
|
|
|
1130
|
|
|
1131 /* Now `shift' the result of the reduction. Determine what state
|
|
|
1132 that goes to, based on the state we popped back to and the rule
|
|
|
1133 number reduced by. */
|
|
|
1134
|
|
|
1135 yyn = yyr1[yyn];
|
|
|
1136
|
|
|
1137 yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
|
|
|
1138 if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
|
|
|
1139 yystate = yytable[yystate];
|
|
|
1140 else
|
|
|
1141 yystate = yydefgoto[yyn - YYNTBASE];
|
|
|
1142
|
|
|
1143 goto yynewstate;
|
|
|
1144
|
|
|
1145
|
|
|
1146 /*------------------------------------.
|
|
|
1147 | yyerrlab -- here on detecting error |
|
|
|
1148 `------------------------------------*/
|
|
|
1149 yyerrlab:
|
|
|
1150 /* If not already recovering from an error, report this error. */
|
|
|
1151 if (!yyerrstatus)
|
|
|
1152 {
|
|
|
1153 ++yynerrs;
|
|
|
1154
|
|
|
1155 #ifdef YYERROR_VERBOSE
|
|
|
1156 yyn = yypact[yystate];
|
|
|
1157
|
|
|
1158 if (yyn > YYFLAG && yyn < YYLAST)
|
|
|
1159 {
|
|
|
1160 YYSIZE_T yysize = 0;
|
|
|
1161 char *yymsg;
|
|
|
1162 int yyx, yycount;
|
|
|
1163
|
|
|
1164 yycount = 0;
|
|
|
1165 /* Start YYX at -YYN if negative to avoid negative indexes in
|
|
|
1166 YYCHECK. */
|
|
|
1167 for (yyx = yyn < 0 ? -yyn : 0;
|
|
|
1168 yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
|
|
|
1169 if (yycheck[yyx + yyn] == yyx)
|
|
|
1170 yysize += yystrlen (yytname[yyx]) + 15, yycount++;
|
|
|
1171 yysize += yystrlen ("parse error, unexpected ") + 1;
|
|
|
1172 yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);
|
|
|
1173 yymsg = (char *) YYSTACK_ALLOC (yysize);
|
|
|
1174 if (yymsg != 0)
|
|
|
1175 {
|
|
|
1176 char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
|
|
|
1177 yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);
|
|
|
1178
|
|
|
1179 if (yycount < 5)
|
|
|
1180 {
|
|
|
1181 yycount = 0;
|
|
|
1182 for (yyx = yyn < 0 ? -yyn : 0;
|
|
|
1183 yyx < (int) (sizeof (yytname) / sizeof (char *));
|
|
|
1184 yyx++)
|
|
|
1185 if (yycheck[yyx + yyn] == yyx)
|
|
|
1186 {
|
|
|
1187 const char *yyq = ! yycount ? ", expecting " : " or ";
|
|
|
1188 yyp = yystpcpy (yyp, yyq);
|
|
|
1189 yyp = yystpcpy (yyp, yytname[yyx]);
|
|
|
1190 yycount++;
|
|
|
1191 }
|
|
|
1192 }
|
|
|
1193 yyerror (yymsg);
|
|
|
1194 YYSTACK_FREE (yymsg);
|
|
|
1195 }
|
|
|
1196 else
|
|
|
1197 yyerror ("parse error; also virtual memory exhausted");
|
|
|
1198 }
|
|
|
1199 else
|
|
|
1200 #endif /* defined (YYERROR_VERBOSE) */
|
|
|
1201 yyerror ("parse error");
|
|
|
1202 }
|
|
|
1203 goto yyerrlab1;
|
|
|
1204
|
|
|
1205
|
|
|
1206 /*--------------------------------------------------.
|
|
|
1207 | yyerrlab1 -- error raised explicitly by an action |
|
|
|
1208 `--------------------------------------------------*/
|
|
|
1209 yyerrlab1:
|
|
|
1210 if (yyerrstatus == 3)
|
|
|
1211 {
|
|
|
1212 /* If just tried and failed to reuse lookahead token after an
|
|
|
1213 error, discard it. */
|
|
|
1214
|
|
|
1215 /* return failure if at end of input */
|
|
|
1216 if (yychar == YYEOF)
|
|
|
1217 YYABORT;
|
|
|
1218 YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
|
|
|
1219 yychar, yytname[yychar1]));
|
|
|
1220 yychar = YYEMPTY;
|
|
|
1221 }
|
|
|
1222
|
|
|
1223 /* Else will try to reuse lookahead token after shifting the error
|
|
|
1224 token. */
|
|
|
1225
|
|
|
1226 yyerrstatus = 3; /* Each real token shifted decrements this */
|
|
|
1227
|
|
|
1228 goto yyerrhandle;
|
|
|
1229
|
|
|
1230
|
|
|
1231 /*-------------------------------------------------------------------.
|
|
|
1232 | yyerrdefault -- current state does not do anything special for the |
|
|
|
1233 | error token. |
|
|
|
1234 `-------------------------------------------------------------------*/
|
|
|
1235 yyerrdefault:
|
|
|
1236 #if 0
|
|
|
1237 /* This is wrong; only states that explicitly want error tokens
|
|
|
1238 should shift them. */
|
|
|
1239
|
|
|
1240 /* If its default is to accept any token, ok. Otherwise pop it. */
|
|
|
1241 yyn = yydefact[yystate];
|
|
|
1242 if (yyn)
|
|
|
1243 goto yydefault;
|
|
|
1244 #endif
|
|
|
1245
|
|
|
1246
|
|
|
1247 /*---------------------------------------------------------------.
|
|
|
1248 | yyerrpop -- pop the current state because it cannot handle the |
|
|
|
1249 | error token |
|
|
|
1250 `---------------------------------------------------------------*/
|
|
|
1251 yyerrpop:
|
|
|
1252 if (yyssp == yyss)
|
|
|
1253 YYABORT;
|
|
|
1254 yyvsp--;
|
|
|
1255 yystate = *--yyssp;
|
|
|
1256 #if YYLSP_NEEDED
|
|
|
1257 yylsp--;
|
|
|
1258 #endif
|
|
|
1259
|
|
|
1260 #if YYDEBUG
|
|
|
1261 if (yydebug)
|
|
|
1262 {
|
|
|
1263 short *yyssp1 = yyss - 1;
|
|
|
1264 YYFPRINTF (stderr, "Error: state stack now");
|
|
|
1265 while (yyssp1 != yyssp)
|
|
|
1266 YYFPRINTF (stderr, " %d", *++yyssp1);
|
|
|
1267 YYFPRINTF (stderr, "\n");
|
|
|
1268 }
|
|
|
1269 #endif
|
|
|
1270
|
|
|
1271 /*--------------.
|
|
|
1272 | yyerrhandle. |
|
|
|
1273 `--------------*/
|
|
|
1274 yyerrhandle:
|
|
|
1275 yyn = yypact[yystate];
|
|
|
1276 if (yyn == YYFLAG)
|
|
|
1277 goto yyerrdefault;
|
|
|
1278
|
|
|
1279 yyn += YYTERROR;
|
|
|
1280 if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
|
|
|
1281 goto yyerrdefault;
|
|
|
1282
|
|
|
1283 yyn = yytable[yyn];
|
|
|
1284 if (yyn < 0)
|
|
|
1285 {
|
|
|
1286 if (yyn == YYFLAG)
|
|
|
1287 goto yyerrpop;
|
|
|
1288 yyn = -yyn;
|
|
|
1289 goto yyreduce;
|
|
|
1290 }
|
|
|
1291 else if (yyn == 0)
|
|
|
1292 goto yyerrpop;
|
|
|
1293
|
|
|
1294 if (yyn == YYFINAL)
|
|
|
1295 YYACCEPT;
|
|
|
1296
|
|
|
1297 YYDPRINTF ((stderr, "Shifting error token, "));
|
|
|
1298
|
|
|
1299 *++yyvsp = yylval;
|
|
|
1300 #if YYLSP_NEEDED
|
|
|
1301 *++yylsp = yylloc;
|
|
|
1302 #endif
|
|
|
1303
|
|
|
1304 yystate = yyn;
|
|
|
1305 goto yynewstate;
|
|
|
1306
|
|
|
1307
|
|
|
1308 /*-------------------------------------.
|
|
|
1309 | yyacceptlab -- YYACCEPT comes here. |
|
|
|
1310 `-------------------------------------*/
|
|
|
1311 yyacceptlab:
|
|
|
1312 yyresult = 0;
|
|
|
1313 goto yyreturn;
|
|
|
1314
|
|
|
1315 /*-----------------------------------.
|
|
|
1316 | yyabortlab -- YYABORT comes here. |
|
|
|
1317 `-----------------------------------*/
|
|
|
1318 yyabortlab:
|
|
|
1319 yyresult = 1;
|
|
|
1320 goto yyreturn;
|
|
|
1321
|
|
|
1322 /*---------------------------------------------.
|
|
|
1323 | yyoverflowab -- parser overflow comes here. |
|
|
|
1324 `---------------------------------------------*/
|
|
|
1325 yyoverflowlab:
|
|
|
1326 yyerror ("parser stack overflow");
|
|
|
1327 yyresult = 2;
|
|
|
1328 /* Fall through. */
|
|
|
1329
|
|
|
1330 yyreturn:
|
|
|
1331 #ifndef yyoverflow
|
|
|
1332 if (yyss != yyssa)
|
|
|
1333 YYSTACK_FREE (yyss);
|
|
|
1334 #endif
|
|
|
1335 return yyresult;
|
|
|
1336 }
|
|
|
1337 #line 229 "plural.y"
|
|
|
1338
|
|
|
1339
|
|
|
1340 void
|
|
|
1341 internal_function
|
|
|
1342 FREE_EXPRESSION (exp)
|
|
|
1343 struct expression *exp;
|
|
|
1344 {
|
|
|
1345 if (exp == NULL)
|
|
|
1346 return;
|
|
|
1347
|
|
|
1348 /* Handle the recursive case. */
|
|
|
1349 switch (exp->nargs)
|
|
|
1350 {
|
|
|
1351 case 3:
|
|
|
1352 FREE_EXPRESSION (exp->val.args[2]);
|
|
|
1353 /* FALLTHROUGH */
|
|
|
1354 case 2:
|
|
|
1355 FREE_EXPRESSION (exp->val.args[1]);
|
|
|
1356 /* FALLTHROUGH */
|
|
|
1357 case 1:
|
|
|
1358 FREE_EXPRESSION (exp->val.args[0]);
|
|
|
1359 /* FALLTHROUGH */
|
|
|
1360 default:
|
|
|
1361 break;
|
|
|
1362 }
|
|
|
1363
|
|
|
1364 free (exp);
|
|
|
1365 }
|
|
|
1366
|
|
|
1367
|
|
|
1368 static int
|
|
|
1369 yylex (lval, pexp)
|
|
|
1370 YYSTYPE *lval;
|
|
|
1371 const char **pexp;
|
|
|
1372 {
|
|
|
1373 const char *exp = *pexp;
|
|
|
1374 int result;
|
|
|
1375
|
|
|
1376 while (1)
|
|
|
1377 {
|
|
|
1378 if (exp[0] == '\0')
|
|
|
1379 {
|
|
|
1380 *pexp = exp;
|
|
|
1381 return YYEOF;
|
|
|
1382 }
|
|
|
1383
|
|
|
1384 if (exp[0] != ' ' && exp[0] != '\t')
|
|
|
1385 break;
|
|
|
1386
|
|
|
1387 ++exp;
|
|
|
1388 }
|
|
|
1389
|
|
|
1390 result = *exp++;
|
|
|
1391 switch (result)
|
|
|
1392 {
|
|
|
1393 case '0': case '1': case '2': case '3': case '4':
|
|
|
1394 case '5': case '6': case '7': case '8': case '9':
|
|
|
1395 {
|
|
|
1396 unsigned long int n = result - '0';
|
|
|
1397 while (exp[0] >= '0' && exp[0] <= '9')
|
|
|
1398 {
|
|
|
1399 n *= 10;
|
|
|
1400 n += exp[0] - '0';
|
|
|
1401 ++exp;
|
|
|
1402 }
|
|
|
1403 lval->num = n;
|
|
|
1404 result = NUMBER;
|
|
|
1405 }
|
|
|
1406 break;
|
|
|
1407
|
|
|
1408 case '=':
|
|
|
1409 if (exp[0] == '=')
|
|
|
1410 {
|
|
|
1411 ++exp;
|
|
|
1412 lval->op = equal;
|
|
|
1413 result = EQUOP2;
|
|
|
1414 }
|
|
|
1415 else
|
|
|
1416 result = YYERRCODE;
|
|
|
1417 break;
|
|
|
1418
|
|
|
1419 case '!':
|
|
|
1420 if (exp[0] == '=')
|
|
|
1421 {
|
|
|
1422 ++exp;
|
|
|
1423 lval->op = not_equal;
|
|
|
1424 result = EQUOP2;
|
|
|
1425 }
|
|
|
1426 break;
|
|
|
1427
|
|
|
1428 case '&':
|
|
|
1429 case '|':
|
|
|
1430 if (exp[0] == result)
|
|
|
1431 ++exp;
|
|
|
1432 else
|
|
|
1433 result = YYERRCODE;
|
|
|
1434 break;
|
|
|
1435
|
|
|
1436 case '<':
|
|
|
1437 if (exp[0] == '=')
|
|
|
1438 {
|
|
|
1439 ++exp;
|
|
|
1440 lval->op = less_or_equal;
|
|
|
1441 }
|
|
|
1442 else
|
|
|
1443 lval->op = less_than;
|
|
|
1444 result = CMPOP2;
|
|
|
1445 break;
|
|
|
1446
|
|
|
1447 case '>':
|
|
|
1448 if (exp[0] == '=')
|
|
|
1449 {
|
|
|
1450 ++exp;
|
|
|
1451 lval->op = greater_or_equal;
|
|
|
1452 }
|
|
|
1453 else
|
|
|
1454 lval->op = greater_than;
|
|
|
1455 result = CMPOP2;
|
|
|
1456 break;
|
|
|
1457
|
|
|
1458 case '*':
|
|
|
1459 lval->op = mult;
|
|
|
1460 result = MULOP2;
|
|
|
1461 break;
|
|
|
1462
|
|
|
1463 case '/':
|
|
|
1464 lval->op = divide;
|
|
|
1465 result = MULOP2;
|
|
|
1466 break;
|
|
|
1467
|
|
|
1468 case '%':
|
|
|
1469 lval->op = module;
|
|
|
1470 result = MULOP2;
|
|
|
1471 break;
|
|
|
1472
|
|
|
1473 case '+':
|
|
|
1474 lval->op = plus;
|
|
|
1475 result = ADDOP2;
|
|
|
1476 break;
|
|
|
1477
|
|
|
1478 case '-':
|
|
|
1479 lval->op = minus;
|
|
|
1480 result = ADDOP2;
|
|
|
1481 break;
|
|
|
1482
|
|
|
1483 case 'n':
|
|
|
1484 case '?':
|
|
|
1485 case ':':
|
|
|
1486 case '(':
|
|
|
1487 case ')':
|
|
|
1488 /* Nothing, just return the character. */
|
|
|
1489 break;
|
|
|
1490
|
|
|
1491 case ';':
|
|
|
1492 case '\n':
|
|
|
1493 case '\0':
|
|
|
1494 /* Be safe and let the user call this function again. */
|
|
|
1495 --exp;
|
|
|
1496 result = YYEOF;
|
|
|
1497 break;
|
|
|
1498
|
|
|
1499 default:
|
|
|
1500 result = YYERRCODE;
|
|
|
1501 #if YYDEBUG != 0
|
|
|
1502 --exp;
|
|
|
1503 #endif
|
|
|
1504 break;
|
|
|
1505 }
|
|
|
1506
|
|
|
1507 *pexp = exp;
|
|
|
1508
|
|
|
1509 return result;
|
|
|
1510 }
|
|
|
1511
|
|
|
1512
|
|
|
1513 static void
|
|
|
1514 yyerror (str)
|
|
|
1515 const char *str;
|
|
|
1516 {
|
|
|
1517 /* Do nothing. We don't print error messages here. */
|
|
|
1518 }
|
