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