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