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