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