1 /* $NetBSD: plural.c,v 1.1.1.1 2016/01/10 21:36:18 christos Exp $ */
2
3
4 /* A Bison parser, made from plural.y
5 by GNU Bison version 1.28 */
6
7 #define YYBISON 1 /* Identify Bison output. */
8
9 #define yyparse __gettextparse
10 #define yylex __gettextlex
11 #define yyerror __gettexterror
12 #define yylval __gettextlval
13 #define yychar __gettextchar
14 #define yydebug __gettextdebug
15 #define yynerrs __gettextnerrs
16 #define EQUOP2 257
17 #define CMPOP2 258
18 #define ADDOP2 259
19 #define MULOP2 260
20 #define NUMBER 261
21
22 #line 1 "plural.y"
23
24 /* Expression parsing for plural form selection.
25 Copyright (C) 2000, 2001 Free Software Foundation, Inc.
26 Written by Ulrich Drepper <drepper@cygnus.com>, 2000.
27
28 This program is free software; you can redistribute it and/or modify it
29 under the terms of the GNU Library General Public License as published
30 by the Free Software Foundation; either version 2, or (at your option)
31 any later version.
32
33 This program is distributed in the hope that it will be useful,
34 but WITHOUT ANY WARRANTY; without even the implied warranty of
35 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
36 Library General Public License for more details.
37
38 You should have received a copy of the GNU Library General Public
39 License along with this program; if not, write to the Free Software
40 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
41 USA. */
42
43 /* The bison generated parser uses alloca. AIX 3 forces us to put this
44 declaration at the beginning of the file. The declaration in bison's
45 skeleton file comes too late. This must come before <config.h>
46 because <config.h> may include arbitrary system headers. */
47 #if defined _AIX && !defined __GNUC__
48 #pragma alloca
49 #endif
50
51 #ifdef HAVE_CONFIG_H
52 # include <config.h>
53 #endif
54
55 #include <stddef.h>
56 #include <stdlib.h>
57 #include "plural-exp.h"
58
59 /* The main function generated by the parser is called __gettextparse,
60 but we want it to be called PLURAL_PARSE. */
61 #ifndef _LIBC
62 # define __gettextparse PLURAL_PARSE
63 #endif
64
65 #define YYLEX_PARAM &((struct parse_args *) arg)->cp
66 #define YYPARSE_PARAM arg
67
68 #line 49 "plural.y"
69 typedef union {
70 unsigned long int num;
71 enum operator op;
72 struct expression *exp;
73 } YYSTYPE;
74 #line 55 "plural.y"
75
76 /* Prototypes for local functions. */
77 static struct expression *new_exp PARAMS ((int nargs, enum operator op,
78 struct expression * const *args));
79 static inline struct expression *new_exp_0 PARAMS ((enum operator op));
80 static inline struct expression *new_exp_1 PARAMS ((enum operator op,
81 struct expression *right));
82 static struct expression *new_exp_2 PARAMS ((enum operator op,
83 struct expression *left,
84 struct expression *right));
85 static inline struct expression *new_exp_3 PARAMS ((enum operator op,
86 struct expression *bexp,
87 struct expression *tbranch,
88 struct expression *fbranch));
89 static int yylex PARAMS ((YYSTYPE *lval, const char **pexp));
90 static void yyerror PARAMS ((const char *str));
91
92 /* Allocation of expressions. */
93
94 static struct expression *
new_exp(nargs,op,args)95 new_exp (nargs, op, args)
96 int nargs;
97 enum operator op;
98 struct expression * const *args;
99 {
100 int i;
101 struct expression *newp;
102
103 /* If any of the argument could not be malloc'ed, just return NULL. */
104 for (i = nargs - 1; i >= 0; i--)
105 if (args[i] == NULL)
106 goto fail;
107
108 /* Allocate a new expression. */
109 newp = (struct expression *) malloc (sizeof (*newp));
110 if (newp != NULL)
111 {
112 newp->nargs = nargs;
113 newp->operation = op;
114 for (i = nargs - 1; i >= 0; i--)
115 newp->val.args[i] = args[i];
116 return newp;
117 }
118
119 fail:
120 for (i = nargs - 1; i >= 0; i--)
121 FREE_EXPRESSION (args[i]);
122
123 return NULL;
124 }
125
126 static inline struct expression *
new_exp_0(op)127 new_exp_0 (op)
128 enum operator op;
129 {
130 return new_exp (0, op, NULL);
131 }
132
133 static inline struct expression *
new_exp_1(op,right)134 new_exp_1 (op, right)
135 enum operator op;
136 struct expression *right;
137 {
138 struct expression *args[1];
139
140 args[0] = right;
141 return new_exp (1, op, args);
142 }
143
144 static struct expression *
new_exp_2(op,left,right)145 new_exp_2 (op, left, right)
146 enum operator op;
147 struct expression *left;
148 struct expression *right;
149 {
150 struct expression *args[2];
151
152 args[0] = left;
153 args[1] = right;
154 return new_exp (2, op, args);
155 }
156
157 static inline struct expression *
new_exp_3(op,bexp,tbranch,fbranch)158 new_exp_3 (op, bexp, tbranch, fbranch)
159 enum operator op;
160 struct expression *bexp;
161 struct expression *tbranch;
162 struct expression *fbranch;
163 {
164 struct expression *args[3];
165
166 args[0] = bexp;
167 args[1] = tbranch;
168 args[2] = fbranch;
169 return new_exp (3, op, args);
170 }
171
172 #include <stdio.h>
173
174 #ifndef __cplusplus
175 #ifndef __STDC__
176 #define const
177 #endif
178 #endif
179
180
181
182 #define YYFINAL 27
183 #define YYFLAG -32768
184 #define YYNTBASE 16
185
186 #define YYTRANSLATE(x) ((unsigned)(x) <= 261 ? yytranslate[x] : 18)
187
188 static const char yytranslate[] = { 0,
189 2, 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, 10, 2, 2, 2, 2, 5, 2, 14,
193 15, 2, 2, 2, 2, 2, 2, 2, 2, 2,
194 2, 2, 2, 2, 2, 2, 2, 12, 2, 2,
195 2, 2, 3, 2, 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, 13,
200 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
201 2, 2, 2, 4, 2, 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, 1, 6, 7, 8, 9,
215 11
216 };
217
218 #if YYDEBUG != 0
219 static const short yyprhs[] = { 0,
220 0, 2, 8, 12, 16, 20, 24, 28, 32, 35,
221 37, 39
222 };
223
224 static const short yyrhs[] = { 17,
225 0, 17, 3, 17, 12, 17, 0, 17, 4, 17,
226 0, 17, 5, 17, 0, 17, 6, 17, 0, 17,
227 7, 17, 0, 17, 8, 17, 0, 17, 9, 17,
228 0, 10, 17, 0, 13, 0, 11, 0, 14, 17,
229 15, 0
230 };
231
232 #endif
233
234 #if YYDEBUG != 0
235 static const short yyrline[] = { 0,
236 174, 182, 186, 190, 194, 198, 202, 206, 210, 214,
237 218, 223
238 };
239 #endif
240
241
242 #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
243
244 static const char * const yytname[] = { "$","error","$undefined.","'?'","'|'",
245 "'&'","EQUOP2","CMPOP2","ADDOP2","MULOP2","'!'","NUMBER","':'","'n'","'('","')'",
246 "start","exp", NULL
247 };
248 #endif
249
250 static const short yyr1[] = { 0,
251 16, 17, 17, 17, 17, 17, 17, 17, 17, 17,
252 17, 17
253 };
254
255 static const short yyr2[] = { 0,
256 1, 5, 3, 3, 3, 3, 3, 3, 2, 1,
257 1, 3
258 };
259
260 static const short yydefact[] = { 0,
261 0, 11, 10, 0, 1, 9, 0, 0, 0, 0,
262 0, 0, 0, 0, 12, 0, 3, 4, 5, 6,
263 7, 8, 0, 2, 0, 0, 0
264 };
265
266 static const short yydefgoto[] = { 25,
267 5
268 };
269
270 static const short yypact[] = { -9,
271 -9,-32768,-32768, -9, 34,-32768, 11, -9, -9, -9,
272 -9, -9, -9, -9,-32768, 24, 39, 43, 16, 26,
273 -3,-32768, -9, 34, 21, 53,-32768
274 };
275
276 static const short yypgoto[] = {-32768,
277 -1
278 };
279
280
281 #define YYLAST 53
282
283
284 static const short yytable[] = { 6,
285 1, 2, 7, 3, 4, 14, 16, 17, 18, 19,
286 20, 21, 22, 8, 9, 10, 11, 12, 13, 14,
287 26, 24, 12, 13, 14, 15, 8, 9, 10, 11,
288 12, 13, 14, 13, 14, 23, 8, 9, 10, 11,
289 12, 13, 14, 10, 11, 12, 13, 14, 11, 12,
290 13, 14, 27
291 };
292
293 static const short yycheck[] = { 1,
294 10, 11, 4, 13, 14, 9, 8, 9, 10, 11,
295 12, 13, 14, 3, 4, 5, 6, 7, 8, 9,
296 0, 23, 7, 8, 9, 15, 3, 4, 5, 6,
297 7, 8, 9, 8, 9, 12, 3, 4, 5, 6,
298 7, 8, 9, 5, 6, 7, 8, 9, 6, 7,
299 8, 9, 0
300 };
301 #define YYPURE 1
302
303 /* -*-C-*- Note some compilers choke on comments on `#line' lines. */
304 #line 3 "/usr/local/share/bison.simple"
305 /* This file comes from bison-1.28. */
306
307 /* Skeleton output parser for bison,
308 Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
309
310 This program is free software; you can redistribute it and/or modify
311 it under the terms of the GNU General Public License as published by
312 the Free Software Foundation; either version 2, or (at your option)
313 any later version.
314
315 This program is distributed in the hope that it will be useful,
316 but WITHOUT ANY WARRANTY; without even the implied warranty of
317 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
318 GNU General Public License for more details.
319
320 You should have received a copy of the GNU General Public License
321 along with this program; if not, write to the Free Software
322 Foundation, Inc., 59 Temple Place - Suite 330,
323 Boston, MA 02111-1307, USA. */
324
325 /* As a special exception, when this file is copied by Bison into a
326 Bison output file, you may use that output file without restriction.
327 This special exception was added by the Free Software Foundation
328 in version 1.24 of Bison. */
329
330 /* This is the parser code that is written into each bison parser
331 when the %semantic_parser declaration is not specified in the grammar.
332 It was written by Richard Stallman by simplifying the hairy parser
333 used when %semantic_parser is specified. */
334
335 #ifndef YYSTACK_USE_ALLOCA
336 #ifdef alloca
337 #define YYSTACK_USE_ALLOCA
338 #else /* alloca not defined */
339 #ifdef __GNUC__
340 #define YYSTACK_USE_ALLOCA
341 #define alloca __builtin_alloca
342 #else /* not GNU C. */
343 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
344 #define YYSTACK_USE_ALLOCA
345 #include <alloca.h>
346 #else /* not sparc */
347 /* We think this test detects Watcom and Microsoft C. */
348 /* This used to test MSDOS, but that is a bad idea
349 since that symbol is in the user namespace. */
350 #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
351 #if 0 /* No need for malloc.h, which pollutes the namespace;
352 instead, just don't use alloca. */
353 #include <malloc.h>
354 #endif
355 #else /* not MSDOS, or __TURBOC__ */
356 #if defined(_AIX)
357 /* I don't know what this was needed for, but it pollutes the namespace.
358 So I turned it off. rms, 2 May 1997. */
359 /* #include <malloc.h> */
360 #pragma alloca
361 #define YYSTACK_USE_ALLOCA
362 #else /* not MSDOS, or __TURBOC__, or _AIX */
363 #if 0
364 #ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
365 and on HPUX 10. Eventually we can turn this on. */
366 #define YYSTACK_USE_ALLOCA
367 #define alloca __builtin_alloca
368 #endif /* __hpux */
369 #endif
370 #endif /* not _AIX */
371 #endif /* not MSDOS, or __TURBOC__ */
372 #endif /* not sparc */
373 #endif /* not GNU C */
374 #endif /* alloca not defined */
375 #endif /* YYSTACK_USE_ALLOCA not defined */
376
377 #ifdef YYSTACK_USE_ALLOCA
378 #define YYSTACK_ALLOC alloca
379 #else
380 #define YYSTACK_ALLOC malloc
381 #endif
382
383 /* Note: there must be only one dollar sign in this file.
384 It is replaced by the list of actions, each action
385 as one case of the switch. */
386
387 #define yyerrok (yyerrstatus = 0)
388 #define yyclearin (yychar = YYEMPTY)
389 #define YYEMPTY -2
390 #define YYEOF 0
391 #define YYACCEPT goto yyacceptlab
392 #define YYABORT goto yyabortlab
393 #define YYERROR goto yyerrlab1
394 /* Like YYERROR except do call yyerror.
395 This remains here temporarily to ease the
396 transition to the new meaning of YYERROR, for GCC.
397 Once GCC version 2 has supplanted version 1, this can go. */
398 #define YYFAIL goto yyerrlab
399 #define YYRECOVERING() (!!yyerrstatus)
400 #define YYBACKUP(token, value) \
401 do \
402 if (yychar == YYEMPTY && yylen == 1) \
403 { yychar = (token), yylval = (value); \
404 yychar1 = YYTRANSLATE (yychar); \
405 YYPOPSTACK; \
406 goto yybackup; \
407 } \
408 else \
409 { yyerror ("syntax error: cannot back up"); YYERROR; } \
410 while (0)
411
412 #define YYTERROR 1
413 #define YYERRCODE 256
414
415 #ifndef YYPURE
416 #define YYLEX yylex()
417 #endif
418
419 #ifdef YYPURE
420 #ifdef YYLSP_NEEDED
421 #ifdef YYLEX_PARAM
422 #define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM)
423 #else
424 #define YYLEX yylex(&yylval, &yylloc)
425 #endif
426 #else /* not YYLSP_NEEDED */
427 #ifdef YYLEX_PARAM
428 #define YYLEX yylex(&yylval, YYLEX_PARAM)
429 #else
430 #define YYLEX yylex(&yylval)
431 #endif
432 #endif /* not YYLSP_NEEDED */
433 #endif
434
435 /* If nonreentrant, generate the variables here */
436
437 #ifndef YYPURE
438
439 int yychar; /* the lookahead symbol */
440 YYSTYPE yylval; /* the semantic value of the */
441 /* lookahead symbol */
442
443 #ifdef YYLSP_NEEDED
444 YYLTYPE yylloc; /* location data for the lookahead */
445 /* symbol */
446 #endif
447
448 int yynerrs; /* number of parse errors so far */
449 #endif /* not YYPURE */
450
451 #if YYDEBUG != 0
452 int yydebug; /* nonzero means print parse trace */
453 /* Since this is uninitialized, it does not stop multiple parsers
454 from coexisting. */
455 #endif
456
457 /* YYINITDEPTH indicates the initial size of the parser's stacks */
458
459 #ifndef YYINITDEPTH
460 #define YYINITDEPTH 200
461 #endif
462
463 /* YYMAXDEPTH is the maximum size the stacks can grow to
464 (effective only if the built-in stack extension method is used). */
465
466 #if YYMAXDEPTH == 0
467 #undef YYMAXDEPTH
468 #endif
469
470 #ifndef YYMAXDEPTH
471 #define YYMAXDEPTH 10000
472 #endif
473
474 /* Define __yy_memcpy. Note that the size argument
475 should be passed with type unsigned int, because that is what the non-GCC
476 definitions require. With GCC, __builtin_memcpy takes an arg
477 of type size_t, but it can handle unsigned int. */
478
479 #if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
480 #define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT)
481 #else /* not GNU C or C++ */
482 #ifndef __cplusplus
483
484 /* This is the most reliable way to avoid incompatibilities
485 in available built-in functions on various systems. */
486 static void
__yy_memcpy(to,from,count)487 __yy_memcpy (to, from, count)
488 char *to;
489 char *from;
490 unsigned int count;
491 {
492 register char *f = from;
493 register char *t = to;
494 register int i = count;
495
496 while (i-- > 0)
497 *t++ = *f++;
498 }
499
500 #else /* __cplusplus */
501
502 /* This is the most reliable way to avoid incompatibilities
503 in available built-in functions on various systems. */
504 static void
__yy_memcpy(char * to,char * from,unsigned int count)505 __yy_memcpy (char *to, char *from, unsigned int count)
506 {
507 register char *t = to;
508 register char *f = from;
509 register int i = count;
510
511 while (i-- > 0)
512 *t++ = *f++;
513 }
514
515 #endif
516 #endif
517
518 #line 217 "/usr/local/share/bison.simple"
519
520 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
521 into yyparse. The argument should have type void *.
522 It should actually point to an object.
523 Grammar actions can access the variable by casting it
524 to the proper pointer type. */
525
526 #ifdef YYPARSE_PARAM
527 #ifdef __cplusplus
528 #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
529 #define YYPARSE_PARAM_DECL
530 #else /* not __cplusplus */
531 #define YYPARSE_PARAM_ARG YYPARSE_PARAM
532 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
533 #endif /* not __cplusplus */
534 #else /* not YYPARSE_PARAM */
535 #define YYPARSE_PARAM_ARG
536 #define YYPARSE_PARAM_DECL
537 #endif /* not YYPARSE_PARAM */
538
539 /* Prevent warning if -Wstrict-prototypes. */
540 #ifdef __GNUC__
541 #ifdef YYPARSE_PARAM
542 int yyparse (void *);
543 #else
544 int yyparse (void);
545 #endif
546 #endif
547
548 int
yyparse(YYPARSE_PARAM_ARG)549 yyparse(YYPARSE_PARAM_ARG)
550 YYPARSE_PARAM_DECL
551 {
552 register int yystate;
553 register int yyn;
554 register short *yyssp;
555 register YYSTYPE *yyvsp;
556 int yyerrstatus; /* number of tokens to shift before error messages enabled */
557 int yychar1 = 0; /* lookahead token as an internal (translated) token number */
558
559 short yyssa[YYINITDEPTH]; /* the state stack */
560 YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */
561
562 short *yyss = yyssa; /* refer to the stacks thru separate pointers */
563 YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */
564
565 #ifdef YYLSP_NEEDED
566 YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */
567 YYLTYPE *yyls = yylsa;
568 YYLTYPE *yylsp;
569
570 #define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
571 #else
572 #define YYPOPSTACK (yyvsp--, yyssp--)
573 #endif
574
575 int yystacksize = YYINITDEPTH;
576 int yyfree_stacks = 0;
577
578 #ifdef YYPURE
579 int yychar;
580 YYSTYPE yylval;
581 int yynerrs;
582 #ifdef YYLSP_NEEDED
583 YYLTYPE yylloc;
584 #endif
585 #endif
586
587 YYSTYPE yyval; /* the variable used to return */
588 /* semantic values from the action */
589 /* routines */
590
591 int yylen;
592
593 #if YYDEBUG != 0
594 if (yydebug)
595 fprintf(stderr, "Starting parse\n");
596 #endif
597
598 yystate = 0;
599 yyerrstatus = 0;
600 yynerrs = 0;
601 yychar = YYEMPTY; /* Cause a token to be read. */
602
603 /* Initialize stack pointers.
604 Waste one element of value and location stack
605 so that they stay on the same level as the state stack.
606 The wasted elements are never initialized. */
607
608 yyssp = yyss - 1;
609 yyvsp = yyvs;
610 #ifdef YYLSP_NEEDED
611 yylsp = yyls;
612 #endif
613
614 /* Push a new state, which is found in yystate . */
615 /* In all cases, when you get here, the value and location stacks
616 have just been pushed. so pushing a state here evens the stacks. */
617 yynewstate:
618
619 *++yyssp = yystate;
620
621 if (yyssp >= yyss + yystacksize - 1)
622 {
623 /* Give user a chance to reallocate the stack */
624 /* Use copies of these so that the &'s don't force the real ones into memory. */
625 YYSTYPE *yyvs1 = yyvs;
626 short *yyss1 = yyss;
627 #ifdef YYLSP_NEEDED
628 YYLTYPE *yyls1 = yyls;
629 #endif
630
631 /* Get the current used size of the three stacks, in elements. */
632 int size = yyssp - yyss + 1;
633
634 #ifdef yyoverflow
635 /* Each stack pointer address is followed by the size of
636 the data in use in that stack, in bytes. */
637 #ifdef YYLSP_NEEDED
638 /* This used to be a conditional around just the two extra args,
639 but that might be undefined if yyoverflow is a macro. */
640 yyoverflow("parser stack overflow",
641 &yyss1, size * sizeof (*yyssp),
642 &yyvs1, size * sizeof (*yyvsp),
643 &yyls1, size * sizeof (*yylsp),
644 &yystacksize);
645 #else
646 yyoverflow("parser stack overflow",
647 &yyss1, size * sizeof (*yyssp),
648 &yyvs1, size * sizeof (*yyvsp),
649 &yystacksize);
650 #endif
651
652 yyss = yyss1; yyvs = yyvs1;
653 #ifdef YYLSP_NEEDED
654 yyls = yyls1;
655 #endif
656 #else /* no yyoverflow */
657 /* Extend the stack our own way. */
658 if (yystacksize >= YYMAXDEPTH)
659 {
660 yyerror("parser stack overflow");
661 if (yyfree_stacks)
662 {
663 free (yyss);
664 free (yyvs);
665 #ifdef YYLSP_NEEDED
666 free (yyls);
667 #endif
668 }
669 return 2;
670 }
671 yystacksize *= 2;
672 if (yystacksize > YYMAXDEPTH)
673 yystacksize = YYMAXDEPTH;
674 #ifndef YYSTACK_USE_ALLOCA
675 yyfree_stacks = 1;
676 #endif
677 yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
678 __yy_memcpy ((char *)yyss, (char *)yyss1,
679 size * (unsigned int) sizeof (*yyssp));
680 yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
681 __yy_memcpy ((char *)yyvs, (char *)yyvs1,
682 size * (unsigned int) sizeof (*yyvsp));
683 #ifdef YYLSP_NEEDED
684 yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
685 __yy_memcpy ((char *)yyls, (char *)yyls1,
686 size * (unsigned int) sizeof (*yylsp));
687 #endif
688 #endif /* no yyoverflow */
689
690 yyssp = yyss + size - 1;
691 yyvsp = yyvs + size - 1;
692 #ifdef YYLSP_NEEDED
693 yylsp = yyls + size - 1;
694 #endif
695
696 #if YYDEBUG != 0
697 if (yydebug)
698 fprintf(stderr, "Stack size increased to %d\n", yystacksize);
699 #endif
700
701 if (yyssp >= yyss + yystacksize - 1)
702 YYABORT;
703 }
704
705 #if YYDEBUG != 0
706 if (yydebug)
707 fprintf(stderr, "Entering state %d\n", yystate);
708 #endif
709
710 goto yybackup;
711 yybackup:
712
713 /* Do appropriate processing given the current state. */
714 /* Read a lookahead token if we need one and don't already have one. */
715 /* yyresume: */
716
717 /* First try to decide what to do without reference to lookahead token. */
718
719 yyn = yypact[yystate];
720 if (yyn == YYFLAG)
721 goto yydefault;
722
723 /* Not known => get a lookahead token if don't already have one. */
724
725 /* yychar is either YYEMPTY or YYEOF
726 or a valid token in external form. */
727
728 if (yychar == YYEMPTY)
729 {
730 #if YYDEBUG != 0
731 if (yydebug)
732 fprintf(stderr, "Reading a token: ");
733 #endif
734 yychar = YYLEX;
735 }
736
737 /* Convert token to internal form (in yychar1) for indexing tables with */
738
739 if (yychar <= 0) /* This means end of input. */
740 {
741 yychar1 = 0;
742 yychar = YYEOF; /* Don't call YYLEX any more */
743
744 #if YYDEBUG != 0
745 if (yydebug)
746 fprintf(stderr, "Now at end of input.\n");
747 #endif
748 }
749 else
750 {
751 yychar1 = YYTRANSLATE(yychar);
752
753 #if YYDEBUG != 0
754 if (yydebug)
755 {
756 fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
757 /* Give the individual parser a way to print the precise meaning
758 of a token, for further debugging info. */
759 #ifdef YYPRINT
760 YYPRINT (stderr, yychar, yylval);
761 #endif
762 fprintf (stderr, ")\n");
763 }
764 #endif
765 }
766
767 yyn += yychar1;
768 if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
769 goto yydefault;
770
771 yyn = yytable[yyn];
772
773 /* yyn is what to do for this token type in this state.
774 Negative => reduce, -yyn is rule number.
775 Positive => shift, yyn is new state.
776 New state is final state => don't bother to shift,
777 just return success.
778 0, or most negative number => error. */
779
780 if (yyn < 0)
781 {
782 if (yyn == YYFLAG)
783 goto yyerrlab;
784 yyn = -yyn;
785 goto yyreduce;
786 }
787 else if (yyn == 0)
788 goto yyerrlab;
789
790 if (yyn == YYFINAL)
791 YYACCEPT;
792
793 /* Shift the lookahead token. */
794
795 #if YYDEBUG != 0
796 if (yydebug)
797 fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
798 #endif
799
800 /* Discard the token being shifted unless it is eof. */
801 if (yychar != YYEOF)
802 yychar = YYEMPTY;
803
804 *++yyvsp = yylval;
805 #ifdef YYLSP_NEEDED
806 *++yylsp = yylloc;
807 #endif
808
809 /* count tokens shifted since error; after three, turn off error status. */
810 if (yyerrstatus) yyerrstatus--;
811
812 yystate = yyn;
813 goto yynewstate;
814
815 /* Do the default action for the current state. */
816 yydefault:
817
818 yyn = yydefact[yystate];
819 if (yyn == 0)
820 goto yyerrlab;
821
822 /* Do a reduction. yyn is the number of a rule to reduce with. */
823 yyreduce:
824 yylen = yyr2[yyn];
825 if (yylen > 0)
826 yyval = yyvsp[1-yylen]; /* implement default value of the action */
827
828 #if YYDEBUG != 0
829 if (yydebug)
830 {
831 int i;
832
833 fprintf (stderr, "Reducing via rule %d (line %d), ",
834 yyn, yyrline[yyn]);
835
836 /* Print the symbols being reduced, and their result. */
837 for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
838 fprintf (stderr, "%s ", yytname[yyrhs[i]]);
839 fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
840 }
841 #endif
842
843
844 switch (yyn) {
845
846 case 1:
847 #line 175 "plural.y"
848 {
849 if (yyvsp[0].exp == NULL)
850 YYABORT;
851 ((struct parse_args *) arg)->res = yyvsp[0].exp;
852 ;
853 break;}
854 case 2:
855 #line 183 "plural.y"
856 {
857 yyval.exp = new_exp_3 (qmop, yyvsp[-4].exp, yyvsp[-2].exp, yyvsp[0].exp);
858 ;
859 break;}
860 case 3:
861 #line 187 "plural.y"
862 {
863 yyval.exp = new_exp_2 (lor, yyvsp[-2].exp, yyvsp[0].exp);
864 ;
865 break;}
866 case 4:
867 #line 191 "plural.y"
868 {
869 yyval.exp = new_exp_2 (land, yyvsp[-2].exp, yyvsp[0].exp);
870 ;
871 break;}
872 case 5:
873 #line 195 "plural.y"
874 {
875 yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
876 ;
877 break;}
878 case 6:
879 #line 199 "plural.y"
880 {
881 yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
882 ;
883 break;}
884 case 7:
885 #line 203 "plural.y"
886 {
887 yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
888 ;
889 break;}
890 case 8:
891 #line 207 "plural.y"
892 {
893 yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
894 ;
895 break;}
896 case 9:
897 #line 211 "plural.y"
898 {
899 yyval.exp = new_exp_1 (lnot, yyvsp[0].exp);
900 ;
901 break;}
902 case 10:
903 #line 215 "plural.y"
904 {
905 yyval.exp = new_exp_0 (var);
906 ;
907 break;}
908 case 11:
909 #line 219 "plural.y"
910 {
911 if ((yyval.exp = new_exp_0 (num)) != NULL)
912 yyval.exp->val.num = yyvsp[0].num;
913 ;
914 break;}
915 case 12:
916 #line 224 "plural.y"
917 {
918 yyval.exp = yyvsp[-1].exp;
919 ;
920 break;}
921 }
922 /* the action file gets copied in in place of this dollarsign */
923 #line 543 "/usr/local/share/bison.simple"
924
925 yyvsp -= yylen;
926 yyssp -= yylen;
927 #ifdef YYLSP_NEEDED
928 yylsp -= yylen;
929 #endif
930
931 #if YYDEBUG != 0
932 if (yydebug)
933 {
934 short *ssp1 = yyss - 1;
935 fprintf (stderr, "state stack now");
936 while (ssp1 != yyssp)
937 fprintf (stderr, " %d", *++ssp1);
938 fprintf (stderr, "\n");
939 }
940 #endif
941
942 *++yyvsp = yyval;
943
944 #ifdef YYLSP_NEEDED
945 yylsp++;
946 if (yylen == 0)
947 {
948 yylsp->first_line = yylloc.first_line;
949 yylsp->first_column = yylloc.first_column;
950 yylsp->last_line = (yylsp-1)->last_line;
951 yylsp->last_column = (yylsp-1)->last_column;
952 yylsp->text = 0;
953 }
954 else
955 {
956 yylsp->last_line = (yylsp+yylen-1)->last_line;
957 yylsp->last_column = (yylsp+yylen-1)->last_column;
958 }
959 #endif
960
961 /* Now "shift" the result of the reduction.
962 Determine what state that goes to,
963 based on the state we popped back to
964 and the rule number reduced by. */
965
966 yyn = yyr1[yyn];
967
968 yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
969 if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
970 yystate = yytable[yystate];
971 else
972 yystate = yydefgoto[yyn - YYNTBASE];
973
974 goto yynewstate;
975
976 yyerrlab: /* here on detecting error */
977
978 if (! yyerrstatus)
979 /* If not already recovering from an error, report this error. */
980 {
981 ++yynerrs;
982
983 #ifdef YYERROR_VERBOSE
984 yyn = yypact[yystate];
985
986 if (yyn > YYFLAG && yyn < YYLAST)
987 {
988 int size = 0;
989 char *msg;
990 int x, count;
991
992 count = 0;
993 /* Start X at -yyn if nec to avoid negative indexes in yycheck. */
994 for (x = (yyn < 0 ? -yyn : 0);
995 x < (sizeof(yytname) / sizeof(char *)); x++)
996 if (yycheck[x + yyn] == x)
997 size += strlen(yytname[x]) + 15, count++;
998 msg = (char *) malloc(size + 15);
999 if (msg != 0)
1000 {
1001 strcpy(msg, "parse error");
1002
1003 if (count < 5)
1004 {
1005 count = 0;
1006 for (x = (yyn < 0 ? -yyn : 0);
1007 x < (sizeof(yytname) / sizeof(char *)); x++)
1008 if (yycheck[x + yyn] == x)
1009 {
1010 strcat(msg, count == 0 ? ", expecting `" : " or `");
1011 strcat(msg, yytname[x]);
1012 strcat(msg, "'");
1013 count++;
1014 }
1015 }
1016 yyerror(msg);
1017 free(msg);
1018 }
1019 else
1020 yyerror ("parse error; also virtual memory exceeded");
1021 }
1022 else
1023 #endif /* YYERROR_VERBOSE */
1024 yyerror("parse error");
1025 }
1026
1027 goto yyerrlab1;
1028 yyerrlab1: /* here on error raised explicitly by an action */
1029
1030 if (yyerrstatus == 3)
1031 {
1032 /* if just tried and failed to reuse lookahead token after an error, discard it. */
1033
1034 /* return failure if at end of input */
1035 if (yychar == YYEOF)
1036 YYABORT;
1037
1038 #if YYDEBUG != 0
1039 if (yydebug)
1040 fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
1041 #endif
1042
1043 yychar = YYEMPTY;
1044 }
1045
1046 /* Else will try to reuse lookahead token
1047 after shifting the error token. */
1048
1049 yyerrstatus = 3; /* Each real token shifted decrements this */
1050
1051 goto yyerrhandle;
1052
1053 yyerrdefault: /* current state does not do anything special for the error token. */
1054
1055 #if 0
1056 /* This is wrong; only states that explicitly want error tokens
1057 should shift them. */
1058 yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
1059 if (yyn) goto yydefault;
1060 #endif
1061
1062 yyerrpop: /* pop the current state because it cannot handle the error token */
1063
1064 if (yyssp == yyss) YYABORT;
1065 yyvsp--;
1066 yystate = *--yyssp;
1067 #ifdef YYLSP_NEEDED
1068 yylsp--;
1069 #endif
1070
1071 #if YYDEBUG != 0
1072 if (yydebug)
1073 {
1074 short *ssp1 = yyss - 1;
1075 fprintf (stderr, "Error: state stack now");
1076 while (ssp1 != yyssp)
1077 fprintf (stderr, " %d", *++ssp1);
1078 fprintf (stderr, "\n");
1079 }
1080 #endif
1081
1082 yyerrhandle:
1083
1084 yyn = yypact[yystate];
1085 if (yyn == YYFLAG)
1086 goto yyerrdefault;
1087
1088 yyn += YYTERROR;
1089 if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
1090 goto yyerrdefault;
1091
1092 yyn = yytable[yyn];
1093 if (yyn < 0)
1094 {
1095 if (yyn == YYFLAG)
1096 goto yyerrpop;
1097 yyn = -yyn;
1098 goto yyreduce;
1099 }
1100 else if (yyn == 0)
1101 goto yyerrpop;
1102
1103 if (yyn == YYFINAL)
1104 YYACCEPT;
1105
1106 #if YYDEBUG != 0
1107 if (yydebug)
1108 fprintf(stderr, "Shifting error token, ");
1109 #endif
1110
1111 *++yyvsp = yylval;
1112 #ifdef YYLSP_NEEDED
1113 *++yylsp = yylloc;
1114 #endif
1115
1116 yystate = yyn;
1117 goto yynewstate;
1118
1119 yyacceptlab:
1120 /* YYACCEPT comes here. */
1121 if (yyfree_stacks)
1122 {
1123 free (yyss);
1124 free (yyvs);
1125 #ifdef YYLSP_NEEDED
1126 free (yyls);
1127 #endif
1128 }
1129 return 0;
1130
1131 yyabortlab:
1132 /* YYABORT comes here. */
1133 if (yyfree_stacks)
1134 {
1135 free (yyss);
1136 free (yyvs);
1137 #ifdef YYLSP_NEEDED
1138 free (yyls);
1139 #endif
1140 }
1141 return 1;
1142 }
1143 #line 229 "plural.y"
1144
1145
1146 void
1147 internal_function
FREE_EXPRESSION(exp)1148 FREE_EXPRESSION (exp)
1149 struct expression *exp;
1150 {
1151 if (exp == NULL)
1152 return;
1153
1154 /* Handle the recursive case. */
1155 switch (exp->nargs)
1156 {
1157 case 3:
1158 FREE_EXPRESSION (exp->val.args[2]);
1159 /* FALLTHROUGH */
1160 case 2:
1161 FREE_EXPRESSION (exp->val.args[1]);
1162 /* FALLTHROUGH */
1163 case 1:
1164 FREE_EXPRESSION (exp->val.args[0]);
1165 /* FALLTHROUGH */
1166 default:
1167 break;
1168 }
1169
1170 free (exp);
1171 }
1172
1173
1174 static int
yylex(lval,pexp)1175 yylex (lval, pexp)
1176 YYSTYPE *lval;
1177 const char **pexp;
1178 {
1179 const char *exp = *pexp;
1180 int result;
1181
1182 while (1)
1183 {
1184 if (exp[0] == '\0')
1185 {
1186 *pexp = exp;
1187 return YYEOF;
1188 }
1189
1190 if (exp[0] != ' ' && exp[0] != '\t')
1191 break;
1192
1193 ++exp;
1194 }
1195
1196 result = *exp++;
1197 switch (result)
1198 {
1199 case '0': case '1': case '2': case '3': case '4':
1200 case '5': case '6': case '7': case '8': case '9':
1201 {
1202 unsigned long int n = result - '0';
1203 while (exp[0] >= '0' && exp[0] <= '9')
1204 {
1205 n *= 10;
1206 n += exp[0] - '0';
1207 ++exp;
1208 }
1209 lval->num = n;
1210 result = NUMBER;
1211 }
1212 break;
1213
1214 case '=':
1215 if (exp[0] == '=')
1216 {
1217 ++exp;
1218 lval->op = equal;
1219 result = EQUOP2;
1220 }
1221 else
1222 result = YYERRCODE;
1223 break;
1224
1225 case '!':
1226 if (exp[0] == '=')
1227 {
1228 ++exp;
1229 lval->op = not_equal;
1230 result = EQUOP2;
1231 }
1232 break;
1233
1234 case '&':
1235 case '|':
1236 if (exp[0] == result)
1237 ++exp;
1238 else
1239 result = YYERRCODE;
1240 break;
1241
1242 case '<':
1243 if (exp[0] == '=')
1244 {
1245 ++exp;
1246 lval->op = less_or_equal;
1247 }
1248 else
1249 lval->op = less_than;
1250 result = CMPOP2;
1251 break;
1252
1253 case '>':
1254 if (exp[0] == '=')
1255 {
1256 ++exp;
1257 lval->op = greater_or_equal;
1258 }
1259 else
1260 lval->op = greater_than;
1261 result = CMPOP2;
1262 break;
1263
1264 case '*':
1265 lval->op = mult;
1266 result = MULOP2;
1267 break;
1268
1269 case '/':
1270 lval->op = divide;
1271 result = MULOP2;
1272 break;
1273
1274 case '%':
1275 lval->op = module;
1276 result = MULOP2;
1277 break;
1278
1279 case '+':
1280 lval->op = plus;
1281 result = ADDOP2;
1282 break;
1283
1284 case '-':
1285 lval->op = minus;
1286 result = ADDOP2;
1287 break;
1288
1289 case 'n':
1290 case '?':
1291 case ':':
1292 case '(':
1293 case ')':
1294 /* Nothing, just return the character. */
1295 break;
1296
1297 case ';':
1298 case '\n':
1299 case '\0':
1300 /* Be safe and let the user call this function again. */
1301 --exp;
1302 result = YYEOF;
1303 break;
1304
1305 default:
1306 result = YYERRCODE;
1307 #if YYDEBUG != 0
1308 --exp;
1309 #endif
1310 break;
1311 }
1312
1313 *pexp = exp;
1314
1315 return result;
1316 }
1317
1318
1319 static void
yyerror(str)1320 yyerror (str)
1321 const char *str;
1322 {
1323 /* Do nothing. We don't print error messages here. */
1324 }
1325