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., 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 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 *
new_exp(nargs,op,args)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 *
new_exp_0(op)128 new_exp_0 (op)
129 enum operator op;
130 {
131 return new_exp (0, op, NULL);
132 }
133
134 static inline struct expression *
new_exp_1(op,right)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 *
new_exp_2(op,left,right)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 *
new_exp_3(op,bexp,tbranch,fbranch)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., 51 Franklin Street - Fifth Floor,
343 Boston, MA 02110-1301, 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
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)
yystrlen(const char * yystr)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)
yystpcpy(char * yydest,const char * yysrc)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
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
yyparse(YYPARSE_PARAM_ARG)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
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
FREE_EXPRESSION(exp)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
yylex(lval,pexp)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
yyerror(str)1514 yyerror (str)
1515 const char *str;
1516 {
1517 /* Do nothing. We don't print error messages here. */
1518 }
1519