xref: /netbsd-src/external/gpl3/gcc.old/dist/intl/plural.c (revision 8feb0f0b7eaff0608f8350bbfa3098827b4bb91b)
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