1 /* A Bison parser, made from plural.y
4 #define YYBISON 1 /* Identify Bison output. */
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
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.
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)
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.
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,
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__
54 #include "plural-exp.h"
56 /* The main function generated by the parser is called __gettextparse,
57 but we want it to be called PLURAL_PARSE. */
59 # define __gettextparse PLURAL_PARSE
62 #define YYLEX_PARAM &((struct parse_args *) arg)->cp
63 #define YYPARSE_PARAM arg
68 unsigned long int num
;
70 struct expression
*exp
;
72 # define YYSTYPE yystype
73 # define YYSTYPE_IS_TRIVIAL 1
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
));
93 /* Allocation of expressions. */
95 static struct expression
*
96 new_exp (nargs
, op
, args
)
99 struct expression
* const *args
;
102 struct expression
*newp
;
104 /* If any of the argument could not be malloc'ed, just return NULL. */
105 for (i
= nargs
- 1; i
>= 0; i
--)
109 /* Allocate a new expression. */
110 newp
= (struct expression
*) malloc (sizeof (*newp
));
114 newp
->operation
= op
;
115 for (i
= nargs
- 1; i
>= 0; i
--)
116 newp
->val
.args
[i
] = args
[i
];
121 for (i
= nargs
- 1; i
>= 0; i
--)
122 FREE_EXPRESSION (args
[i
]);
127 static inline struct expression
*
131 return new_exp (0, op
, NULL
);
134 static inline struct expression
*
135 new_exp_1 (op
, right
)
137 struct expression
*right
;
139 struct expression
*args
[1];
142 return new_exp (1, op
, args
);
145 static struct expression
*
146 new_exp_2 (op
, left
, right
)
148 struct expression
*left
;
149 struct expression
*right
;
151 struct expression
*args
[2];
155 return new_exp (2, op
, args
);
158 static inline struct expression
*
159 new_exp_3 (op
, bexp
, tbranch
, fbranch
)
161 struct expression
*bexp
;
162 struct expression
*tbranch
;
163 struct expression
*fbranch
;
165 struct expression
*args
[3];
170 return new_exp (3, op
, args
);
180 #define YYFLAG -32768
183 /* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */
184 #define YYTRANSLATE(x) ((unsigned)(x) <= 261 ? yytranslate[x] : 18)
186 /* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */
187 static const char yytranslate
[] =
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,
219 static const short yyprhs
[] =
221 0, 0, 2, 8, 12, 16, 20, 24, 28, 32,
224 static const short yyrhs
[] =
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,
236 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
237 static const short yyrline
[] =
239 0, 174, 182, 186, 190, 194, 198, 202, 206, 210,
245 #if (YYDEBUG) || defined YYERROR_VERBOSE
247 /* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */
248 static const char *const yytname
[] =
250 "$", "error", "$undefined.", "'?'", "'|'", "'&'", "EQUOP2", "CMPOP2",
251 "ADDOP2", "MULOP2", "'!'", "NUMBER", "':'", "'n'", "'('", "')'",
256 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
257 static const short yyr1
[] =
259 0, 16, 17, 17, 17, 17, 17, 17, 17, 17,
263 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
264 static const short yyr2
[] =
266 0, 1, 5, 3, 3, 3, 3, 3, 3, 2,
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
273 static const short yydefact
[] =
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
280 static const short yydefgoto
[] =
285 static const short yypact
[] =
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
292 static const short yypgoto
[] =
301 static const short yytable
[] =
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,
311 static const short yycheck
[] =
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,
322 /* -*-C-*- Note some compilers choke on comments on `#line' lines. */
323 #line 3 "/usr/local/share/bison/bison.simple"
325 /* Skeleton output parser for bison,
327 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software
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)
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.
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. */
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. */
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. */
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. */
362 #if ! defined (yyoverflow) || defined (YYERROR_VERBOSE)
364 /* The parser invokes alloca or malloc; define the necessary symbols. */
366 # if YYSTACK_USE_ALLOCA
367 # define YYSTACK_ALLOC alloca
369 # ifndef YYSTACK_USE_ALLOCA
370 # if defined (alloca) || defined (_ALLOCA_H)
371 # define YYSTACK_ALLOC alloca
374 # define YYSTACK_ALLOC __builtin_alloca
380 # ifdef YYSTACK_ALLOC
381 /* Pacify GCC's `empty if-body' warning. */
382 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
384 # if defined (__STDC__) || defined (__cplusplus)
385 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
386 # define YYSIZE_T size_t
388 # define YYSTACK_ALLOC malloc
389 # define YYSTACK_FREE free
391 #endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */
394 #if (! defined (yyoverflow) \
395 && (! defined (__cplusplus) \
396 || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
398 /* A type that is properly aligned for any stack member. */
408 /* The size of the maximum gap between one aligned stack and the next. */
409 # define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
411 /* The size of an array large to enough to hold all stacks, each with
414 # define YYSTACK_BYTES(N) \
415 ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
416 + 2 * YYSTACK_GAP_MAX)
418 # define YYSTACK_BYTES(N) \
419 ((N) * (sizeof (short) + sizeof (YYSTYPE)) \
423 /* Copy COUNT objects from FROM to TO. The source and destination do
427 # define YYCOPY(To, From, Count) \
428 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
430 # define YYCOPY(To, From, Count) \
433 register YYSIZE_T yyi; \
434 for (yyi = 0; yyi < (Count); yyi++) \
435 (To)[yyi] = (From)[yyi]; \
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
446 # define YYSTACK_RELOCATE(Stack) \
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); \
460 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
461 # define YYSIZE_T __SIZE_TYPE__
463 #if ! defined (YYSIZE_T) && defined (size_t)
464 # define YYSIZE_T size_t
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
472 #if ! defined (YYSIZE_T)
473 # define YYSIZE_T unsigned int
476 #define yyerrok (yyerrstatus = 0)
477 #define yyclearin (yychar = YYEMPTY)
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) \
490 if (yychar == YYEMPTY && yylen == 1) \
494 yychar1 = YYTRANSLATE (yychar); \
500 yyerror ("syntax error: cannot back up"); \
506 #define YYERRCODE 256
509 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
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. */
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;
523 /* YYLEX -- calling `yylex' with the right arguments. */
528 # define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
530 # define YYLEX yylex (&yylval, &yylloc)
532 # else /* !YYLSP_NEEDED */
534 # define YYLEX yylex (&yylval, YYLEX_PARAM)
536 # define YYLEX yylex (&yylval)
538 # endif /* !YYLSP_NEEDED */
540 # define YYLEX yylex ()
544 /* Enable debugging if requested. */
548 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
549 # define YYFPRINTF fprintf
552 # define YYDPRINTF(Args) \
557 /* Nonzero means print parse trace. It is left uninitialized so that
558 multiple parsers can coexist. */
561 # define YYDPRINTF(Args)
562 #endif /* !YYDEBUG */
564 /* YYINITDEPTH -- initial size of the parser's stacks. */
566 # define YYINITDEPTH 200
569 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
570 if the built-in stack extension method is used).
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. */
581 # define YYMAXDEPTH 10000
584 #ifdef YYERROR_VERBOSE
587 # if defined (__GLIBC__) && defined (_STRING_H)
588 # define yystrlen strlen
590 /* Return the length of YYSTR. */
592 # if defined (__STDC__) || defined (__cplusplus)
593 yystrlen (const char *yystr
)
599 register const char *yys
= yystr
;
601 while (*yys
++ != '\0')
604 return yys
- yystr
- 1;
610 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
611 # define yystpcpy stpcpy
613 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
616 # if defined (__STDC__) || defined (__cplusplus)
617 yystpcpy (char *yydest
, const char *yysrc
)
619 yystpcpy (yydest
, yysrc
)
624 register char *yyd
= yydest
;
625 register const char *yys
= yysrc
;
627 while ((*yyd
++ = *yys
++) != '\0')
636 #line 315 "/usr/local/share/bison/bison.simple"
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. */
646 # if defined (__STDC__) || defined (__cplusplus)
647 # define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
648 # define YYPARSE_PARAM_DECL
650 # define YYPARSE_PARAM_ARG YYPARSE_PARAM
651 # define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
653 #else /* !YYPARSE_PARAM */
654 # define YYPARSE_PARAM_ARG
655 # define YYPARSE_PARAM_DECL
656 #endif /* !YYPARSE_PARAM */
658 /* Prevent warning if -Wstrict-prototypes. */
660 # ifdef YYPARSE_PARAM
661 int yyparse (void *);
667 /* YY_DECL_VARIABLES -- depending whether we use a pure parser,
668 variables are global, or local to YYPARSE. */
670 #define YY_DECL_NON_LSP_VARIABLES \
671 /* The lookahead symbol. */ \
674 /* The semantic value of the lookahead symbol. */ \
677 /* Number of parse errors so far. */ \
681 # define YY_DECL_VARIABLES \
682 YY_DECL_NON_LSP_VARIABLES \
684 /* Location data for the lookahead symbol. */ \
687 # define YY_DECL_VARIABLES \
688 YY_DECL_NON_LSP_VARIABLES
692 /* If nonreentrant, generate the variables here. */
699 yyparse (YYPARSE_PARAM_ARG
)
702 /* If reentrant, generate the variables here. */
707 register int yystate
;
710 /* Number of tokens to shift before error messages enabled. */
712 /* Lookahead token as an internal (translated) token number. */
715 /* Three stacks and their tools:
716 `yyss': related to states,
717 `yyvs': related to semantic values,
718 `yyls': related to locations.
720 Refer to the stacks thru separate pointers, to allow yyoverflow
721 to reallocate them elsewhere. */
723 /* The state stack. */
724 short yyssa
[YYINITDEPTH
];
726 register short *yyssp
;
728 /* The semantic value stack. */
729 YYSTYPE yyvsa
[YYINITDEPTH
];
730 YYSTYPE
*yyvs
= yyvsa
;
731 register YYSTYPE
*yyvsp
;
734 /* The location stack. */
735 YYLTYPE yylsa
[YYINITDEPTH
];
736 YYLTYPE
*yyls
= yylsa
;
741 # define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
743 # define YYPOPSTACK (yyvsp--, yyssp--)
746 YYSIZE_T yystacksize
= YYINITDEPTH
;
749 /* The variables used to return semantic value and location from the
756 /* When reducing, the number of symbols on the RHS of the reduced
760 YYDPRINTF ((stderr
, "Starting parse\n"));
765 yychar
= YYEMPTY
; /* Cause a token to be read. */
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. */
779 /*------------------------------------------------------------.
780 | yynewstate -- Push a new state, which is found in yystate. |
781 `------------------------------------------------------------*/
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.
791 if (yyssp
>= yyss
+ yystacksize
- 1)
793 /* Get the current used size of the three stacks, in elements. */
794 YYSIZE_T yysize
= yyssp
- yyss
+ 1;
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
801 YYSTYPE
*yyvs1
= yyvs
;
804 /* Each stack pointer address is followed by the size of the
805 data in use in that stack, in bytes. */
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
),
817 yyoverflow ("parser stack overflow",
818 &yyss1
, yysize
* sizeof (*yyssp
),
819 &yyvs1
, yysize
* sizeof (*yyvsp
),
825 #else /* no yyoverflow */
826 # ifndef YYSTACK_RELOCATE
829 /* Extend the stack our own way. */
830 if (yystacksize
>= YYMAXDEPTH
)
833 if (yystacksize
> YYMAXDEPTH
)
834 yystacksize
= YYMAXDEPTH
;
838 union yyalloc
*yyptr
=
839 (union yyalloc
*) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize
));
842 YYSTACK_RELOCATE (yyss
);
843 YYSTACK_RELOCATE (yyvs
);
845 YYSTACK_RELOCATE (yyls
);
847 # undef YYSTACK_RELOCATE
849 YYSTACK_FREE (yyss1
);
852 #endif /* no yyoverflow */
854 yyssp
= yyss
+ yysize
- 1;
855 yyvsp
= yyvs
+ yysize
- 1;
857 yylsp
= yyls
+ yysize
- 1;
860 YYDPRINTF ((stderr
, "Stack size increased to %lu\n",
861 (unsigned long int) yystacksize
));
863 if (yyssp
>= yyss
+ yystacksize
- 1)
867 YYDPRINTF ((stderr
, "Entering state %d\n", yystate
));
877 /* Do appropriate processing given the current state. */
878 /* Read a lookahead token if we need one and don't already have one. */
881 /* First try to decide what to do without reference to lookahead token. */
883 yyn
= yypact
[yystate
];
887 /* Not known => get a lookahead token if don't already have one. */
889 /* yychar is either YYEMPTY or YYEOF
890 or a valid token in external form. */
892 if (yychar
== YYEMPTY
)
894 YYDPRINTF ((stderr
, "Reading a token: "));
898 /* Convert token to internal form (in yychar1) for indexing tables with */
900 if (yychar
<= 0) /* This means end of input. */
903 yychar
= YYEOF
; /* Don't call YYLEX any more */
905 YYDPRINTF ((stderr
, "Now at end of input.\n"));
909 yychar1
= YYTRANSLATE (yychar
);
912 /* We have to keep this `#if YYDEBUG', since we use variables
913 which are defined only if `YYDEBUG' is set. */
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. */
921 YYPRINT (stderr
, yychar
, yylval
);
923 YYFPRINTF (stderr
, ")\n");
929 if (yyn
< 0 || yyn
> YYLAST
|| yycheck
[yyn
] != yychar1
)
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,
939 0, or most negative number => error. */
954 /* Shift the lookahead token. */
955 YYDPRINTF ((stderr
, "Shifting token %d (%s), ",
956 yychar
, yytname
[yychar1
]));
958 /* Discard the token being shifted unless it is eof. */
967 /* Count tokens shifted since error; after three, turn off error
976 /*-----------------------------------------------------------.
977 | yydefault -- do the default action for the current state. |
978 `-----------------------------------------------------------*/
980 yyn
= yydefact
[yystate
];
986 /*-----------------------------.
987 | yyreduce -- Do a reduction. |
988 `-----------------------------*/
990 /* yyn is the number of a rule to reduce with. */
993 /* If YYLEN is nonzero, implement the default value of the action:
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
];
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
);
1011 /* We have to keep this `#if YYDEBUG', since we use variables which
1012 are defined only if `YYDEBUG' is set. */
1017 YYFPRINTF (stderr
, "Reducing via rule %d (line %d), ",
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
]]);
1030 #line 175 "plural.y"
1032 if (yyvsp
[0].exp
== NULL
)
1034 ((struct parse_args
*) arg
)->res
= yyvsp
[0].exp
;
1038 #line 183 "plural.y"
1040 yyval
.exp
= new_exp_3 (qmop
, yyvsp
[-4].exp
, yyvsp
[-2].exp
, yyvsp
[0].exp
);
1044 #line 187 "plural.y"
1046 yyval
.exp
= new_exp_2 (lor
, yyvsp
[-2].exp
, yyvsp
[0].exp
);
1050 #line 191 "plural.y"
1052 yyval
.exp
= new_exp_2 (land
, yyvsp
[-2].exp
, yyvsp
[0].exp
);
1056 #line 195 "plural.y"
1058 yyval
.exp
= new_exp_2 (yyvsp
[-1].op
, yyvsp
[-2].exp
, yyvsp
[0].exp
);
1062 #line 199 "plural.y"
1064 yyval
.exp
= new_exp_2 (yyvsp
[-1].op
, yyvsp
[-2].exp
, yyvsp
[0].exp
);
1068 #line 203 "plural.y"
1070 yyval
.exp
= new_exp_2 (yyvsp
[-1].op
, yyvsp
[-2].exp
, yyvsp
[0].exp
);
1074 #line 207 "plural.y"
1076 yyval
.exp
= new_exp_2 (yyvsp
[-1].op
, yyvsp
[-2].exp
, yyvsp
[0].exp
);
1080 #line 211 "plural.y"
1082 yyval
.exp
= new_exp_1 (lnot
, yyvsp
[0].exp
);
1086 #line 215 "plural.y"
1088 yyval
.exp
= new_exp_0 (var
);
1092 #line 219 "plural.y"
1094 if ((yyval
.exp
= new_exp_0 (num
)) != NULL
)
1095 yyval
.exp
->val
.num
= yyvsp
[0].num
;
1099 #line 224 "plural.y"
1101 yyval
.exp
= yyvsp
[-1].exp
;
1106 #line 705 "/usr/local/share/bison/bison.simple"
1118 short *yyssp1
= yyss
- 1;
1119 YYFPRINTF (stderr
, "state stack now");
1120 while (yyssp1
!= yyssp
)
1121 YYFPRINTF (stderr
, " %d", *++yyssp1
);
1122 YYFPRINTF (stderr
, "\n");
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. */
1137 yystate
= yypgoto
[yyn
- YYNTBASE
] + *yyssp
;
1138 if (yystate
>= 0 && yystate
<= YYLAST
&& yycheck
[yystate
] == *yyssp
)
1139 yystate
= yytable
[yystate
];
1141 yystate
= yydefgoto
[yyn
- YYNTBASE
];
1146 /*------------------------------------.
1147 | yyerrlab -- here on detecting error |
1148 `------------------------------------*/
1150 /* If not already recovering from an error, report this error. */
1155 #ifdef YYERROR_VERBOSE
1156 yyn
= yypact
[yystate
];
1158 if (yyn
> YYFLAG
&& yyn
< YYLAST
)
1160 YYSIZE_T yysize
= 0;
1165 /* Start YYX at -YYN if negative to avoid negative indexes in
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
);
1176 char *yyp
= yystpcpy (yymsg
, "parse error, unexpected ");
1177 yyp
= yystpcpy (yyp
, yytname
[YYTRANSLATE (yychar
)]);
1182 for (yyx
= yyn
< 0 ? -yyn
: 0;
1183 yyx
< (int) (sizeof (yytname
) / sizeof (char *));
1185 if (yycheck
[yyx
+ yyn
] == yyx
)
1187 const char *yyq
= ! yycount
? ", expecting " : " or ";
1188 yyp
= yystpcpy (yyp
, yyq
);
1189 yyp
= yystpcpy (yyp
, yytname
[yyx
]);
1194 YYSTACK_FREE (yymsg
);
1197 yyerror ("parse error; also virtual memory exhausted");
1200 #endif /* defined (YYERROR_VERBOSE) */
1201 yyerror ("parse error");
1206 /*--------------------------------------------------.
1207 | yyerrlab1 -- error raised explicitly by an action |
1208 `--------------------------------------------------*/
1210 if (yyerrstatus
== 3)
1212 /* If just tried and failed to reuse lookahead token after an
1213 error, discard it. */
1215 /* return failure if at end of input */
1216 if (yychar
== YYEOF
)
1218 YYDPRINTF ((stderr
, "Discarding token %d (%s).\n",
1219 yychar
, yytname
[yychar1
]));
1223 /* Else will try to reuse lookahead token after shifting the error
1226 yyerrstatus
= 3; /* Each real token shifted decrements this */
1231 /*-------------------------------------------------------------------.
1232 | yyerrdefault -- current state does not do anything special for the |
1234 `-------------------------------------------------------------------*/
1237 /* This is wrong; only states that explicitly want error tokens
1238 should shift them. */
1240 /* If its default is to accept any token, ok. Otherwise pop it. */
1241 yyn
= yydefact
[yystate
];
1247 /*---------------------------------------------------------------.
1248 | yyerrpop -- pop the current state because it cannot handle the |
1250 `---------------------------------------------------------------*/
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");
1275 yyn
= yypact
[yystate
];
1280 if (yyn
< 0 || yyn
> YYLAST
|| yycheck
[yyn
] != YYTERROR
)
1297 YYDPRINTF ((stderr
, "Shifting error token, "));
1308 /*-------------------------------------.
1309 | yyacceptlab -- YYACCEPT comes here. |
1310 `-------------------------------------*/
1315 /*-----------------------------------.
1316 | yyabortlab -- YYABORT comes here. |
1317 `-----------------------------------*/
1322 /*---------------------------------------------.
1323 | yyoverflowab -- parser overflow comes here. |
1324 `---------------------------------------------*/
1326 yyerror ("parser stack overflow");
1333 YYSTACK_FREE (yyss
);
1337 #line 229 "plural.y"
1342 FREE_EXPRESSION (exp
)
1343 struct expression
*exp
;
1348 /* Handle the recursive case. */
1352 FREE_EXPRESSION (exp
->val
.args
[2]);
1355 FREE_EXPRESSION (exp
->val
.args
[1]);
1358 FREE_EXPRESSION (exp
->val
.args
[0]);
1373 const char *exp
= *pexp
;
1384 if (exp
[0] != ' ' && exp
[0] != '\t')
1393 case '0': case '1': case '2': case '3': case '4':
1394 case '5': case '6': case '7': case '8': case '9':
1396 unsigned long int n
= result
- '0';
1397 while (exp
[0] >= '0' && exp
[0] <= '9')
1423 lval
->op
= not_equal
;
1430 if (exp
[0] == result
)
1440 lval
->op
= less_or_equal
;
1443 lval
->op
= less_than
;
1451 lval
->op
= greater_or_equal
;
1454 lval
->op
= greater_than
;
1488 /* Nothing, just return the character. */
1494 /* Be safe and let the user call this function again. */
1517 /* Do nothing. We don't print error messages here. */
This page took 0.064392 seconds and 4 git commands to generate.