/[zanavi_public1]/navit/intl/plural.c
ZANavi

Contents of /navit/intl/plural.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2 - (show annotations) (download)
Fri Oct 28 21:19:04 2011 UTC (8 years, 3 months ago) by zoff99
File MIME type: text/plain
File size: 37289 byte(s)
import files
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 *
84 new_exp (int nargs, enum operator op, struct expression * const *args)
85 {
86 int i;
87 struct expression *newp;
88
89 /* If any of the argument could not be malloc'ed, just return NULL. */
90 for (i = nargs - 1; i >= 0; i--)
91 if (args[i] == NULL)
92 goto fail;
93
94 /* Allocate a new expression. */
95 newp = (struct expression *) malloc (sizeof (*newp));
96 if (newp != NULL)
97 {
98 newp->nargs = nargs;
99 newp->operation = op;
100 for (i = nargs - 1; i >= 0; i--)
101 newp->val.args[i] = args[i];
102 return newp;
103 }
104
105 fail:
106 for (i = nargs - 1; i >= 0; i--)
107 FREE_EXPRESSION (args[i]);
108
109 return NULL;
110 }
111
112 static inline struct expression *
113 new_exp_0 (enum operator op)
114 {
115 return new_exp (0, op, NULL);
116 }
117
118 static inline struct expression *
119 new_exp_1 (enum operator op, struct expression *right)
120 {
121 struct expression *args[1];
122
123 args[0] = right;
124 return new_exp (1, op, args);
125 }
126
127 static struct expression *
128 new_exp_2 (enum operator op, struct expression *left, struct expression *right)
129 {
130 struct expression *args[2];
131
132 args[0] = left;
133 args[1] = right;
134 return new_exp (2, op, args);
135 }
136
137 static inline struct expression *
138 new_exp_3 (enum operator op, struct expression *bexp,
139 struct expression *tbranch, struct expression *fbranch)
140 {
141 struct expression *args[3];
142
143 args[0] = bexp;
144 args[1] = tbranch;
145 args[2] = fbranch;
146 return new_exp (3, op, args);
147 }
148
149 #ifndef YYDEBUG
150 # define YYDEBUG 0
151 #endif
152
153
154
155 #define YYFINAL 27
156 #define YYFLAG -32768
157 #define YYNTBASE 16
158
159 /* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */
160 #define YYTRANSLATE(x) ((unsigned)(x) <= 261 ? yytranslate[x] : 18)
161
162 /* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */
163 static const char yytranslate[] =
164 {
165 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
166 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
167 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
168 2, 2, 2, 10, 2, 2, 2, 2, 5, 2,
169 14, 15, 2, 2, 2, 2, 2, 2, 2, 2,
170 2, 2, 2, 2, 2, 2, 2, 2, 12, 2,
171 2, 2, 2, 3, 2, 2, 2, 2, 2, 2,
172 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
173 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
174 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
175 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
176 13, 2, 2, 2, 2, 2, 2, 2, 2, 2,
177 2, 2, 2, 2, 4, 2, 2, 2, 2, 2,
178 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
179 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
180 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
181 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
182 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
183 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
184 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
185 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
186 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
187 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
188 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
189 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
190 2, 2, 2, 2, 2, 2, 1, 6, 7, 8,
191 9, 11
192 };
193
194 #if YYDEBUG
195 static const short yyprhs[] =
196 {
197 0, 0, 2, 8, 12, 16, 20, 24, 28, 32,
198 35, 37, 39
199 };
200 static const short yyrhs[] =
201 {
202 17, 0, 17, 3, 17, 12, 17, 0, 17, 4,
203 17, 0, 17, 5, 17, 0, 17, 6, 17, 0,
204 17, 7, 17, 0, 17, 8, 17, 0, 17, 9,
205 17, 0, 10, 17, 0, 13, 0, 11, 0, 14,
206 17, 15, 0
207 };
208
209 #endif
210
211 #if YYDEBUG
212 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
213 static const short yyrline[] =
214 {
215 0, 150, 158, 162, 166, 170, 174, 178, 182, 186,
216 190, 194, 199
217 };
218 #endif
219
220
221 #if (YYDEBUG) || defined YYERROR_VERBOSE
222
223 /* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */
224 static const char *const yytname[] =
225 {
226 "$", "error", "$undefined.", "'?'", "'|'", "'&'", "EQUOP2", "CMPOP2",
227 "ADDOP2", "MULOP2", "'!'", "NUMBER", "':'", "'n'", "'('", "')'",
228 "start", "exp", 0
229 };
230 #endif
231
232 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
233 static const short yyr1[] =
234 {
235 0, 16, 17, 17, 17, 17, 17, 17, 17, 17,
236 17, 17, 17
237 };
238
239 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
240 static const short yyr2[] =
241 {
242 0, 1, 5, 3, 3, 3, 3, 3, 3, 2,
243 1, 1, 3
244 };
245
246 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
247 doesn't specify something else to do. Zero means the default is an
248 error. */
249 static const short yydefact[] =
250 {
251 0, 0, 11, 10, 0, 1, 9, 0, 0, 0,
252 0, 0, 0, 0, 0, 12, 0, 3, 4, 5,
253 6, 7, 8, 0, 2, 0, 0, 0
254 };
255
256 static const short yydefgoto[] =
257 {
258 25, 5
259 };
260
261 static const short yypact[] =
262 {
263 -9, -9,-32768,-32768, -9, 34,-32768, 11, -9, -9,
264 -9, -9, -9, -9, -9,-32768, 24, 39, 43, 16,
265 26, -3,-32768, -9, 34, 21, 53,-32768
266 };
267
268 static const short yypgoto[] =
269 {
270 -32768, -1
271 };
272
273
274 #define YYLAST 53
275
276
277 static const short yytable[] =
278 {
279 6, 1, 2, 7, 3, 4, 14, 16, 17, 18,
280 19, 20, 21, 22, 8, 9, 10, 11, 12, 13,
281 14, 26, 24, 12, 13, 14, 15, 8, 9, 10,
282 11, 12, 13, 14, 13, 14, 23, 8, 9, 10,
283 11, 12, 13, 14, 10, 11, 12, 13, 14, 11,
284 12, 13, 14, 27
285 };
286
287 static const short yycheck[] =
288 {
289 1, 10, 11, 4, 13, 14, 9, 8, 9, 10,
290 11, 12, 13, 14, 3, 4, 5, 6, 7, 8,
291 9, 0, 23, 7, 8, 9, 15, 3, 4, 5,
292 6, 7, 8, 9, 8, 9, 12, 3, 4, 5,
293 6, 7, 8, 9, 5, 6, 7, 8, 9, 6,
294 7, 8, 9, 0
295 };
296 #define YYPURE 1
297
298 /* -*-C-*- Note some compilers choke on comments on `#line' lines. */
299 #line 3 "/usr/local/share/bison/bison.simple"
300
301 /* Skeleton output parser for bison,
302
303 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software
304 Foundation, Inc.
305
306 This program is free software; you can redistribute it and/or modify
307 it under the terms of the GNU General Public License as published by
308 the Free Software Foundation; either version 2, or (at your option)
309 any later version.
310
311 This program is distributed in the hope that it will be useful,
312 but WITHOUT ANY WARRANTY; without even the implied warranty of
313 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
314 GNU General Public License for more details.
315
316 You should have received a copy of the GNU General Public License
317 along with this program; if not, write to the Free Software
318 Foundation, Inc., 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)
569 yystrlen (const char *yystr)
570 # else
571 yystrlen (yystr)
572 const char *yystr;
573 # endif
574 {
575 register const char *yys = yystr;
576
577 while (*yys++ != '\0')
578 continue;
579
580 return yys - yystr - 1;
581 }
582 # endif
583 # endif
584
585 # ifndef yystpcpy
586 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
587 # define yystpcpy stpcpy
588 # else
589 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
590 YYDEST. */
591 static char *
592 # if defined (__STDC__) || defined (__cplusplus)
593 yystpcpy (char *yydest, const char *yysrc)
594 # else
595 yystpcpy (yydest, yysrc)
596 char *yydest;
597 const char *yysrc;
598 # endif
599 {
600 register char *yyd = yydest;
601 register const char *yys = yysrc;
602
603 while ((*yyd++ = *yys++) != '\0')
604 continue;
605
606 return yyd - 1;
607 }
608 # endif
609 # endif
610 #endif
611
612 #line 315 "/usr/local/share/bison/bison.simple"
613
614
615 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
616 into yyparse. The argument should have type void *.
617 It should actually point to an object.
618 Grammar actions can access the variable by casting it
619 to the proper pointer type. */
620
621 #ifdef YYPARSE_PARAM
622 # if defined (__STDC__) || defined (__cplusplus)
623 # define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
624 # define YYPARSE_PARAM_DECL
625 # else
626 # define YYPARSE_PARAM_ARG YYPARSE_PARAM
627 # define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
628 # endif
629 #else /* !YYPARSE_PARAM */
630 # define YYPARSE_PARAM_ARG
631 # define YYPARSE_PARAM_DECL
632 #endif /* !YYPARSE_PARAM */
633
634 /* Prevent warning if -Wstrict-prototypes. */
635 #ifdef __GNUC__
636 # ifdef YYPARSE_PARAM
637 int yyparse (void *);
638 # else
639 int yyparse (void);
640 # endif
641 #endif
642
643 /* YY_DECL_VARIABLES -- depending whether we use a pure parser,
644 variables are global, or local to YYPARSE. */
645
646 #define YY_DECL_NON_LSP_VARIABLES \
647 /* The lookahead symbol. */ \
648 int yychar; \
649 \
650 /* The semantic value of the lookahead symbol. */ \
651 YYSTYPE yylval; \
652 \
653 /* Number of parse errors so far. */ \
654 int yynerrs;
655
656 #if YYLSP_NEEDED
657 # define YY_DECL_VARIABLES \
658 YY_DECL_NON_LSP_VARIABLES \
659 \
660 /* Location data for the lookahead symbol. */ \
661 YYLTYPE yylloc;
662 #else
663 # define YY_DECL_VARIABLES \
664 YY_DECL_NON_LSP_VARIABLES
665 #endif
666
667
668 /* If nonreentrant, generate the variables here. */
669
670 #if !YYPURE
671 YY_DECL_VARIABLES
672 #endif /* !YYPURE */
673
674 int
675 yyparse (YYPARSE_PARAM_ARG)
676 YYPARSE_PARAM_DECL
677 {
678 /* If reentrant, generate the variables here. */
679 #if YYPURE
680 YY_DECL_VARIABLES
681 #endif /* !YYPURE */
682
683 register int yystate;
684 register int yyn;
685 int yyresult;
686 /* Number of tokens to shift before error messages enabled. */
687 int yyerrstatus;
688 /* Lookahead token as an internal (translated) token number. */
689 int yychar1 = 0;
690
691 /* Three stacks and their tools:
692 `yyss': related to states,
693 `yyvs': related to semantic values,
694 `yyls': related to locations.
695
696 Refer to the stacks thru separate pointers, to allow yyoverflow
697 to reallocate them elsewhere. */
698
699 /* The state stack. */
700 short yyssa[YYINITDEPTH];
701 short *yyss = yyssa;
702 register short *yyssp;
703
704 /* The semantic value stack. */
705 YYSTYPE yyvsa[YYINITDEPTH];
706 YYSTYPE *yyvs = yyvsa;
707 register YYSTYPE *yyvsp;
708
709 #if YYLSP_NEEDED
710 /* The location stack. */
711 YYLTYPE yylsa[YYINITDEPTH];
712 YYLTYPE *yyls = yylsa;
713 YYLTYPE *yylsp;
714 #endif
715
716 #if YYLSP_NEEDED
717 # define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
718 #else
719 # define YYPOPSTACK (yyvsp--, yyssp--)
720 #endif
721
722 YYSIZE_T yystacksize = YYINITDEPTH;
723
724
725 /* The variables used to return semantic value and location from the
726 action routines. */
727 YYSTYPE yyval;
728 #if YYLSP_NEEDED
729 YYLTYPE yyloc;
730 #endif
731
732 /* When reducing, the number of symbols on the RHS of the reduced
733 rule. */
734 int yylen;
735
736 YYDPRINTF ((stderr, "Starting parse\n"));
737
738 yystate = 0;
739 yyerrstatus = 0;
740 yynerrs = 0;
741 yychar = YYEMPTY; /* Cause a token to be read. */
742
743 /* Initialize stack pointers.
744 Waste one element of value and location stack
745 so that they stay on the same level as the state stack.
746 The wasted elements are never initialized. */
747
748 yyssp = yyss;
749 yyvsp = yyvs;
750 #if YYLSP_NEEDED
751 yylsp = yyls;
752 #endif
753 goto yysetstate;
754
755 /*------------------------------------------------------------.
756 | yynewstate -- Push a new state, which is found in yystate. |
757 `------------------------------------------------------------*/
758 yynewstate:
759 /* In all cases, when you get here, the value and location stacks
760 have just been pushed. so pushing a state here evens the stacks.
761 */
762 yyssp++;
763
764 yysetstate:
765 *yyssp = yystate;
766
767 if (yyssp >= yyss + yystacksize - 1)
768 {
769 /* Get the current used size of the three stacks, in elements. */
770 YYSIZE_T yysize = yyssp - yyss + 1;
771
772 #ifdef yyoverflow
773 {
774 /* Give user a chance to reallocate the stack. Use copies of
775 these so that the &'s don't force the real ones into
776 memory. */
777 YYSTYPE *yyvs1 = yyvs;
778 short *yyss1 = yyss;
779
780 /* Each stack pointer address is followed by the size of the
781 data in use in that stack, in bytes. */
782 # if YYLSP_NEEDED
783 YYLTYPE *yyls1 = yyls;
784 /* This used to be a conditional around just the two extra args,
785 but that might be undefined if yyoverflow is a macro. */
786 yyoverflow ("parser stack overflow",
787 &yyss1, yysize * sizeof (*yyssp),
788 &yyvs1, yysize * sizeof (*yyvsp),
789 &yyls1, yysize * sizeof (*yylsp),
790 &yystacksize);
791 yyls = yyls1;
792 # else
793 yyoverflow ("parser stack overflow",
794 &yyss1, yysize * sizeof (*yyssp),
795 &yyvs1, yysize * sizeof (*yyvsp),
796 &yystacksize);
797 # endif
798 yyss = yyss1;
799 yyvs = yyvs1;
800 }
801 #else /* no yyoverflow */
802 # ifndef YYSTACK_RELOCATE
803 goto yyoverflowlab;
804 # else
805 /* Extend the stack our own way. */
806 if (yystacksize >= YYMAXDEPTH)
807 goto yyoverflowlab;
808 yystacksize *= 2;
809 if (yystacksize > YYMAXDEPTH)
810 yystacksize = YYMAXDEPTH;
811
812 {
813 short *yyss1 = yyss;
814 union yyalloc *yyptr =
815 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
816 if (! yyptr)
817 goto yyoverflowlab;
818 YYSTACK_RELOCATE (yyss);
819 YYSTACK_RELOCATE (yyvs);
820 # if YYLSP_NEEDED
821 YYSTACK_RELOCATE (yyls);
822 # endif
823 # undef YYSTACK_RELOCATE
824 if (yyss1 != yyssa)
825 YYSTACK_FREE (yyss1);
826 }
827 # endif
828 #endif /* no yyoverflow */
829
830 yyssp = yyss + yysize - 1;
831 yyvsp = yyvs + yysize - 1;
832 #if YYLSP_NEEDED
833 yylsp = yyls + yysize - 1;
834 #endif
835
836 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
837 (unsigned long int) yystacksize));
838
839 if (yyssp >= yyss + yystacksize - 1)
840 YYABORT;
841 }
842
843 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
844
845 goto yybackup;
846
847
848 /*-----------.
849 | yybackup. |
850 `-----------*/
851 yybackup:
852
853 /* Do appropriate processing given the current state. */
854 /* Read a lookahead token if we need one and don't already have one. */
855 /* yyresume: */
856
857 /* First try to decide what to do without reference to lookahead token. */
858
859 yyn = yypact[yystate];
860 if (yyn == YYFLAG)
861 goto yydefault;
862
863 /* Not known => get a lookahead token if don't already have one. */
864
865 /* yychar is either YYEMPTY or YYEOF
866 or a valid token in external form. */
867
868 if (yychar == YYEMPTY)
869 {
870 YYDPRINTF ((stderr, "Reading a token: "));
871 yychar = YYLEX;
872 }
873
874 /* Convert token to internal form (in yychar1) for indexing tables with */
875
876 if (yychar <= 0) /* This means end of input. */
877 {
878 yychar1 = 0;
879 yychar = YYEOF; /* Don't call YYLEX any more */
880
881 YYDPRINTF ((stderr, "Now at end of input.\n"));
882 }
883 else
884 {
885 yychar1 = YYTRANSLATE (yychar);
886
887 #if YYDEBUG
888 /* We have to keep this `#if YYDEBUG', since we use variables
889 which are defined only if `YYDEBUG' is set. */
890 if (yydebug)
891 {
892 YYFPRINTF (stderr, "Next token is %d (%s",
893 yychar, yytname[yychar1]);
894 /* Give the individual parser a way to print the precise
895 meaning of a token, for further debugging info. */
896 # ifdef YYPRINT
897 YYPRINT (stderr, yychar, yylval);
898 # endif
899 YYFPRINTF (stderr, ")\n");
900 }
901 #endif
902 }
903
904 yyn += yychar1;
905 if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
906 goto yydefault;
907
908 yyn = yytable[yyn];
909
910 /* yyn is what to do for this token type in this state.
911 Negative => reduce, -yyn is rule number.
912 Positive => shift, yyn is new state.
913 New state is final state => don't bother to shift,
914 just return success.
915 0, or most negative number => error. */
916
917 if (yyn < 0)
918 {
919 if (yyn == YYFLAG)
920 goto yyerrlab;
921 yyn = -yyn;
922 goto yyreduce;
923 }
924 else if (yyn == 0)
925 goto yyerrlab;
926
927 if (yyn == YYFINAL)
928 YYACCEPT;
929
930 /* Shift the lookahead token. */
931 YYDPRINTF ((stderr, "Shifting token %d (%s), ",
932 yychar, yytname[yychar1]));
933
934 /* Discard the token being shifted unless it is eof. */
935 if (yychar != YYEOF)
936 yychar = YYEMPTY;
937
938 *++yyvsp = yylval;
939 #if YYLSP_NEEDED
940 *++yylsp = yylloc;
941 #endif
942
943 /* Count tokens shifted since error; after three, turn off error
944 status. */
945 if (yyerrstatus)
946 yyerrstatus--;
947
948 yystate = yyn;
949 goto yynewstate;
950
951
952 /*-----------------------------------------------------------.
953 | yydefault -- do the default action for the current state. |
954 `-----------------------------------------------------------*/
955 yydefault:
956 yyn = yydefact[yystate];
957 if (yyn == 0)
958 goto yyerrlab;
959 goto yyreduce;
960
961
962 /*-----------------------------.
963 | yyreduce -- Do a reduction. |
964 `-----------------------------*/
965 yyreduce:
966 /* yyn is the number of a rule to reduce with. */
967 yylen = yyr2[yyn];
968
969 /* If YYLEN is nonzero, implement the default value of the action:
970 `$$ = $1'.
971
972 Otherwise, the following line sets YYVAL to the semantic value of
973 the lookahead token. This behavior is undocumented and Bison
974 users should not rely upon it. Assigning to YYVAL
975 unconditionally makes the parser a bit smaller, and it avoids a
976 GCC warning that YYVAL may be used uninitialized. */
977 yyval = yyvsp[1-yylen];
978
979 #if YYLSP_NEEDED
980 /* Similarly for the default location. Let the user run additional
981 commands if for instance locations are ranges. */
982 yyloc = yylsp[1-yylen];
983 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
984 #endif
985
986 #if YYDEBUG
987 /* We have to keep this `#if YYDEBUG', since we use variables which
988 are defined only if `YYDEBUG' is set. */
989 if (yydebug)
990 {
991 int yyi;
992
993 YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
994 yyn, yyrline[yyn]);
995
996 /* Print the symbols being reduced, and their result. */
997 for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)
998 YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
999 YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
1000 }
1001 #endif
1002
1003 switch (yyn) {
1004
1005 case 1:
1006 #line 151 "plural.y"
1007 {
1008 if (yyvsp[0].exp == NULL)
1009 YYABORT;
1010 ((struct parse_args *) arg)->res = yyvsp[0].exp;
1011 }
1012 break;
1013 case 2:
1014 #line 159 "plural.y"
1015 {
1016 yyval.exp = new_exp_3 (qmop, yyvsp[-4].exp, yyvsp[-2].exp, yyvsp[0].exp);
1017 }
1018 break;
1019 case 3:
1020 #line 163 "plural.y"
1021 {
1022 yyval.exp = new_exp_2 (lor, yyvsp[-2].exp, yyvsp[0].exp);
1023 }
1024 break;
1025 case 4:
1026 #line 167 "plural.y"
1027 {
1028 yyval.exp = new_exp_2 (land, yyvsp[-2].exp, yyvsp[0].exp);
1029 }
1030 break;
1031 case 5:
1032 #line 171 "plural.y"
1033 {
1034 yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
1035 }
1036 break;
1037 case 6:
1038 #line 175 "plural.y"
1039 {
1040 yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
1041 }
1042 break;
1043 case 7:
1044 #line 179 "plural.y"
1045 {
1046 yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
1047 }
1048 break;
1049 case 8:
1050 #line 183 "plural.y"
1051 {
1052 yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
1053 }
1054 break;
1055 case 9:
1056 #line 187 "plural.y"
1057 {
1058 yyval.exp = new_exp_1 (lnot, yyvsp[0].exp);
1059 }
1060 break;
1061 case 10:
1062 #line 191 "plural.y"
1063 {
1064 yyval.exp = new_exp_0 (var);
1065 }
1066 break;
1067 case 11:
1068 #line 195 "plural.y"
1069 {
1070 if ((yyval.exp = new_exp_0 (num)) != NULL)
1071 yyval.exp->val.num = yyvsp[0].num;
1072 }
1073 break;
1074 case 12:
1075 #line 200 "plural.y"
1076 {
1077 yyval.exp = yyvsp[-1].exp;
1078 }
1079 break;
1080 }
1081
1082 #line 705 "/usr/local/share/bison/bison.simple"
1083
1084
1085 yyvsp -= yylen;
1086 yyssp -= yylen;
1087 #if YYLSP_NEEDED
1088 yylsp -= yylen;
1089 #endif
1090
1091 #if YYDEBUG
1092 if (yydebug)
1093 {
1094 short *yyssp1 = yyss - 1;
1095 YYFPRINTF (stderr, "state stack now");
1096 while (yyssp1 != yyssp)
1097 YYFPRINTF (stderr, " %d", *++yyssp1);
1098 YYFPRINTF (stderr, "\n");
1099 }
1100 #endif
1101
1102 *++yyvsp = yyval;
1103 #if YYLSP_NEEDED
1104 *++yylsp = yyloc;
1105 #endif
1106
1107 /* Now `shift' the result of the reduction. Determine what state
1108 that goes to, based on the state we popped back to and the rule
1109 number reduced by. */
1110
1111 yyn = yyr1[yyn];
1112
1113 yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
1114 if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1115 yystate = yytable[yystate];
1116 else
1117 yystate = yydefgoto[yyn - YYNTBASE];
1118
1119 goto yynewstate;
1120
1121
1122 /*------------------------------------.
1123 | yyerrlab -- here on detecting error |
1124 `------------------------------------*/
1125 yyerrlab:
1126 /* If not already recovering from an error, report this error. */
1127 if (!yyerrstatus)
1128 {
1129 ++yynerrs;
1130
1131 #ifdef YYERROR_VERBOSE
1132 yyn = yypact[yystate];
1133
1134 if (yyn > YYFLAG && yyn < YYLAST)
1135 {
1136 YYSIZE_T yysize = 0;
1137 char *yymsg;
1138 int yyx, yycount;
1139
1140 yycount = 0;
1141 /* Start YYX at -YYN if negative to avoid negative indexes in
1142 YYCHECK. */
1143 for (yyx = yyn < 0 ? -yyn : 0;
1144 yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
1145 if (yycheck[yyx + yyn] == yyx)
1146 yysize += yystrlen (yytname[yyx]) + 15, yycount++;
1147 yysize += yystrlen ("parse error, unexpected ") + 1;
1148 yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);
1149 yymsg = (char *) YYSTACK_ALLOC (yysize);
1150 if (yymsg != 0)
1151 {
1152 char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
1153 yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);
1154
1155 if (yycount < 5)
1156 {
1157 yycount = 0;
1158 for (yyx = yyn < 0 ? -yyn : 0;
1159 yyx < (int) (sizeof (yytname) / sizeof (char *));
1160 yyx++)
1161 if (yycheck[yyx + yyn] == yyx)
1162 {
1163 const char *yyq = ! yycount ? ", expecting " : " or ";
1164 yyp = yystpcpy (yyp, yyq);
1165 yyp = yystpcpy (yyp, yytname[yyx]);
1166 yycount++;
1167 }
1168 }
1169 yyerror (yymsg);
1170 YYSTACK_FREE (yymsg);
1171 }
1172 else
1173 yyerror ("parse error; also virtual memory exhausted");
1174 }
1175 else
1176 #endif /* defined (YYERROR_VERBOSE) */
1177 yyerror ("parse error");
1178 }
1179 goto yyerrlab1;
1180
1181
1182 /*--------------------------------------------------.
1183 | yyerrlab1 -- error raised explicitly by an action |
1184 `--------------------------------------------------*/
1185 yyerrlab1:
1186 if (yyerrstatus == 3)
1187 {
1188 /* If just tried and failed to reuse lookahead token after an
1189 error, discard it. */
1190
1191 /* return failure if at end of input */
1192 if (yychar == YYEOF)
1193 YYABORT;
1194 YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
1195 yychar, yytname[yychar1]));
1196 yychar = YYEMPTY;
1197 }
1198
1199 /* Else will try to reuse lookahead token after shifting the error
1200 token. */
1201
1202 yyerrstatus = 3; /* Each real token shifted decrements this */
1203
1204 goto yyerrhandle;
1205
1206
1207 /*-------------------------------------------------------------------.
1208 | yyerrdefault -- current state does not do anything special for the |
1209 | error token. |
1210 `-------------------------------------------------------------------*/
1211 yyerrdefault:
1212 #if 0
1213 /* This is wrong; only states that explicitly want error tokens
1214 should shift them. */
1215
1216 /* If its default is to accept any token, ok. Otherwise pop it. */
1217 yyn = yydefact[yystate];
1218 if (yyn)
1219 goto yydefault;
1220 #endif
1221
1222
1223 /*---------------------------------------------------------------.
1224 | yyerrpop -- pop the current state because it cannot handle the |
1225 | error token |
1226 `---------------------------------------------------------------*/
1227 yyerrpop:
1228 if (yyssp == yyss)
1229 YYABORT;
1230 yyvsp--;
1231 yystate = *--yyssp;
1232 #if YYLSP_NEEDED
1233 yylsp--;
1234 #endif
1235
1236 #if YYDEBUG
1237 if (yydebug)
1238 {
1239 short *yyssp1 = yyss - 1;
1240 YYFPRINTF (stderr, "Error: state stack now");
1241 while (yyssp1 != yyssp)
1242 YYFPRINTF (stderr, " %d", *++yyssp1);
1243 YYFPRINTF (stderr, "\n");
1244 }
1245 #endif
1246
1247 /*--------------.
1248 | yyerrhandle. |
1249 `--------------*/
1250 yyerrhandle:
1251 yyn = yypact[yystate];
1252 if (yyn == YYFLAG)
1253 goto yyerrdefault;
1254
1255 yyn += YYTERROR;
1256 if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
1257 goto yyerrdefault;
1258
1259 yyn = yytable[yyn];
1260 if (yyn < 0)
1261 {
1262 if (yyn == YYFLAG)
1263 goto yyerrpop;
1264 yyn = -yyn;
1265 goto yyreduce;
1266 }
1267 else if (yyn == 0)
1268 goto yyerrpop;
1269
1270 if (yyn == YYFINAL)
1271 YYACCEPT;
1272
1273 YYDPRINTF ((stderr, "Shifting error token, "));
1274
1275 *++yyvsp = yylval;
1276 #if YYLSP_NEEDED
1277 *++yylsp = yylloc;
1278 #endif
1279
1280 yystate = yyn;
1281 goto yynewstate;
1282
1283
1284 /*-------------------------------------.
1285 | yyacceptlab -- YYACCEPT comes here. |
1286 `-------------------------------------*/
1287 yyacceptlab:
1288 yyresult = 0;
1289 goto yyreturn;
1290
1291 /*-----------------------------------.
1292 | yyabortlab -- YYABORT comes here. |
1293 `-----------------------------------*/
1294 yyabortlab:
1295 yyresult = 1;
1296 goto yyreturn;
1297
1298 /*---------------------------------------------.
1299 | yyoverflowab -- parser overflow comes here. |
1300 `---------------------------------------------*/
1301 yyoverflowlab:
1302 yyerror ("parser stack overflow");
1303 yyresult = 2;
1304 /* Fall through. */
1305
1306 yyreturn:
1307 #ifndef yyoverflow
1308 if (yyss != yyssa)
1309 YYSTACK_FREE (yyss);
1310 #endif
1311 return yyresult;
1312 }
1313 #line 205 "plural.y"
1314
1315
1316 void
1317 internal_function
1318 FREE_EXPRESSION (struct expression *exp)
1319 {
1320 if (exp == NULL)
1321 return;
1322
1323 /* Handle the recursive case. */
1324 switch (exp->nargs)
1325 {
1326 case 3:
1327 FREE_EXPRESSION (exp->val.args[2]);
1328 /* FALLTHROUGH */
1329 case 2:
1330 FREE_EXPRESSION (exp->val.args[1]);
1331 /* FALLTHROUGH */
1332 case 1:
1333 FREE_EXPRESSION (exp->val.args[0]);
1334 /* FALLTHROUGH */
1335 default:
1336 break;
1337 }
1338
1339 free (exp);
1340 }
1341
1342
1343 static int
1344 yylex (YYSTYPE *lval, const char **pexp)
1345 {
1346 const char *exp = *pexp;
1347 int result;
1348
1349 while (1)
1350 {
1351 if (exp[0] == '\0')
1352 {
1353 *pexp = exp;
1354 return YYEOF;
1355 }
1356
1357 if (exp[0] != ' ' && exp[0] != '\t')
1358 break;
1359
1360 ++exp;
1361 }
1362
1363 result = *exp++;
1364 switch (result)
1365 {
1366 case '0': case '1': case '2': case '3': case '4':
1367 case '5': case '6': case '7': case '8': case '9':
1368 {
1369 unsigned long int n = result - '0';
1370 while (exp[0] >= '0' && exp[0] <= '9')
1371 {
1372 n *= 10;
1373 n += exp[0] - '0';
1374 ++exp;
1375 }
1376 lval->num = n;
1377 result = NUMBER;
1378 }
1379 break;
1380
1381 case '=':
1382 if (exp[0] == '=')
1383 {
1384 ++exp;
1385 lval->op = equal;
1386 result = EQUOP2;
1387 }
1388 else
1389 result = YYERRCODE;
1390 break;
1391
1392 case '!':
1393 if (exp[0] == '=')
1394 {
1395 ++exp;
1396 lval->op = not_equal;
1397 result = EQUOP2;
1398 }
1399 break;
1400
1401 case '&':
1402 case '|':
1403 if (exp[0] == result)
1404 ++exp;
1405 else
1406 result = YYERRCODE;
1407 break;
1408
1409 case '<':
1410 if (exp[0] == '=')
1411 {
1412 ++exp;
1413 lval->op = less_or_equal;
1414 }
1415 else
1416 lval->op = less_than;
1417 result = CMPOP2;
1418 break;
1419
1420 case '>':
1421 if (exp[0] == '=')
1422 {
1423 ++exp;
1424 lval->op = greater_or_equal;
1425 }
1426 else
1427 lval->op = greater_than;
1428 result = CMPOP2;
1429 break;
1430
1431 case '*':
1432 lval->op = mult;
1433 result = MULOP2;
1434 break;
1435
1436 case '/':
1437 lval->op = divide;
1438 result = MULOP2;
1439 break;
1440
1441 case '%':
1442 lval->op = module;
1443 result = MULOP2;
1444 break;
1445
1446 case '+':
1447 lval->op = plus;
1448 result = ADDOP2;
1449 break;
1450
1451 case '-':
1452 lval->op = minus;
1453 result = ADDOP2;
1454 break;
1455
1456 case 'n':
1457 case '?':
1458 case ':':
1459 case '(':
1460 case ')':
1461 /* Nothing, just return the character. */
1462 break;
1463
1464 case ';':
1465 case '\n':
1466 case '\0':
1467 /* Be safe and let the user call this function again. */
1468 --exp;
1469 result = YYEOF;
1470 break;
1471
1472 default:
1473 result = YYERRCODE;
1474 #if YYDEBUG != 0
1475 --exp;
1476 #endif
1477 break;
1478 }
1479
1480 *pexp = exp;
1481
1482 return result;
1483 }
1484
1485
1486 static void
1487 yyerror (const char *str)
1488 {
1489 /* Do nothing. We don't print error messages here. */
1490 }

   
Visit the ZANavi Wiki