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