136ac495dSmrg /* A Bison parser, made from plural.y
236ac495dSmrg by GNU bison 1.35. */
336ac495dSmrg
436ac495dSmrg #define YYBISON 1 /* Identify Bison output. */
536ac495dSmrg
636ac495dSmrg #define yyparse __gettextparse
736ac495dSmrg #define yylex __gettextlex
836ac495dSmrg #define yyerror __gettexterror
936ac495dSmrg #define yylval __gettextlval
1036ac495dSmrg #define yychar __gettextchar
1136ac495dSmrg #define yydebug __gettextdebug
1236ac495dSmrg #define yynerrs __gettextnerrs
1336ac495dSmrg # define EQUOP2 257
1436ac495dSmrg # define CMPOP2 258
1536ac495dSmrg # define ADDOP2 259
1636ac495dSmrg # define MULOP2 260
1736ac495dSmrg # define NUMBER 261
1836ac495dSmrg
1936ac495dSmrg #line 1 "plural.y"
2036ac495dSmrg
2136ac495dSmrg /* Expression parsing for plural form selection.
22*8feb0f0bSmrg Copyright (C) 2000-2020 Free Software Foundation, Inc.
2336ac495dSmrg Written by Ulrich Drepper <drepper@cygnus.com>, 2000.
2436ac495dSmrg
2536ac495dSmrg This program is free software; you can redistribute it and/or modify it
2636ac495dSmrg under the terms of the GNU Library General Public License as published
2736ac495dSmrg by the Free Software Foundation; either version 2, or (at your option)
2836ac495dSmrg any later version.
2936ac495dSmrg
3036ac495dSmrg This program is distributed in the hope that it will be useful,
3136ac495dSmrg but WITHOUT ANY WARRANTY; without even the implied warranty of
3236ac495dSmrg MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
3336ac495dSmrg Library General Public License for more details.
3436ac495dSmrg
3536ac495dSmrg You should have received a copy of the GNU Library General Public
3636ac495dSmrg License along with this program; if not, write to the Free Software
3736ac495dSmrg Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301,
3836ac495dSmrg USA. */
3936ac495dSmrg
4036ac495dSmrg /* The bison generated parser uses alloca. AIX 3 forces us to put this
4136ac495dSmrg declaration at the beginning of the file. The declaration in bison's
4236ac495dSmrg skeleton file comes too late. This must come before <config.h>
4336ac495dSmrg because <config.h> may include arbitrary system headers. */
4436ac495dSmrg #if defined _AIX && !defined __GNUC__
4536ac495dSmrg #pragma alloca
4636ac495dSmrg #endif
4736ac495dSmrg
4836ac495dSmrg #ifdef HAVE_CONFIG_H
4936ac495dSmrg # include <config.h>
5036ac495dSmrg #endif
5136ac495dSmrg
5236ac495dSmrg #include <stddef.h>
5336ac495dSmrg #include <stdlib.h>
5436ac495dSmrg #include "plural-exp.h"
5536ac495dSmrg
5636ac495dSmrg /* The main function generated by the parser is called __gettextparse,
5736ac495dSmrg but we want it to be called PLURAL_PARSE. */
5836ac495dSmrg #ifndef _LIBC
5936ac495dSmrg # define __gettextparse PLURAL_PARSE
6036ac495dSmrg #endif
6136ac495dSmrg
62*8feb0f0bSmrg #ifndef USE_BISON3
6336ac495dSmrg #define YYLEX_PARAM &((struct parse_args *) arg)->cp
6436ac495dSmrg #define YYPARSE_PARAM arg
65*8feb0f0bSmrg #endif
6636ac495dSmrg
67*8feb0f0bSmrg #line 54 "plural.y"
6836ac495dSmrg #ifndef YYSTYPE
6936ac495dSmrg typedef union {
7036ac495dSmrg unsigned long int num;
7136ac495dSmrg enum operator op;
7236ac495dSmrg struct expression *exp;
7336ac495dSmrg } yystype;
7436ac495dSmrg # define YYSTYPE yystype
7536ac495dSmrg # define YYSTYPE_IS_TRIVIAL 1
7636ac495dSmrg #endif
77*8feb0f0bSmrg #line 60 "plural.y"
7836ac495dSmrg
7936ac495dSmrg /* Prototypes for local functions. */
8036ac495dSmrg static struct expression *new_exp PARAMS ((int nargs, enum operator op,
8136ac495dSmrg struct expression * const *args));
8236ac495dSmrg static inline struct expression *new_exp_0 PARAMS ((enum operator op));
8336ac495dSmrg static inline struct expression *new_exp_1 PARAMS ((enum operator op,
8436ac495dSmrg struct expression *right));
8536ac495dSmrg static struct expression *new_exp_2 PARAMS ((enum operator op,
8636ac495dSmrg struct expression *left,
8736ac495dSmrg struct expression *right));
8836ac495dSmrg static inline struct expression *new_exp_3 PARAMS ((enum operator op,
8936ac495dSmrg struct expression *bexp,
9036ac495dSmrg struct expression *tbranch,
9136ac495dSmrg struct expression *fbranch));
92*8feb0f0bSmrg #ifdef USE_BISON3
93*8feb0f0bSmrg static int yylex PARAMS ((YYSTYPE *lval, struct parse_args *arg));
94*8feb0f0bSmrg static void yyerror PARAMS ((struct parse_args *arg, const char *str));
95*8feb0f0bSmrg #else
9636ac495dSmrg static int yylex PARAMS ((YYSTYPE *lval, const char **pexp));
9736ac495dSmrg static void yyerror PARAMS ((const char *str));
98*8feb0f0bSmrg #endif
9936ac495dSmrg
10036ac495dSmrg /* Allocation of expressions. */
10136ac495dSmrg
10236ac495dSmrg static struct expression *
new_exp(nargs,op,args)10336ac495dSmrg new_exp (nargs, op, args)
10436ac495dSmrg int nargs;
10536ac495dSmrg enum operator op;
10636ac495dSmrg struct expression * const *args;
10736ac495dSmrg {
10836ac495dSmrg int i;
10936ac495dSmrg struct expression *newp;
11036ac495dSmrg
11136ac495dSmrg /* If any of the argument could not be malloc'ed, just return NULL. */
11236ac495dSmrg for (i = nargs - 1; i >= 0; i--)
11336ac495dSmrg if (args[i] == NULL)
11436ac495dSmrg goto fail;
11536ac495dSmrg
11636ac495dSmrg /* Allocate a new expression. */
11736ac495dSmrg newp = (struct expression *) malloc (sizeof (*newp));
11836ac495dSmrg if (newp != NULL)
11936ac495dSmrg {
12036ac495dSmrg newp->nargs = nargs;
12136ac495dSmrg newp->operation = op;
12236ac495dSmrg for (i = nargs - 1; i >= 0; i--)
12336ac495dSmrg newp->val.args[i] = args[i];
12436ac495dSmrg return newp;
12536ac495dSmrg }
12636ac495dSmrg
12736ac495dSmrg fail:
12836ac495dSmrg for (i = nargs - 1; i >= 0; i--)
12936ac495dSmrg FREE_EXPRESSION (args[i]);
13036ac495dSmrg
13136ac495dSmrg return NULL;
13236ac495dSmrg }
13336ac495dSmrg
13436ac495dSmrg static inline struct expression *
new_exp_0(op)13536ac495dSmrg new_exp_0 (op)
13636ac495dSmrg enum operator op;
13736ac495dSmrg {
13836ac495dSmrg return new_exp (0, op, NULL);
13936ac495dSmrg }
14036ac495dSmrg
14136ac495dSmrg static inline struct expression *
new_exp_1(op,right)14236ac495dSmrg new_exp_1 (op, right)
14336ac495dSmrg enum operator op;
14436ac495dSmrg struct expression *right;
14536ac495dSmrg {
14636ac495dSmrg struct expression *args[1];
14736ac495dSmrg
14836ac495dSmrg args[0] = right;
14936ac495dSmrg return new_exp (1, op, args);
15036ac495dSmrg }
15136ac495dSmrg
15236ac495dSmrg static struct expression *
new_exp_2(op,left,right)15336ac495dSmrg new_exp_2 (op, left, right)
15436ac495dSmrg enum operator op;
15536ac495dSmrg struct expression *left;
15636ac495dSmrg struct expression *right;
15736ac495dSmrg {
15836ac495dSmrg struct expression *args[2];
15936ac495dSmrg
16036ac495dSmrg args[0] = left;
16136ac495dSmrg args[1] = right;
16236ac495dSmrg return new_exp (2, op, args);
16336ac495dSmrg }
16436ac495dSmrg
16536ac495dSmrg static inline struct expression *
new_exp_3(op,bexp,tbranch,fbranch)16636ac495dSmrg new_exp_3 (op, bexp, tbranch, fbranch)
16736ac495dSmrg enum operator op;
16836ac495dSmrg struct expression *bexp;
16936ac495dSmrg struct expression *tbranch;
17036ac495dSmrg struct expression *fbranch;
17136ac495dSmrg {
17236ac495dSmrg struct expression *args[3];
17336ac495dSmrg
17436ac495dSmrg args[0] = bexp;
17536ac495dSmrg args[1] = tbranch;
17636ac495dSmrg args[2] = fbranch;
17736ac495dSmrg return new_exp (3, op, args);
17836ac495dSmrg }
17936ac495dSmrg
18036ac495dSmrg #ifndef YYDEBUG
18136ac495dSmrg # define YYDEBUG 0
18236ac495dSmrg #endif
18336ac495dSmrg
18436ac495dSmrg
18536ac495dSmrg
18636ac495dSmrg #define YYFINAL 27
18736ac495dSmrg #define YYFLAG -32768
18836ac495dSmrg #define YYNTBASE 16
18936ac495dSmrg
19036ac495dSmrg /* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */
19136ac495dSmrg #define YYTRANSLATE(x) ((unsigned)(x) <= 261 ? yytranslate[x] : 18)
19236ac495dSmrg
19336ac495dSmrg /* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */
19436ac495dSmrg static const char yytranslate[] =
19536ac495dSmrg {
19636ac495dSmrg 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
19736ac495dSmrg 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
19836ac495dSmrg 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
19936ac495dSmrg 2, 2, 2, 10, 2, 2, 2, 2, 5, 2,
20036ac495dSmrg 14, 15, 2, 2, 2, 2, 2, 2, 2, 2,
20136ac495dSmrg 2, 2, 2, 2, 2, 2, 2, 2, 12, 2,
20236ac495dSmrg 2, 2, 2, 3, 2, 2, 2, 2, 2, 2,
20336ac495dSmrg 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
20436ac495dSmrg 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
20536ac495dSmrg 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
20636ac495dSmrg 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
20736ac495dSmrg 13, 2, 2, 2, 2, 2, 2, 2, 2, 2,
20836ac495dSmrg 2, 2, 2, 2, 4, 2, 2, 2, 2, 2,
20936ac495dSmrg 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
21036ac495dSmrg 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
21136ac495dSmrg 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
21236ac495dSmrg 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
21336ac495dSmrg 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
21436ac495dSmrg 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
21536ac495dSmrg 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
21636ac495dSmrg 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
21736ac495dSmrg 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
21836ac495dSmrg 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
21936ac495dSmrg 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
22036ac495dSmrg 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
22136ac495dSmrg 2, 2, 2, 2, 2, 2, 1, 6, 7, 8,
22236ac495dSmrg 9, 11
22336ac495dSmrg };
22436ac495dSmrg
22536ac495dSmrg #if YYDEBUG
22636ac495dSmrg static const short yyprhs[] =
22736ac495dSmrg {
22836ac495dSmrg 0, 0, 2, 8, 12, 16, 20, 24, 28, 32,
22936ac495dSmrg 35, 37, 39
23036ac495dSmrg };
23136ac495dSmrg static const short yyrhs[] =
23236ac495dSmrg {
23336ac495dSmrg 17, 0, 17, 3, 17, 12, 17, 0, 17, 4,
23436ac495dSmrg 17, 0, 17, 5, 17, 0, 17, 6, 17, 0,
23536ac495dSmrg 17, 7, 17, 0, 17, 8, 17, 0, 17, 9,
23636ac495dSmrg 17, 0, 10, 17, 0, 13, 0, 11, 0, 14,
23736ac495dSmrg 17, 15, 0
23836ac495dSmrg };
23936ac495dSmrg
24036ac495dSmrg #endif
24136ac495dSmrg
24236ac495dSmrg #if YYDEBUG
24336ac495dSmrg /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
24436ac495dSmrg static const short yyrline[] =
24536ac495dSmrg {
246*8feb0f0bSmrg 0, 184, 192, 196, 200, 204, 208, 212, 216, 220,
247*8feb0f0bSmrg 224, 228, 233
24836ac495dSmrg };
24936ac495dSmrg #endif
25036ac495dSmrg
25136ac495dSmrg
25236ac495dSmrg #if (YYDEBUG) || defined YYERROR_VERBOSE
25336ac495dSmrg
25436ac495dSmrg /* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */
25536ac495dSmrg static const char *const yytname[] =
25636ac495dSmrg {
25736ac495dSmrg "$", "error", "$undefined.", "'?'", "'|'", "'&'", "EQUOP2", "CMPOP2",
25836ac495dSmrg "ADDOP2", "MULOP2", "'!'", "NUMBER", "':'", "'n'", "'('", "')'",
25936ac495dSmrg "start", "exp", 0
26036ac495dSmrg };
26136ac495dSmrg #endif
26236ac495dSmrg
26336ac495dSmrg /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
26436ac495dSmrg static const short yyr1[] =
26536ac495dSmrg {
26636ac495dSmrg 0, 16, 17, 17, 17, 17, 17, 17, 17, 17,
26736ac495dSmrg 17, 17, 17
26836ac495dSmrg };
26936ac495dSmrg
27036ac495dSmrg /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
27136ac495dSmrg static const short yyr2[] =
27236ac495dSmrg {
27336ac495dSmrg 0, 1, 5, 3, 3, 3, 3, 3, 3, 2,
27436ac495dSmrg 1, 1, 3
27536ac495dSmrg };
27636ac495dSmrg
27736ac495dSmrg /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
27836ac495dSmrg doesn't specify something else to do. Zero means the default is an
27936ac495dSmrg error. */
28036ac495dSmrg static const short yydefact[] =
28136ac495dSmrg {
28236ac495dSmrg 0, 0, 11, 10, 0, 1, 9, 0, 0, 0,
28336ac495dSmrg 0, 0, 0, 0, 0, 12, 0, 3, 4, 5,
28436ac495dSmrg 6, 7, 8, 0, 2, 0, 0, 0
28536ac495dSmrg };
28636ac495dSmrg
28736ac495dSmrg static const short yydefgoto[] =
28836ac495dSmrg {
28936ac495dSmrg 25, 5
29036ac495dSmrg };
29136ac495dSmrg
29236ac495dSmrg static const short yypact[] =
29336ac495dSmrg {
29436ac495dSmrg -9, -9,-32768,-32768, -9, 34,-32768, 11, -9, -9,
29536ac495dSmrg -9, -9, -9, -9, -9,-32768, 24, 39, 43, 16,
29636ac495dSmrg 26, -3,-32768, -9, 34, 21, 53,-32768
29736ac495dSmrg };
29836ac495dSmrg
29936ac495dSmrg static const short yypgoto[] =
30036ac495dSmrg {
30136ac495dSmrg -32768, -1
30236ac495dSmrg };
30336ac495dSmrg
30436ac495dSmrg
30536ac495dSmrg #define YYLAST 53
30636ac495dSmrg
30736ac495dSmrg
30836ac495dSmrg static const short yytable[] =
30936ac495dSmrg {
31036ac495dSmrg 6, 1, 2, 7, 3, 4, 14, 16, 17, 18,
31136ac495dSmrg 19, 20, 21, 22, 8, 9, 10, 11, 12, 13,
31236ac495dSmrg 14, 26, 24, 12, 13, 14, 15, 8, 9, 10,
31336ac495dSmrg 11, 12, 13, 14, 13, 14, 23, 8, 9, 10,
31436ac495dSmrg 11, 12, 13, 14, 10, 11, 12, 13, 14, 11,
31536ac495dSmrg 12, 13, 14, 27
31636ac495dSmrg };
31736ac495dSmrg
31836ac495dSmrg static const short yycheck[] =
31936ac495dSmrg {
32036ac495dSmrg 1, 10, 11, 4, 13, 14, 9, 8, 9, 10,
32136ac495dSmrg 11, 12, 13, 14, 3, 4, 5, 6, 7, 8,
32236ac495dSmrg 9, 0, 23, 7, 8, 9, 15, 3, 4, 5,
32336ac495dSmrg 6, 7, 8, 9, 8, 9, 12, 3, 4, 5,
32436ac495dSmrg 6, 7, 8, 9, 5, 6, 7, 8, 9, 6,
32536ac495dSmrg 7, 8, 9, 0
32636ac495dSmrg };
32736ac495dSmrg #define YYPURE 1
32836ac495dSmrg
32936ac495dSmrg /* -*-C-*- Note some compilers choke on comments on `#line' lines. */
33036ac495dSmrg #line 3 "/usr/local/share/bison/bison.simple"
33136ac495dSmrg
33236ac495dSmrg /* Skeleton output parser for bison,
33336ac495dSmrg
33436ac495dSmrg Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software
33536ac495dSmrg Foundation, Inc.
33636ac495dSmrg
33736ac495dSmrg This program is free software; you can redistribute it and/or modify
33836ac495dSmrg it under the terms of the GNU General Public License as published by
33936ac495dSmrg the Free Software Foundation; either version 2, or (at your option)
34036ac495dSmrg any later version.
34136ac495dSmrg
34236ac495dSmrg This program is distributed in the hope that it will be useful,
34336ac495dSmrg but WITHOUT ANY WARRANTY; without even the implied warranty of
34436ac495dSmrg MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
34536ac495dSmrg GNU General Public License for more details.
34636ac495dSmrg
34736ac495dSmrg You should have received a copy of the GNU General Public License
34836ac495dSmrg along with this program; if not, write to the Free Software
349*8feb0f0bSmrg Foundation, Inc., 59 Temple Place - Suite 330,
350*8feb0f0bSmrg Boston, MA 02111-1307, USA. */
35136ac495dSmrg
35236ac495dSmrg /* As a special exception, when this file is copied by Bison into a
35336ac495dSmrg Bison output file, you may use that output file without restriction.
35436ac495dSmrg This special exception was added by the Free Software Foundation
35536ac495dSmrg in version 1.24 of Bison. */
35636ac495dSmrg
35736ac495dSmrg /* This is the parser code that is written into each bison parser when
35836ac495dSmrg the %semantic_parser declaration is not specified in the grammar.
35936ac495dSmrg It was written by Richard Stallman by simplifying the hairy parser
36036ac495dSmrg used when %semantic_parser is specified. */
36136ac495dSmrg
36236ac495dSmrg /* All symbols defined below should begin with yy or YY, to avoid
36336ac495dSmrg infringing on user name space. This should be done even for local
36436ac495dSmrg variables, as they might otherwise be expanded by user macros.
36536ac495dSmrg There are some unavoidable exceptions within include files to
36636ac495dSmrg define necessary library symbols; they are noted "INFRINGES ON
36736ac495dSmrg USER NAME SPACE" below. */
36836ac495dSmrg
36936ac495dSmrg #if ! defined (yyoverflow) || defined (YYERROR_VERBOSE)
37036ac495dSmrg
37136ac495dSmrg /* The parser invokes alloca or malloc; define the necessary symbols. */
37236ac495dSmrg
37336ac495dSmrg # if YYSTACK_USE_ALLOCA
37436ac495dSmrg # define YYSTACK_ALLOC alloca
37536ac495dSmrg # else
37636ac495dSmrg # ifndef YYSTACK_USE_ALLOCA
37736ac495dSmrg # if defined (alloca) || defined (_ALLOCA_H)
37836ac495dSmrg # define YYSTACK_ALLOC alloca
37936ac495dSmrg # else
38036ac495dSmrg # ifdef __GNUC__
38136ac495dSmrg # define YYSTACK_ALLOC __builtin_alloca
38236ac495dSmrg # endif
38336ac495dSmrg # endif
38436ac495dSmrg # endif
38536ac495dSmrg # endif
38636ac495dSmrg
38736ac495dSmrg # ifdef YYSTACK_ALLOC
38836ac495dSmrg /* Pacify GCC's `empty if-body' warning. */
38936ac495dSmrg # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
39036ac495dSmrg # else
39136ac495dSmrg # if defined (__STDC__) || defined (__cplusplus)
39236ac495dSmrg # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
39336ac495dSmrg # define YYSIZE_T size_t
39436ac495dSmrg # endif
39536ac495dSmrg # define YYSTACK_ALLOC malloc
39636ac495dSmrg # define YYSTACK_FREE free
39736ac495dSmrg # endif
39836ac495dSmrg #endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */
39936ac495dSmrg
40036ac495dSmrg
40136ac495dSmrg #if (! defined (yyoverflow) \
40236ac495dSmrg && (! defined (__cplusplus) \
40336ac495dSmrg || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
40436ac495dSmrg
40536ac495dSmrg /* A type that is properly aligned for any stack member. */
40636ac495dSmrg union yyalloc
40736ac495dSmrg {
40836ac495dSmrg short yyss;
40936ac495dSmrg YYSTYPE yyvs;
41036ac495dSmrg # if YYLSP_NEEDED
41136ac495dSmrg YYLTYPE yyls;
41236ac495dSmrg # endif
41336ac495dSmrg };
41436ac495dSmrg
41536ac495dSmrg /* The size of the maximum gap between one aligned stack and the next. */
41636ac495dSmrg # define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
41736ac495dSmrg
41836ac495dSmrg /* The size of an array large to enough to hold all stacks, each with
41936ac495dSmrg N elements. */
42036ac495dSmrg # if YYLSP_NEEDED
42136ac495dSmrg # define YYSTACK_BYTES(N) \
42236ac495dSmrg ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
42336ac495dSmrg + 2 * YYSTACK_GAP_MAX)
42436ac495dSmrg # else
42536ac495dSmrg # define YYSTACK_BYTES(N) \
42636ac495dSmrg ((N) * (sizeof (short) + sizeof (YYSTYPE)) \
42736ac495dSmrg + YYSTACK_GAP_MAX)
42836ac495dSmrg # endif
42936ac495dSmrg
43036ac495dSmrg /* Copy COUNT objects from FROM to TO. The source and destination do
43136ac495dSmrg not overlap. */
43236ac495dSmrg # ifndef YYCOPY
43336ac495dSmrg # if 1 < __GNUC__
43436ac495dSmrg # define YYCOPY(To, From, Count) \
43536ac495dSmrg __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
43636ac495dSmrg # else
43736ac495dSmrg # define YYCOPY(To, From, Count) \
43836ac495dSmrg do \
43936ac495dSmrg { \
44036ac495dSmrg register YYSIZE_T yyi; \
44136ac495dSmrg for (yyi = 0; yyi < (Count); yyi++) \
44236ac495dSmrg (To)[yyi] = (From)[yyi]; \
44336ac495dSmrg } \
44436ac495dSmrg while (0)
44536ac495dSmrg # endif
44636ac495dSmrg # endif
44736ac495dSmrg
44836ac495dSmrg /* Relocate STACK from its old location to the new one. The
44936ac495dSmrg local variables YYSIZE and YYSTACKSIZE give the old and new number of
45036ac495dSmrg elements in the stack, and YYPTR gives the new location of the
45136ac495dSmrg stack. Advance YYPTR to a properly aligned location for the next
45236ac495dSmrg stack. */
45336ac495dSmrg # define YYSTACK_RELOCATE(Stack) \
45436ac495dSmrg do \
45536ac495dSmrg { \
45636ac495dSmrg YYSIZE_T yynewbytes; \
45736ac495dSmrg YYCOPY (&yyptr->Stack, Stack, yysize); \
45836ac495dSmrg Stack = &yyptr->Stack; \
45936ac495dSmrg yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX; \
46036ac495dSmrg yyptr += yynewbytes / sizeof (*yyptr); \
46136ac495dSmrg } \
46236ac495dSmrg while (0)
46336ac495dSmrg
46436ac495dSmrg #endif
46536ac495dSmrg
46636ac495dSmrg
46736ac495dSmrg #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
46836ac495dSmrg # define YYSIZE_T __SIZE_TYPE__
46936ac495dSmrg #endif
47036ac495dSmrg #if ! defined (YYSIZE_T) && defined (size_t)
47136ac495dSmrg # define YYSIZE_T size_t
47236ac495dSmrg #endif
47336ac495dSmrg #if ! defined (YYSIZE_T)
47436ac495dSmrg # if defined (__STDC__) || defined (__cplusplus)
47536ac495dSmrg # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
47636ac495dSmrg # define YYSIZE_T size_t
47736ac495dSmrg # endif
47836ac495dSmrg #endif
47936ac495dSmrg #if ! defined (YYSIZE_T)
48036ac495dSmrg # define YYSIZE_T unsigned int
48136ac495dSmrg #endif
48236ac495dSmrg
48336ac495dSmrg #define yyerrok (yyerrstatus = 0)
48436ac495dSmrg #define yyclearin (yychar = YYEMPTY)
48536ac495dSmrg #define YYEMPTY -2
48636ac495dSmrg #define YYEOF 0
48736ac495dSmrg #define YYACCEPT goto yyacceptlab
48836ac495dSmrg #define YYABORT goto yyabortlab
48936ac495dSmrg #define YYERROR goto yyerrlab1
49036ac495dSmrg /* Like YYERROR except do call yyerror. This remains here temporarily
49136ac495dSmrg to ease the transition to the new meaning of YYERROR, for GCC.
49236ac495dSmrg Once GCC version 2 has supplanted version 1, this can go. */
49336ac495dSmrg #define YYFAIL goto yyerrlab
49436ac495dSmrg #define YYRECOVERING() (!!yyerrstatus)
49536ac495dSmrg #define YYBACKUP(Token, Value) \
49636ac495dSmrg do \
49736ac495dSmrg if (yychar == YYEMPTY && yylen == 1) \
49836ac495dSmrg { \
49936ac495dSmrg yychar = (Token); \
50036ac495dSmrg yylval = (Value); \
50136ac495dSmrg yychar1 = YYTRANSLATE (yychar); \
50236ac495dSmrg YYPOPSTACK; \
50336ac495dSmrg goto yybackup; \
50436ac495dSmrg } \
50536ac495dSmrg else \
50636ac495dSmrg { \
50736ac495dSmrg yyerror ("syntax error: cannot back up"); \
50836ac495dSmrg YYERROR; \
50936ac495dSmrg } \
51036ac495dSmrg while (0)
51136ac495dSmrg
51236ac495dSmrg #define YYTERROR 1
51336ac495dSmrg #define YYERRCODE 256
51436ac495dSmrg
51536ac495dSmrg
51636ac495dSmrg /* YYLLOC_DEFAULT -- Compute the default location (before the actions
51736ac495dSmrg are run).
51836ac495dSmrg
51936ac495dSmrg When YYLLOC_DEFAULT is run, CURRENT is set the location of the
52036ac495dSmrg first token. By default, to implement support for ranges, extend
52136ac495dSmrg its range to the last symbol. */
52236ac495dSmrg
52336ac495dSmrg #ifndef YYLLOC_DEFAULT
52436ac495dSmrg # define YYLLOC_DEFAULT(Current, Rhs, N) \
52536ac495dSmrg Current.last_line = Rhs[N].last_line; \
52636ac495dSmrg Current.last_column = Rhs[N].last_column;
52736ac495dSmrg #endif
52836ac495dSmrg
52936ac495dSmrg
53036ac495dSmrg /* YYLEX -- calling `yylex' with the right arguments. */
53136ac495dSmrg
53236ac495dSmrg #if YYPURE
53336ac495dSmrg # if YYLSP_NEEDED
53436ac495dSmrg # ifdef YYLEX_PARAM
53536ac495dSmrg # define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
53636ac495dSmrg # else
53736ac495dSmrg # define YYLEX yylex (&yylval, &yylloc)
53836ac495dSmrg # endif
53936ac495dSmrg # else /* !YYLSP_NEEDED */
54036ac495dSmrg # ifdef YYLEX_PARAM
54136ac495dSmrg # define YYLEX yylex (&yylval, YYLEX_PARAM)
54236ac495dSmrg # else
54336ac495dSmrg # define YYLEX yylex (&yylval)
54436ac495dSmrg # endif
54536ac495dSmrg # endif /* !YYLSP_NEEDED */
54636ac495dSmrg #else /* !YYPURE */
54736ac495dSmrg # define YYLEX yylex ()
54836ac495dSmrg #endif /* !YYPURE */
54936ac495dSmrg
55036ac495dSmrg
55136ac495dSmrg /* Enable debugging if requested. */
55236ac495dSmrg #if YYDEBUG
55336ac495dSmrg
55436ac495dSmrg # ifndef YYFPRINTF
55536ac495dSmrg # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
55636ac495dSmrg # define YYFPRINTF fprintf
55736ac495dSmrg # endif
55836ac495dSmrg
55936ac495dSmrg # define YYDPRINTF(Args) \
56036ac495dSmrg do { \
56136ac495dSmrg if (yydebug) \
56236ac495dSmrg YYFPRINTF Args; \
56336ac495dSmrg } while (0)
56436ac495dSmrg /* Nonzero means print parse trace. It is left uninitialized so that
56536ac495dSmrg multiple parsers can coexist. */
56636ac495dSmrg int yydebug;
56736ac495dSmrg #else /* !YYDEBUG */
56836ac495dSmrg # define YYDPRINTF(Args)
56936ac495dSmrg #endif /* !YYDEBUG */
57036ac495dSmrg
57136ac495dSmrg /* YYINITDEPTH -- initial size of the parser's stacks. */
57236ac495dSmrg #ifndef YYINITDEPTH
57336ac495dSmrg # define YYINITDEPTH 200
57436ac495dSmrg #endif
57536ac495dSmrg
57636ac495dSmrg /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
57736ac495dSmrg if the built-in stack extension method is used).
57836ac495dSmrg
57936ac495dSmrg Do not make this value too large; the results are undefined if
58036ac495dSmrg SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
58136ac495dSmrg evaluated with infinite-precision integer arithmetic. */
58236ac495dSmrg
58336ac495dSmrg #if YYMAXDEPTH == 0
58436ac495dSmrg # undef YYMAXDEPTH
58536ac495dSmrg #endif
58636ac495dSmrg
58736ac495dSmrg #ifndef YYMAXDEPTH
58836ac495dSmrg # define YYMAXDEPTH 10000
58936ac495dSmrg #endif
59036ac495dSmrg
59136ac495dSmrg #ifdef YYERROR_VERBOSE
59236ac495dSmrg
59336ac495dSmrg # ifndef yystrlen
59436ac495dSmrg # if defined (__GLIBC__) && defined (_STRING_H)
59536ac495dSmrg # define yystrlen strlen
59636ac495dSmrg # else
59736ac495dSmrg /* Return the length of YYSTR. */
59836ac495dSmrg static YYSIZE_T
59936ac495dSmrg # if defined (__STDC__) || defined (__cplusplus)
yystrlen(const char * yystr)60036ac495dSmrg yystrlen (const char *yystr)
60136ac495dSmrg # else
60236ac495dSmrg yystrlen (yystr)
60336ac495dSmrg const char *yystr;
60436ac495dSmrg # endif
60536ac495dSmrg {
60636ac495dSmrg register const char *yys = yystr;
60736ac495dSmrg
60836ac495dSmrg while (*yys++ != '\0')
60936ac495dSmrg continue;
61036ac495dSmrg
61136ac495dSmrg return yys - yystr - 1;
61236ac495dSmrg }
61336ac495dSmrg # endif
61436ac495dSmrg # endif
61536ac495dSmrg
61636ac495dSmrg # ifndef yystpcpy
61736ac495dSmrg # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
61836ac495dSmrg # define yystpcpy stpcpy
61936ac495dSmrg # else
62036ac495dSmrg /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
62136ac495dSmrg YYDEST. */
62236ac495dSmrg static char *
62336ac495dSmrg # if defined (__STDC__) || defined (__cplusplus)
yystpcpy(char * yydest,const char * yysrc)62436ac495dSmrg yystpcpy (char *yydest, const char *yysrc)
62536ac495dSmrg # else
62636ac495dSmrg yystpcpy (yydest, yysrc)
62736ac495dSmrg char *yydest;
62836ac495dSmrg const char *yysrc;
62936ac495dSmrg # endif
63036ac495dSmrg {
63136ac495dSmrg register char *yyd = yydest;
63236ac495dSmrg register const char *yys = yysrc;
63336ac495dSmrg
63436ac495dSmrg while ((*yyd++ = *yys++) != '\0')
63536ac495dSmrg continue;
63636ac495dSmrg
63736ac495dSmrg return yyd - 1;
63836ac495dSmrg }
63936ac495dSmrg # endif
64036ac495dSmrg # endif
64136ac495dSmrg #endif
64236ac495dSmrg
64336ac495dSmrg #line 315 "/usr/local/share/bison/bison.simple"
64436ac495dSmrg
64536ac495dSmrg
64636ac495dSmrg /* The user can define YYPARSE_PARAM as the name of an argument to be passed
64736ac495dSmrg into yyparse. The argument should have type void *.
64836ac495dSmrg It should actually point to an object.
64936ac495dSmrg Grammar actions can access the variable by casting it
65036ac495dSmrg to the proper pointer type. */
65136ac495dSmrg
65236ac495dSmrg #ifdef YYPARSE_PARAM
65336ac495dSmrg # if defined (__STDC__) || defined (__cplusplus)
65436ac495dSmrg # define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
65536ac495dSmrg # define YYPARSE_PARAM_DECL
65636ac495dSmrg # else
65736ac495dSmrg # define YYPARSE_PARAM_ARG YYPARSE_PARAM
65836ac495dSmrg # define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
65936ac495dSmrg # endif
66036ac495dSmrg #else /* !YYPARSE_PARAM */
66136ac495dSmrg # define YYPARSE_PARAM_ARG
66236ac495dSmrg # define YYPARSE_PARAM_DECL
66336ac495dSmrg #endif /* !YYPARSE_PARAM */
66436ac495dSmrg
66536ac495dSmrg /* Prevent warning if -Wstrict-prototypes. */
66636ac495dSmrg #ifdef __GNUC__
66736ac495dSmrg # ifdef YYPARSE_PARAM
66836ac495dSmrg int yyparse (void *);
66936ac495dSmrg # else
67036ac495dSmrg int yyparse (void);
67136ac495dSmrg # endif
67236ac495dSmrg #endif
67336ac495dSmrg
67436ac495dSmrg /* YY_DECL_VARIABLES -- depending whether we use a pure parser,
67536ac495dSmrg variables are global, or local to YYPARSE. */
67636ac495dSmrg
67736ac495dSmrg #define YY_DECL_NON_LSP_VARIABLES \
67836ac495dSmrg /* The lookahead symbol. */ \
67936ac495dSmrg int yychar; \
68036ac495dSmrg \
68136ac495dSmrg /* The semantic value of the lookahead symbol. */ \
68236ac495dSmrg YYSTYPE yylval; \
68336ac495dSmrg \
68436ac495dSmrg /* Number of parse errors so far. */ \
68536ac495dSmrg int yynerrs;
68636ac495dSmrg
68736ac495dSmrg #if YYLSP_NEEDED
68836ac495dSmrg # define YY_DECL_VARIABLES \
68936ac495dSmrg YY_DECL_NON_LSP_VARIABLES \
69036ac495dSmrg \
69136ac495dSmrg /* Location data for the lookahead symbol. */ \
69236ac495dSmrg YYLTYPE yylloc;
69336ac495dSmrg #else
69436ac495dSmrg # define YY_DECL_VARIABLES \
69536ac495dSmrg YY_DECL_NON_LSP_VARIABLES
69636ac495dSmrg #endif
69736ac495dSmrg
69836ac495dSmrg
69936ac495dSmrg /* If nonreentrant, generate the variables here. */
70036ac495dSmrg
70136ac495dSmrg #if !YYPURE
70236ac495dSmrg YY_DECL_VARIABLES
70336ac495dSmrg #endif /* !YYPURE */
70436ac495dSmrg
70536ac495dSmrg int
yyparse(YYPARSE_PARAM_ARG)70636ac495dSmrg yyparse (YYPARSE_PARAM_ARG)
70736ac495dSmrg YYPARSE_PARAM_DECL
70836ac495dSmrg {
70936ac495dSmrg /* If reentrant, generate the variables here. */
71036ac495dSmrg #if YYPURE
71136ac495dSmrg YY_DECL_VARIABLES
71236ac495dSmrg #endif /* !YYPURE */
71336ac495dSmrg
71436ac495dSmrg register int yystate;
71536ac495dSmrg register int yyn;
71636ac495dSmrg int yyresult;
71736ac495dSmrg /* Number of tokens to shift before error messages enabled. */
71836ac495dSmrg int yyerrstatus;
71936ac495dSmrg /* Lookahead token as an internal (translated) token number. */
72036ac495dSmrg int yychar1 = 0;
72136ac495dSmrg
72236ac495dSmrg /* Three stacks and their tools:
72336ac495dSmrg `yyss': related to states,
72436ac495dSmrg `yyvs': related to semantic values,
72536ac495dSmrg `yyls': related to locations.
72636ac495dSmrg
72736ac495dSmrg Refer to the stacks thru separate pointers, to allow yyoverflow
72836ac495dSmrg to reallocate them elsewhere. */
72936ac495dSmrg
73036ac495dSmrg /* The state stack. */
73136ac495dSmrg short yyssa[YYINITDEPTH];
73236ac495dSmrg short *yyss = yyssa;
73336ac495dSmrg register short *yyssp;
73436ac495dSmrg
73536ac495dSmrg /* The semantic value stack. */
73636ac495dSmrg YYSTYPE yyvsa[YYINITDEPTH];
73736ac495dSmrg YYSTYPE *yyvs = yyvsa;
73836ac495dSmrg register YYSTYPE *yyvsp;
73936ac495dSmrg
74036ac495dSmrg #if YYLSP_NEEDED
74136ac495dSmrg /* The location stack. */
74236ac495dSmrg YYLTYPE yylsa[YYINITDEPTH];
74336ac495dSmrg YYLTYPE *yyls = yylsa;
74436ac495dSmrg YYLTYPE *yylsp;
74536ac495dSmrg #endif
74636ac495dSmrg
74736ac495dSmrg #if YYLSP_NEEDED
74836ac495dSmrg # define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
74936ac495dSmrg #else
75036ac495dSmrg # define YYPOPSTACK (yyvsp--, yyssp--)
75136ac495dSmrg #endif
75236ac495dSmrg
75336ac495dSmrg YYSIZE_T yystacksize = YYINITDEPTH;
75436ac495dSmrg
75536ac495dSmrg
75636ac495dSmrg /* The variables used to return semantic value and location from the
75736ac495dSmrg action routines. */
75836ac495dSmrg YYSTYPE yyval;
75936ac495dSmrg #if YYLSP_NEEDED
76036ac495dSmrg YYLTYPE yyloc;
76136ac495dSmrg #endif
76236ac495dSmrg
76336ac495dSmrg /* When reducing, the number of symbols on the RHS of the reduced
76436ac495dSmrg rule. */
76536ac495dSmrg int yylen;
76636ac495dSmrg
76736ac495dSmrg YYDPRINTF ((stderr, "Starting parse\n"));
76836ac495dSmrg
76936ac495dSmrg yystate = 0;
77036ac495dSmrg yyerrstatus = 0;
77136ac495dSmrg yynerrs = 0;
77236ac495dSmrg yychar = YYEMPTY; /* Cause a token to be read. */
77336ac495dSmrg
77436ac495dSmrg /* Initialize stack pointers.
77536ac495dSmrg Waste one element of value and location stack
77636ac495dSmrg so that they stay on the same level as the state stack.
77736ac495dSmrg The wasted elements are never initialized. */
77836ac495dSmrg
77936ac495dSmrg yyssp = yyss;
78036ac495dSmrg yyvsp = yyvs;
78136ac495dSmrg #if YYLSP_NEEDED
78236ac495dSmrg yylsp = yyls;
78336ac495dSmrg #endif
78436ac495dSmrg goto yysetstate;
78536ac495dSmrg
78636ac495dSmrg /*------------------------------------------------------------.
78736ac495dSmrg | yynewstate -- Push a new state, which is found in yystate. |
78836ac495dSmrg `------------------------------------------------------------*/
78936ac495dSmrg yynewstate:
79036ac495dSmrg /* In all cases, when you get here, the value and location stacks
79136ac495dSmrg have just been pushed. so pushing a state here evens the stacks.
79236ac495dSmrg */
79336ac495dSmrg yyssp++;
79436ac495dSmrg
79536ac495dSmrg yysetstate:
79636ac495dSmrg *yyssp = yystate;
79736ac495dSmrg
79836ac495dSmrg if (yyssp >= yyss + yystacksize - 1)
79936ac495dSmrg {
80036ac495dSmrg /* Get the current used size of the three stacks, in elements. */
80136ac495dSmrg YYSIZE_T yysize = yyssp - yyss + 1;
80236ac495dSmrg
80336ac495dSmrg #ifdef yyoverflow
80436ac495dSmrg {
80536ac495dSmrg /* Give user a chance to reallocate the stack. Use copies of
80636ac495dSmrg these so that the &'s don't force the real ones into
80736ac495dSmrg memory. */
80836ac495dSmrg YYSTYPE *yyvs1 = yyvs;
80936ac495dSmrg short *yyss1 = yyss;
81036ac495dSmrg
81136ac495dSmrg /* Each stack pointer address is followed by the size of the
81236ac495dSmrg data in use in that stack, in bytes. */
81336ac495dSmrg # if YYLSP_NEEDED
81436ac495dSmrg YYLTYPE *yyls1 = yyls;
81536ac495dSmrg /* This used to be a conditional around just the two extra args,
81636ac495dSmrg but that might be undefined if yyoverflow is a macro. */
81736ac495dSmrg yyoverflow ("parser stack overflow",
81836ac495dSmrg &yyss1, yysize * sizeof (*yyssp),
81936ac495dSmrg &yyvs1, yysize * sizeof (*yyvsp),
82036ac495dSmrg &yyls1, yysize * sizeof (*yylsp),
82136ac495dSmrg &yystacksize);
82236ac495dSmrg yyls = yyls1;
82336ac495dSmrg # else
82436ac495dSmrg yyoverflow ("parser stack overflow",
82536ac495dSmrg &yyss1, yysize * sizeof (*yyssp),
82636ac495dSmrg &yyvs1, yysize * sizeof (*yyvsp),
82736ac495dSmrg &yystacksize);
82836ac495dSmrg # endif
82936ac495dSmrg yyss = yyss1;
83036ac495dSmrg yyvs = yyvs1;
83136ac495dSmrg }
83236ac495dSmrg #else /* no yyoverflow */
83336ac495dSmrg # ifndef YYSTACK_RELOCATE
83436ac495dSmrg goto yyoverflowlab;
83536ac495dSmrg # else
83636ac495dSmrg /* Extend the stack our own way. */
83736ac495dSmrg if (yystacksize >= YYMAXDEPTH)
83836ac495dSmrg goto yyoverflowlab;
83936ac495dSmrg yystacksize *= 2;
84036ac495dSmrg if (yystacksize > YYMAXDEPTH)
84136ac495dSmrg yystacksize = YYMAXDEPTH;
84236ac495dSmrg
84336ac495dSmrg {
84436ac495dSmrg short *yyss1 = yyss;
84536ac495dSmrg union yyalloc *yyptr =
84636ac495dSmrg (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
84736ac495dSmrg if (! yyptr)
84836ac495dSmrg goto yyoverflowlab;
84936ac495dSmrg YYSTACK_RELOCATE (yyss);
85036ac495dSmrg YYSTACK_RELOCATE (yyvs);
85136ac495dSmrg # if YYLSP_NEEDED
85236ac495dSmrg YYSTACK_RELOCATE (yyls);
85336ac495dSmrg # endif
85436ac495dSmrg # undef YYSTACK_RELOCATE
85536ac495dSmrg if (yyss1 != yyssa)
85636ac495dSmrg YYSTACK_FREE (yyss1);
85736ac495dSmrg }
85836ac495dSmrg # endif
85936ac495dSmrg #endif /* no yyoverflow */
86036ac495dSmrg
86136ac495dSmrg yyssp = yyss + yysize - 1;
86236ac495dSmrg yyvsp = yyvs + yysize - 1;
86336ac495dSmrg #if YYLSP_NEEDED
86436ac495dSmrg yylsp = yyls + yysize - 1;
86536ac495dSmrg #endif
86636ac495dSmrg
86736ac495dSmrg YYDPRINTF ((stderr, "Stack size increased to %lu\n",
86836ac495dSmrg (unsigned long int) yystacksize));
86936ac495dSmrg
87036ac495dSmrg if (yyssp >= yyss + yystacksize - 1)
87136ac495dSmrg YYABORT;
87236ac495dSmrg }
87336ac495dSmrg
87436ac495dSmrg YYDPRINTF ((stderr, "Entering state %d\n", yystate));
87536ac495dSmrg
87636ac495dSmrg goto yybackup;
87736ac495dSmrg
87836ac495dSmrg
87936ac495dSmrg /*-----------.
88036ac495dSmrg | yybackup. |
88136ac495dSmrg `-----------*/
88236ac495dSmrg yybackup:
88336ac495dSmrg
88436ac495dSmrg /* Do appropriate processing given the current state. */
88536ac495dSmrg /* Read a lookahead token if we need one and don't already have one. */
88636ac495dSmrg /* yyresume: */
88736ac495dSmrg
88836ac495dSmrg /* First try to decide what to do without reference to lookahead token. */
88936ac495dSmrg
89036ac495dSmrg yyn = yypact[yystate];
89136ac495dSmrg if (yyn == YYFLAG)
89236ac495dSmrg goto yydefault;
89336ac495dSmrg
89436ac495dSmrg /* Not known => get a lookahead token if don't already have one. */
89536ac495dSmrg
89636ac495dSmrg /* yychar is either YYEMPTY or YYEOF
89736ac495dSmrg or a valid token in external form. */
89836ac495dSmrg
89936ac495dSmrg if (yychar == YYEMPTY)
90036ac495dSmrg {
90136ac495dSmrg YYDPRINTF ((stderr, "Reading a token: "));
90236ac495dSmrg yychar = YYLEX;
90336ac495dSmrg }
90436ac495dSmrg
90536ac495dSmrg /* Convert token to internal form (in yychar1) for indexing tables with */
90636ac495dSmrg
90736ac495dSmrg if (yychar <= 0) /* This means end of input. */
90836ac495dSmrg {
90936ac495dSmrg yychar1 = 0;
91036ac495dSmrg yychar = YYEOF; /* Don't call YYLEX any more */
91136ac495dSmrg
91236ac495dSmrg YYDPRINTF ((stderr, "Now at end of input.\n"));
91336ac495dSmrg }
91436ac495dSmrg else
91536ac495dSmrg {
91636ac495dSmrg yychar1 = YYTRANSLATE (yychar);
91736ac495dSmrg
91836ac495dSmrg #if YYDEBUG
91936ac495dSmrg /* We have to keep this `#if YYDEBUG', since we use variables
92036ac495dSmrg which are defined only if `YYDEBUG' is set. */
92136ac495dSmrg if (yydebug)
92236ac495dSmrg {
92336ac495dSmrg YYFPRINTF (stderr, "Next token is %d (%s",
92436ac495dSmrg yychar, yytname[yychar1]);
92536ac495dSmrg /* Give the individual parser a way to print the precise
92636ac495dSmrg meaning of a token, for further debugging info. */
92736ac495dSmrg # ifdef YYPRINT
92836ac495dSmrg YYPRINT (stderr, yychar, yylval);
92936ac495dSmrg # endif
93036ac495dSmrg YYFPRINTF (stderr, ")\n");
93136ac495dSmrg }
93236ac495dSmrg #endif
93336ac495dSmrg }
93436ac495dSmrg
93536ac495dSmrg yyn += yychar1;
93636ac495dSmrg if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
93736ac495dSmrg goto yydefault;
93836ac495dSmrg
93936ac495dSmrg yyn = yytable[yyn];
94036ac495dSmrg
94136ac495dSmrg /* yyn is what to do for this token type in this state.
94236ac495dSmrg Negative => reduce, -yyn is rule number.
94336ac495dSmrg Positive => shift, yyn is new state.
94436ac495dSmrg New state is final state => don't bother to shift,
94536ac495dSmrg just return success.
94636ac495dSmrg 0, or most negative number => error. */
94736ac495dSmrg
94836ac495dSmrg if (yyn < 0)
94936ac495dSmrg {
95036ac495dSmrg if (yyn == YYFLAG)
95136ac495dSmrg goto yyerrlab;
95236ac495dSmrg yyn = -yyn;
95336ac495dSmrg goto yyreduce;
95436ac495dSmrg }
95536ac495dSmrg else if (yyn == 0)
95636ac495dSmrg goto yyerrlab;
95736ac495dSmrg
95836ac495dSmrg if (yyn == YYFINAL)
95936ac495dSmrg YYACCEPT;
96036ac495dSmrg
96136ac495dSmrg /* Shift the lookahead token. */
96236ac495dSmrg YYDPRINTF ((stderr, "Shifting token %d (%s), ",
96336ac495dSmrg yychar, yytname[yychar1]));
96436ac495dSmrg
96536ac495dSmrg /* Discard the token being shifted unless it is eof. */
96636ac495dSmrg if (yychar != YYEOF)
96736ac495dSmrg yychar = YYEMPTY;
96836ac495dSmrg
96936ac495dSmrg *++yyvsp = yylval;
97036ac495dSmrg #if YYLSP_NEEDED
97136ac495dSmrg *++yylsp = yylloc;
97236ac495dSmrg #endif
97336ac495dSmrg
97436ac495dSmrg /* Count tokens shifted since error; after three, turn off error
97536ac495dSmrg status. */
97636ac495dSmrg if (yyerrstatus)
97736ac495dSmrg yyerrstatus--;
97836ac495dSmrg
97936ac495dSmrg yystate = yyn;
98036ac495dSmrg goto yynewstate;
98136ac495dSmrg
98236ac495dSmrg
98336ac495dSmrg /*-----------------------------------------------------------.
98436ac495dSmrg | yydefault -- do the default action for the current state. |
98536ac495dSmrg `-----------------------------------------------------------*/
98636ac495dSmrg yydefault:
98736ac495dSmrg yyn = yydefact[yystate];
98836ac495dSmrg if (yyn == 0)
98936ac495dSmrg goto yyerrlab;
99036ac495dSmrg goto yyreduce;
99136ac495dSmrg
99236ac495dSmrg
99336ac495dSmrg /*-----------------------------.
99436ac495dSmrg | yyreduce -- Do a reduction. |
99536ac495dSmrg `-----------------------------*/
99636ac495dSmrg yyreduce:
99736ac495dSmrg /* yyn is the number of a rule to reduce with. */
99836ac495dSmrg yylen = yyr2[yyn];
99936ac495dSmrg
100036ac495dSmrg /* If YYLEN is nonzero, implement the default value of the action:
100136ac495dSmrg `$$ = $1'.
100236ac495dSmrg
100336ac495dSmrg Otherwise, the following line sets YYVAL to the semantic value of
100436ac495dSmrg the lookahead token. This behavior is undocumented and Bison
100536ac495dSmrg users should not rely upon it. Assigning to YYVAL
100636ac495dSmrg unconditionally makes the parser a bit smaller, and it avoids a
100736ac495dSmrg GCC warning that YYVAL may be used uninitialized. */
100836ac495dSmrg yyval = yyvsp[1-yylen];
100936ac495dSmrg
101036ac495dSmrg #if YYLSP_NEEDED
101136ac495dSmrg /* Similarly for the default location. Let the user run additional
101236ac495dSmrg commands if for instance locations are ranges. */
101336ac495dSmrg yyloc = yylsp[1-yylen];
101436ac495dSmrg YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
101536ac495dSmrg #endif
101636ac495dSmrg
101736ac495dSmrg #if YYDEBUG
101836ac495dSmrg /* We have to keep this `#if YYDEBUG', since we use variables which
101936ac495dSmrg are defined only if `YYDEBUG' is set. */
102036ac495dSmrg if (yydebug)
102136ac495dSmrg {
102236ac495dSmrg int yyi;
102336ac495dSmrg
102436ac495dSmrg YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
102536ac495dSmrg yyn, yyrline[yyn]);
102636ac495dSmrg
102736ac495dSmrg /* Print the symbols being reduced, and their result. */
102836ac495dSmrg for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)
102936ac495dSmrg YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
103036ac495dSmrg YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
103136ac495dSmrg }
103236ac495dSmrg #endif
103336ac495dSmrg
103436ac495dSmrg switch (yyn) {
103536ac495dSmrg
103636ac495dSmrg case 1:
1037*8feb0f0bSmrg #line 185 "plural.y"
103836ac495dSmrg {
103936ac495dSmrg if (yyvsp[0].exp == NULL)
104036ac495dSmrg YYABORT;
104136ac495dSmrg ((struct parse_args *) arg)->res = yyvsp[0].exp;
104236ac495dSmrg }
104336ac495dSmrg break;
104436ac495dSmrg case 2:
1045*8feb0f0bSmrg #line 193 "plural.y"
104636ac495dSmrg {
104736ac495dSmrg yyval.exp = new_exp_3 (qmop, yyvsp[-4].exp, yyvsp[-2].exp, yyvsp[0].exp);
104836ac495dSmrg }
104936ac495dSmrg break;
105036ac495dSmrg case 3:
1051*8feb0f0bSmrg #line 197 "plural.y"
105236ac495dSmrg {
105336ac495dSmrg yyval.exp = new_exp_2 (lor, yyvsp[-2].exp, yyvsp[0].exp);
105436ac495dSmrg }
105536ac495dSmrg break;
105636ac495dSmrg case 4:
1057*8feb0f0bSmrg #line 201 "plural.y"
105836ac495dSmrg {
105936ac495dSmrg yyval.exp = new_exp_2 (land, yyvsp[-2].exp, yyvsp[0].exp);
106036ac495dSmrg }
106136ac495dSmrg break;
106236ac495dSmrg case 5:
1063*8feb0f0bSmrg #line 205 "plural.y"
106436ac495dSmrg {
106536ac495dSmrg yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
106636ac495dSmrg }
106736ac495dSmrg break;
106836ac495dSmrg case 6:
1069*8feb0f0bSmrg #line 209 "plural.y"
107036ac495dSmrg {
107136ac495dSmrg yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
107236ac495dSmrg }
107336ac495dSmrg break;
107436ac495dSmrg case 7:
1075*8feb0f0bSmrg #line 213 "plural.y"
107636ac495dSmrg {
107736ac495dSmrg yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
107836ac495dSmrg }
107936ac495dSmrg break;
108036ac495dSmrg case 8:
1081*8feb0f0bSmrg #line 217 "plural.y"
108236ac495dSmrg {
108336ac495dSmrg yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
108436ac495dSmrg }
108536ac495dSmrg break;
108636ac495dSmrg case 9:
1087*8feb0f0bSmrg #line 221 "plural.y"
108836ac495dSmrg {
108936ac495dSmrg yyval.exp = new_exp_1 (lnot, yyvsp[0].exp);
109036ac495dSmrg }
109136ac495dSmrg break;
109236ac495dSmrg case 10:
1093*8feb0f0bSmrg #line 225 "plural.y"
109436ac495dSmrg {
109536ac495dSmrg yyval.exp = new_exp_0 (var);
109636ac495dSmrg }
109736ac495dSmrg break;
109836ac495dSmrg case 11:
1099*8feb0f0bSmrg #line 229 "plural.y"
110036ac495dSmrg {
110136ac495dSmrg if ((yyval.exp = new_exp_0 (num)) != NULL)
110236ac495dSmrg yyval.exp->val.num = yyvsp[0].num;
110336ac495dSmrg }
110436ac495dSmrg break;
110536ac495dSmrg case 12:
1106*8feb0f0bSmrg #line 234 "plural.y"
110736ac495dSmrg {
110836ac495dSmrg yyval.exp = yyvsp[-1].exp;
110936ac495dSmrg }
111036ac495dSmrg break;
111136ac495dSmrg }
111236ac495dSmrg
111336ac495dSmrg #line 705 "/usr/local/share/bison/bison.simple"
111436ac495dSmrg
111536ac495dSmrg
111636ac495dSmrg yyvsp -= yylen;
111736ac495dSmrg yyssp -= yylen;
111836ac495dSmrg #if YYLSP_NEEDED
111936ac495dSmrg yylsp -= yylen;
112036ac495dSmrg #endif
112136ac495dSmrg
112236ac495dSmrg #if YYDEBUG
112336ac495dSmrg if (yydebug)
112436ac495dSmrg {
112536ac495dSmrg short *yyssp1 = yyss - 1;
112636ac495dSmrg YYFPRINTF (stderr, "state stack now");
112736ac495dSmrg while (yyssp1 != yyssp)
112836ac495dSmrg YYFPRINTF (stderr, " %d", *++yyssp1);
112936ac495dSmrg YYFPRINTF (stderr, "\n");
113036ac495dSmrg }
113136ac495dSmrg #endif
113236ac495dSmrg
113336ac495dSmrg *++yyvsp = yyval;
113436ac495dSmrg #if YYLSP_NEEDED
113536ac495dSmrg *++yylsp = yyloc;
113636ac495dSmrg #endif
113736ac495dSmrg
113836ac495dSmrg /* Now `shift' the result of the reduction. Determine what state
113936ac495dSmrg that goes to, based on the state we popped back to and the rule
114036ac495dSmrg number reduced by. */
114136ac495dSmrg
114236ac495dSmrg yyn = yyr1[yyn];
114336ac495dSmrg
114436ac495dSmrg yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
114536ac495dSmrg if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
114636ac495dSmrg yystate = yytable[yystate];
114736ac495dSmrg else
114836ac495dSmrg yystate = yydefgoto[yyn - YYNTBASE];
114936ac495dSmrg
115036ac495dSmrg goto yynewstate;
115136ac495dSmrg
115236ac495dSmrg
115336ac495dSmrg /*------------------------------------.
115436ac495dSmrg | yyerrlab -- here on detecting error |
115536ac495dSmrg `------------------------------------*/
115636ac495dSmrg yyerrlab:
115736ac495dSmrg /* If not already recovering from an error, report this error. */
115836ac495dSmrg if (!yyerrstatus)
115936ac495dSmrg {
116036ac495dSmrg ++yynerrs;
116136ac495dSmrg
116236ac495dSmrg #ifdef YYERROR_VERBOSE
116336ac495dSmrg yyn = yypact[yystate];
116436ac495dSmrg
116536ac495dSmrg if (yyn > YYFLAG && yyn < YYLAST)
116636ac495dSmrg {
116736ac495dSmrg YYSIZE_T yysize = 0;
116836ac495dSmrg char *yymsg;
116936ac495dSmrg int yyx, yycount;
117036ac495dSmrg
117136ac495dSmrg yycount = 0;
117236ac495dSmrg /* Start YYX at -YYN if negative to avoid negative indexes in
117336ac495dSmrg YYCHECK. */
117436ac495dSmrg for (yyx = yyn < 0 ? -yyn : 0;
117536ac495dSmrg yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
117636ac495dSmrg if (yycheck[yyx + yyn] == yyx)
117736ac495dSmrg yysize += yystrlen (yytname[yyx]) + 15, yycount++;
117836ac495dSmrg yysize += yystrlen ("parse error, unexpected ") + 1;
117936ac495dSmrg yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);
118036ac495dSmrg yymsg = (char *) YYSTACK_ALLOC (yysize);
118136ac495dSmrg if (yymsg != 0)
118236ac495dSmrg {
118336ac495dSmrg char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
118436ac495dSmrg yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);
118536ac495dSmrg
118636ac495dSmrg if (yycount < 5)
118736ac495dSmrg {
118836ac495dSmrg yycount = 0;
118936ac495dSmrg for (yyx = yyn < 0 ? -yyn : 0;
119036ac495dSmrg yyx < (int) (sizeof (yytname) / sizeof (char *));
119136ac495dSmrg yyx++)
119236ac495dSmrg if (yycheck[yyx + yyn] == yyx)
119336ac495dSmrg {
119436ac495dSmrg const char *yyq = ! yycount ? ", expecting " : " or ";
119536ac495dSmrg yyp = yystpcpy (yyp, yyq);
119636ac495dSmrg yyp = yystpcpy (yyp, yytname[yyx]);
119736ac495dSmrg yycount++;
119836ac495dSmrg }
119936ac495dSmrg }
120036ac495dSmrg yyerror (yymsg);
120136ac495dSmrg YYSTACK_FREE (yymsg);
120236ac495dSmrg }
120336ac495dSmrg else
120436ac495dSmrg yyerror ("parse error; also virtual memory exhausted");
120536ac495dSmrg }
120636ac495dSmrg else
120736ac495dSmrg #endif /* defined (YYERROR_VERBOSE) */
120836ac495dSmrg yyerror ("parse error");
120936ac495dSmrg }
121036ac495dSmrg goto yyerrlab1;
121136ac495dSmrg
121236ac495dSmrg
121336ac495dSmrg /*--------------------------------------------------.
121436ac495dSmrg | yyerrlab1 -- error raised explicitly by an action |
121536ac495dSmrg `--------------------------------------------------*/
121636ac495dSmrg yyerrlab1:
121736ac495dSmrg if (yyerrstatus == 3)
121836ac495dSmrg {
121936ac495dSmrg /* If just tried and failed to reuse lookahead token after an
122036ac495dSmrg error, discard it. */
122136ac495dSmrg
122236ac495dSmrg /* return failure if at end of input */
122336ac495dSmrg if (yychar == YYEOF)
122436ac495dSmrg YYABORT;
122536ac495dSmrg YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
122636ac495dSmrg yychar, yytname[yychar1]));
122736ac495dSmrg yychar = YYEMPTY;
122836ac495dSmrg }
122936ac495dSmrg
123036ac495dSmrg /* Else will try to reuse lookahead token after shifting the error
123136ac495dSmrg token. */
123236ac495dSmrg
123336ac495dSmrg yyerrstatus = 3; /* Each real token shifted decrements this */
123436ac495dSmrg
123536ac495dSmrg goto yyerrhandle;
123636ac495dSmrg
123736ac495dSmrg
123836ac495dSmrg /*-------------------------------------------------------------------.
123936ac495dSmrg | yyerrdefault -- current state does not do anything special for the |
124036ac495dSmrg | error token. |
124136ac495dSmrg `-------------------------------------------------------------------*/
124236ac495dSmrg yyerrdefault:
124336ac495dSmrg #if 0
124436ac495dSmrg /* This is wrong; only states that explicitly want error tokens
124536ac495dSmrg should shift them. */
124636ac495dSmrg
124736ac495dSmrg /* If its default is to accept any token, ok. Otherwise pop it. */
124836ac495dSmrg yyn = yydefact[yystate];
124936ac495dSmrg if (yyn)
125036ac495dSmrg goto yydefault;
125136ac495dSmrg #endif
125236ac495dSmrg
125336ac495dSmrg
125436ac495dSmrg /*---------------------------------------------------------------.
125536ac495dSmrg | yyerrpop -- pop the current state because it cannot handle the |
125636ac495dSmrg | error token |
125736ac495dSmrg `---------------------------------------------------------------*/
125836ac495dSmrg yyerrpop:
125936ac495dSmrg if (yyssp == yyss)
126036ac495dSmrg YYABORT;
126136ac495dSmrg yyvsp--;
126236ac495dSmrg yystate = *--yyssp;
126336ac495dSmrg #if YYLSP_NEEDED
126436ac495dSmrg yylsp--;
126536ac495dSmrg #endif
126636ac495dSmrg
126736ac495dSmrg #if YYDEBUG
126836ac495dSmrg if (yydebug)
126936ac495dSmrg {
127036ac495dSmrg short *yyssp1 = yyss - 1;
127136ac495dSmrg YYFPRINTF (stderr, "Error: state stack now");
127236ac495dSmrg while (yyssp1 != yyssp)
127336ac495dSmrg YYFPRINTF (stderr, " %d", *++yyssp1);
127436ac495dSmrg YYFPRINTF (stderr, "\n");
127536ac495dSmrg }
127636ac495dSmrg #endif
127736ac495dSmrg
127836ac495dSmrg /*--------------.
127936ac495dSmrg | yyerrhandle. |
128036ac495dSmrg `--------------*/
128136ac495dSmrg yyerrhandle:
128236ac495dSmrg yyn = yypact[yystate];
128336ac495dSmrg if (yyn == YYFLAG)
128436ac495dSmrg goto yyerrdefault;
128536ac495dSmrg
128636ac495dSmrg yyn += YYTERROR;
128736ac495dSmrg if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
128836ac495dSmrg goto yyerrdefault;
128936ac495dSmrg
129036ac495dSmrg yyn = yytable[yyn];
129136ac495dSmrg if (yyn < 0)
129236ac495dSmrg {
129336ac495dSmrg if (yyn == YYFLAG)
129436ac495dSmrg goto yyerrpop;
129536ac495dSmrg yyn = -yyn;
129636ac495dSmrg goto yyreduce;
129736ac495dSmrg }
129836ac495dSmrg else if (yyn == 0)
129936ac495dSmrg goto yyerrpop;
130036ac495dSmrg
130136ac495dSmrg if (yyn == YYFINAL)
130236ac495dSmrg YYACCEPT;
130336ac495dSmrg
130436ac495dSmrg YYDPRINTF ((stderr, "Shifting error token, "));
130536ac495dSmrg
130636ac495dSmrg *++yyvsp = yylval;
130736ac495dSmrg #if YYLSP_NEEDED
130836ac495dSmrg *++yylsp = yylloc;
130936ac495dSmrg #endif
131036ac495dSmrg
131136ac495dSmrg yystate = yyn;
131236ac495dSmrg goto yynewstate;
131336ac495dSmrg
131436ac495dSmrg
131536ac495dSmrg /*-------------------------------------.
131636ac495dSmrg | yyacceptlab -- YYACCEPT comes here. |
131736ac495dSmrg `-------------------------------------*/
131836ac495dSmrg yyacceptlab:
131936ac495dSmrg yyresult = 0;
132036ac495dSmrg goto yyreturn;
132136ac495dSmrg
132236ac495dSmrg /*-----------------------------------.
132336ac495dSmrg | yyabortlab -- YYABORT comes here. |
132436ac495dSmrg `-----------------------------------*/
132536ac495dSmrg yyabortlab:
132636ac495dSmrg yyresult = 1;
132736ac495dSmrg goto yyreturn;
132836ac495dSmrg
132936ac495dSmrg /*---------------------------------------------.
133036ac495dSmrg | yyoverflowab -- parser overflow comes here. |
133136ac495dSmrg `---------------------------------------------*/
133236ac495dSmrg yyoverflowlab:
133336ac495dSmrg yyerror ("parser stack overflow");
133436ac495dSmrg yyresult = 2;
133536ac495dSmrg /* Fall through. */
133636ac495dSmrg
133736ac495dSmrg yyreturn:
133836ac495dSmrg #ifndef yyoverflow
133936ac495dSmrg if (yyss != yyssa)
134036ac495dSmrg YYSTACK_FREE (yyss);
134136ac495dSmrg #endif
134236ac495dSmrg return yyresult;
134336ac495dSmrg }
1344*8feb0f0bSmrg #line 239 "plural.y"
134536ac495dSmrg
134636ac495dSmrg
134736ac495dSmrg void
134836ac495dSmrg internal_function
FREE_EXPRESSION(exp)134936ac495dSmrg FREE_EXPRESSION (exp)
135036ac495dSmrg struct expression *exp;
135136ac495dSmrg {
135236ac495dSmrg if (exp == NULL)
135336ac495dSmrg return;
135436ac495dSmrg
135536ac495dSmrg /* Handle the recursive case. */
135636ac495dSmrg switch (exp->nargs)
135736ac495dSmrg {
135836ac495dSmrg case 3:
135936ac495dSmrg FREE_EXPRESSION (exp->val.args[2]);
136036ac495dSmrg /* FALLTHROUGH */
136136ac495dSmrg case 2:
136236ac495dSmrg FREE_EXPRESSION (exp->val.args[1]);
136336ac495dSmrg /* FALLTHROUGH */
136436ac495dSmrg case 1:
136536ac495dSmrg FREE_EXPRESSION (exp->val.args[0]);
136636ac495dSmrg /* FALLTHROUGH */
136736ac495dSmrg default:
136836ac495dSmrg break;
136936ac495dSmrg }
137036ac495dSmrg
137136ac495dSmrg free (exp);
137236ac495dSmrg }
137336ac495dSmrg
137436ac495dSmrg
1375*8feb0f0bSmrg #ifdef USE_BISON3
1376*8feb0f0bSmrg static int
yylex(lval,arg)1377*8feb0f0bSmrg yylex (lval, arg)
1378*8feb0f0bSmrg YYSTYPE *lval;
1379*8feb0f0bSmrg struct parse_args *arg;
1380*8feb0f0bSmrg {
1381*8feb0f0bSmrg const char **pexp = &arg->cp;
1382*8feb0f0bSmrg #else
138336ac495dSmrg static int
138436ac495dSmrg yylex (lval, pexp)
138536ac495dSmrg YYSTYPE *lval;
138636ac495dSmrg const char **pexp;
138736ac495dSmrg {
1388*8feb0f0bSmrg #endif
138936ac495dSmrg const char *exp = *pexp;
139036ac495dSmrg int result;
139136ac495dSmrg
139236ac495dSmrg while (1)
139336ac495dSmrg {
139436ac495dSmrg if (exp[0] == '\0')
139536ac495dSmrg {
139636ac495dSmrg *pexp = exp;
139736ac495dSmrg return YYEOF;
139836ac495dSmrg }
139936ac495dSmrg
140036ac495dSmrg if (exp[0] != ' ' && exp[0] != '\t')
140136ac495dSmrg break;
140236ac495dSmrg
140336ac495dSmrg ++exp;
140436ac495dSmrg }
140536ac495dSmrg
140636ac495dSmrg result = *exp++;
140736ac495dSmrg switch (result)
140836ac495dSmrg {
140936ac495dSmrg case '0': case '1': case '2': case '3': case '4':
141036ac495dSmrg case '5': case '6': case '7': case '8': case '9':
141136ac495dSmrg {
141236ac495dSmrg unsigned long int n = result - '0';
141336ac495dSmrg while (exp[0] >= '0' && exp[0] <= '9')
141436ac495dSmrg {
141536ac495dSmrg n *= 10;
141636ac495dSmrg n += exp[0] - '0';
141736ac495dSmrg ++exp;
141836ac495dSmrg }
141936ac495dSmrg lval->num = n;
142036ac495dSmrg result = NUMBER;
142136ac495dSmrg }
142236ac495dSmrg break;
142336ac495dSmrg
142436ac495dSmrg case '=':
142536ac495dSmrg if (exp[0] == '=')
142636ac495dSmrg {
142736ac495dSmrg ++exp;
142836ac495dSmrg lval->op = equal;
142936ac495dSmrg result = EQUOP2;
143036ac495dSmrg }
143136ac495dSmrg else
143236ac495dSmrg result = YYERRCODE;
143336ac495dSmrg break;
143436ac495dSmrg
143536ac495dSmrg case '!':
143636ac495dSmrg if (exp[0] == '=')
143736ac495dSmrg {
143836ac495dSmrg ++exp;
143936ac495dSmrg lval->op = not_equal;
144036ac495dSmrg result = EQUOP2;
144136ac495dSmrg }
144236ac495dSmrg break;
144336ac495dSmrg
144436ac495dSmrg case '&':
144536ac495dSmrg case '|':
144636ac495dSmrg if (exp[0] == result)
144736ac495dSmrg ++exp;
144836ac495dSmrg else
144936ac495dSmrg result = YYERRCODE;
145036ac495dSmrg break;
145136ac495dSmrg
145236ac495dSmrg case '<':
145336ac495dSmrg if (exp[0] == '=')
145436ac495dSmrg {
145536ac495dSmrg ++exp;
145636ac495dSmrg lval->op = less_or_equal;
145736ac495dSmrg }
145836ac495dSmrg else
145936ac495dSmrg lval->op = less_than;
146036ac495dSmrg result = CMPOP2;
146136ac495dSmrg break;
146236ac495dSmrg
146336ac495dSmrg case '>':
146436ac495dSmrg if (exp[0] == '=')
146536ac495dSmrg {
146636ac495dSmrg ++exp;
146736ac495dSmrg lval->op = greater_or_equal;
146836ac495dSmrg }
146936ac495dSmrg else
147036ac495dSmrg lval->op = greater_than;
147136ac495dSmrg result = CMPOP2;
147236ac495dSmrg break;
147336ac495dSmrg
147436ac495dSmrg case '*':
147536ac495dSmrg lval->op = mult;
147636ac495dSmrg result = MULOP2;
147736ac495dSmrg break;
147836ac495dSmrg
147936ac495dSmrg case '/':
148036ac495dSmrg lval->op = divide;
148136ac495dSmrg result = MULOP2;
148236ac495dSmrg break;
148336ac495dSmrg
148436ac495dSmrg case '%':
148536ac495dSmrg lval->op = module;
148636ac495dSmrg result = MULOP2;
148736ac495dSmrg break;
148836ac495dSmrg
148936ac495dSmrg case '+':
149036ac495dSmrg lval->op = plus;
149136ac495dSmrg result = ADDOP2;
149236ac495dSmrg break;
149336ac495dSmrg
149436ac495dSmrg case '-':
149536ac495dSmrg lval->op = minus;
149636ac495dSmrg result = ADDOP2;
149736ac495dSmrg break;
149836ac495dSmrg
149936ac495dSmrg case 'n':
150036ac495dSmrg case '?':
150136ac495dSmrg case ':':
150236ac495dSmrg case '(':
150336ac495dSmrg case ')':
150436ac495dSmrg /* Nothing, just return the character. */
150536ac495dSmrg break;
150636ac495dSmrg
150736ac495dSmrg case ';':
150836ac495dSmrg case '\n':
150936ac495dSmrg case '\0':
151036ac495dSmrg /* Be safe and let the user call this function again. */
151136ac495dSmrg --exp;
151236ac495dSmrg result = YYEOF;
151336ac495dSmrg break;
151436ac495dSmrg
151536ac495dSmrg default:
151636ac495dSmrg result = YYERRCODE;
151736ac495dSmrg #if YYDEBUG != 0
151836ac495dSmrg --exp;
151936ac495dSmrg #endif
152036ac495dSmrg break;
152136ac495dSmrg }
152236ac495dSmrg
152336ac495dSmrg *pexp = exp;
152436ac495dSmrg
152536ac495dSmrg return result;
152636ac495dSmrg }
152736ac495dSmrg
152836ac495dSmrg
1529*8feb0f0bSmrg #ifdef USE_BISON3
1530*8feb0f0bSmrg static void
yyerror(arg,str)1531*8feb0f0bSmrg yyerror (arg, str)
1532*8feb0f0bSmrg struct parse_args *arg;
1533*8feb0f0bSmrg #else
153436ac495dSmrg static void
153536ac495dSmrg yyerror (str)
1536*8feb0f0bSmrg #endif
153736ac495dSmrg const char *str;
153836ac495dSmrg {
153936ac495dSmrg /* Do nothing. We don't print error messages here. */
154036ac495dSmrg }
1541