• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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., 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 int yylex (YYSTYPE *lval, const char **pexp);
79 static void yyerror (const char *str);
80 
81 /* Allocation of expressions.  */
82 
83 static struct expression *
new_exp(int nargs,enum operator op,struct expression * const * args)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 *
new_exp_0(enum operator op)113 new_exp_0 (enum operator op)
114 {
115   return new_exp (0, op, NULL);
116 }
117 
118 static inline struct expression *
new_exp_1(enum operator op,struct expression * right)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 *
new_exp_2(enum operator op,struct expression * left,struct expression * right)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 *
new_exp_3(enum operator op,struct expression * bexp,struct expression * tbranch,struct expression * fbranch)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., 59 Temple Place - Suite 330,
319    Boston, MA 02111-1307, 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 
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)
yystrlen(const char * yystr)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)
yystpcpy(char * yydest,const char * yysrc)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 
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
yyparse(YYPARSE_PARAM_ARG)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 
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
FREE_EXPRESSION(struct expression * exp)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
yylex(YYSTYPE * lval,const char ** pexp)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
yyerror(const char * str)1487 yyerror (const char *str)
1488 {
1489   /* Do nothing.  We don't print error messages here.  */
1490 }
1491