intl/plural.c

   1 /* A Bison parser, made from plural.y
   2    by GNU bison 1.35.  */
   3
   4 #define YYBISON 1  /* Identify Bison output.  */
   5
   6 #define yyparse __gettextparse
   7 #define yylex __gettextlex
   8 #define yyerror __gettexterror
   9 #define yylval __gettextlval
  10 #define yychar __gettextchar
  11 #define yydebug __gettextdebug
  12 #define yynerrs __gettextnerrs
  13 # define        EQUOP2  257
  14 # define        CMPOP2  258
  15 # define        ADDOP2  259
  16 # define        MULOP2  260
  17 # define        NUMBER  261
  18
  19 #line 1 "plural.y"
  20
  21 /* Expression parsing for plural form selection.
  22    Copyright (C) 2000-2020 Free Software Foundation, Inc.
  23    Written by Ulrich Drepper <drepper@cygnus.com>, 2000.
  24
  25    This program is free software; you can redistribute it and/or modify it
  26    under the terms of the GNU Library General Public License as published
  27    by the Free Software Foundation; either version 2, or (at your option)
  28    any later version.
  29
  30    This program is distributed in the hope that it will be useful,
  31    but WITHOUT ANY WARRANTY; without even the implied warranty of
  32    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  33    Library General Public License for more details.
  34
  35    You should have received a copy of the GNU Library General Public
  36    License along with this program; if not, write to the Free Software
  37    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301,
  38    USA.  */
  39
  40 /* The bison generated parser uses alloca.  AIX 3 forces us to put this
  41    declaration at the beginning of the file.  The declaration in bison's
  42    skeleton file comes too late.  This must come before <config.h>
  43    because <config.h> may include arbitrary system headers.  */
  44 #if defined _AIX && !defined __GNUC__
  45  #pragma alloca
  46 #endif
  47
  48 #ifdef HAVE_CONFIG_H
  49 # include <config.h>
  50 #endif
  51
  52 #include <stddef.h>
  53 #include <stdlib.h>
  54 #include "plural-exp.h"
  55
  56 /* The main function generated by the parser is called __gettextparse,
  57    but we want it to be called PLURAL_PARSE.  */
  58 #ifndef _LIBC
  59 # define __gettextparse PLURAL_PARSE
  60 #endif
  61
  62 #ifndef USE_BISON3
  63 #define YYLEX_PARAM     &((struct parse_args *) arg)->cp
  64 #define YYPARSE_PARAM   arg
  65 #endif
  66
  67 #line 54 "plural.y"
  68 #ifndef YYSTYPE
  69 typedef union {
  70   unsigned long int num;
  71   enum operator op;
  72   struct expression *exp;
  73 } yystype;
  74 # define YYSTYPE yystype
  75 # define YYSTYPE_IS_TRIVIAL 1
  76 #endif
  77 #line 60 "plural.y"
  78
  79 /* Prototypes for local functions.  */
  80 static struct expression *new_exp PARAMS ((int nargs, enum operator op,
  81                                            struct expression * const *args));
  82 static inline struct expression *new_exp_0 PARAMS ((enum operator op));
  83 static inline struct expression *new_exp_1 PARAMS ((enum operator op,
  84                                                    struct expression *right));
  85 static struct expression *new_exp_2 PARAMS ((enum operator op,
  86                                              struct expression *left,
  87                                              struct expression *right));
  88 static inline struct expression *new_exp_3 PARAMS ((enum operator op,
  89                                                    struct expression *bexp,
  90                                                    struct expression *tbranch,
  91                                                    struct expression *fbranch));
  92 #ifdef USE_BISON3
  93 static int yylex PARAMS ((YYSTYPE *lval, struct parse_args *arg));
  94 static void yyerror PARAMS ((struct parse_args *arg, const char *str));
  95 #else
  96 static int yylex PARAMS ((YYSTYPE *lval, const char **pexp));
  97 static void yyerror PARAMS ((const char *str));
  98 #endif
  99
 100 /* Allocation of expressions.  */
 101
 102 static struct expression *
 103 new_exp (nargs, op, args)
 104      int nargs;
 105      enum operator op;
 106      struct expression * const *args;
 107 {
 108   int i;
 109   struct expression *newp;
 110
 111   /* If any of the argument could not be malloc'ed, just return NULL.  */
 112   for (i = nargs - 1; i >= 0; i--)
 113     if (args[i] == NULL)
 114       goto fail;
 115
 116   /* Allocate a new expression.  */
 117   newp = (struct expression *) malloc (sizeof (*newp));
 118   if (newp != NULL)
 119     {
 120       newp->nargs = nargs;
 121       newp->operation = op;
 122       for (i = nargs - 1; i >= 0; i--)
 123         newp->val.args[i] = args[i];
 124       return newp;
 125     }
 126
 127  fail:
 128   for (i = nargs - 1; i >= 0; i--)
 129     FREE_EXPRESSION (args[i]);
 130
 131   return NULL;
 132 }
 133
 134 static inline struct expression *
 135 new_exp_0 (op)
 136      enum operator op;
 137 {
 138   return new_exp (0, op, NULL);
 139 }
 140
 141 static inline struct expression *
 142 new_exp_1 (op, right)
 143      enum operator op;
 144      struct expression *right;
 145 {
 146   struct expression *args[1];
 147
 148   args[0] = right;
 149   return new_exp (1, op, args);
 150 }
 151
 152 static struct expression *
 153 new_exp_2 (op, left, right)
 154      enum operator op;
 155      struct expression *left;
 156      struct expression *right;
 157 {
 158   struct expression *args[2];
 159
 160   args[0] = left;
 161   args[1] = right;
 162   return new_exp (2, op, args);
 163 }
 164
 165 static inline struct expression *
 166 new_exp_3 (op, bexp, tbranch, fbranch)
 167      enum operator op;
 168      struct expression *bexp;
 169      struct expression *tbranch;
 170      struct expression *fbranch;
 171 {
 172   struct expression *args[3];
 173
 174   args[0] = bexp;
 175   args[1] = tbranch;
 176   args[2] = fbranch;
 177   return new_exp (3, op, args);
 178 }
 179
 180 #ifndef YYDEBUG
 181 # define YYDEBUG 0
 182 #endif
 183
 184
 185
 186 #define YYFINAL         27
 187 #define YYFLAG          -32768
 188 #define YYNTBASE        16
 189
 190 /* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */
 191 #define YYTRANSLATE(x) ((unsigned)(x) <= 261 ? yytranslate[x] : 18)
 192
 193 /* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */
 194 static const char yytranslate[] =
 195 {
 196        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 197        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 198        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 199        2,     2,     2,    10,     2,     2,     2,     2,     5,     2,
 200       14,    15,     2,     2,     2,     2,     2,     2,     2,     2,
 201        2,     2,     2,     2,     2,     2,     2,     2,    12,     2,
 202        2,     2,     2,     3,     2,     2,     2,     2,     2,     2,
 203        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 204        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 205        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 206        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 207       13,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 208        2,     2,     2,     2,     4,     2,     2,     2,     2,     2,
 209        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 210        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 211        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 212        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 213        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 214        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 215        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 216        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 217        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 218        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 219        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 220        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 221        2,     2,     2,     2,     2,     2,     1,     6,     7,     8,
 222        9,    11
 223 };
 224
 225 #if YYDEBUG
 226 static const short yyprhs[] =
 227 {
 228        0,     0,     2,     8,    12,    16,    20,    24,    28,    32,
 229       35,    37,    39
 230 };
 231 static const short yyrhs[] =
 232 {
 233       17,     0,    17,     3,    17,    12,    17,     0,    17,     4,
 234       17,     0,    17,     5,    17,     0,    17,     6,    17,     0,
 235       17,     7,    17,     0,    17,     8,    17,     0,    17,     9,
 236       17,     0,    10,    17,     0,    13,     0,    11,     0,    14,
 237       17,    15,     0
 238 };
 239
 240 #endif
 241
 242 #if YYDEBUG
 243 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
 244 static const short yyrline[] =
 245 {
 246        0,   184,   192,   196,   200,   204,   208,   212,   216,   220,
 247      224,   228,   233
 248 };
 249 #endif
 250
 251
 252 #if (YYDEBUG) || defined YYERROR_VERBOSE
 253
 254 /* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */
 255 static const char *const yytname[] =
 256 {
 257   "$", "error", "$undefined.", "'?'", "'|'", "'&'", "EQUOP2", "CMPOP2",
 258   "ADDOP2", "MULOP2", "'!'", "NUMBER", "':'", "'n'", "'('", "')'",
 259   "start", "exp", 0
 260 };
 261 #endif
 262
 263 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
 264 static const short yyr1[] =
 265 {
 266        0,    16,    17,    17,    17,    17,    17,    17,    17,    17,
 267       17,    17,    17
 268 };
 269
 270 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
 271 static const short yyr2[] =
 272 {
 273        0,     1,     5,     3,     3,     3,     3,     3,     3,     2,
 274        1,     1,     3
 275 };
 276
 277 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
 278    doesn't specify something else to do.  Zero means the default is an
 279    error. */
 280 static const short yydefact[] =
 281 {
 282        0,     0,    11,    10,     0,     1,     9,     0,     0,     0,
 283        0,     0,     0,     0,     0,    12,     0,     3,     4,     5,
 284        6,     7,     8,     0,     2,     0,     0,     0
 285 };
 286
 287 static const short yydefgoto[] =
 288 {
 289       25,     5
 290 };
 291
 292 static const short yypact[] =
 293 {
 294       -9,    -9,-32768,-32768,    -9,    34,-32768,    11,    -9,    -9,
 295       -9,    -9,    -9,    -9,    -9,-32768,    24,    39,    43,    16,
 296       26,    -3,-32768,    -9,    34,    21,    53,-32768
 297 };
 298
 299 static const short yypgoto[] =
 300 {
 301   -32768,    -1
 302 };
 303
 304
 305 #define YYLAST          53
 306
 307
 308 static const short yytable[] =
 309 {
 310        6,     1,     2,     7,     3,     4,    14,    16,    17,    18,
 311       19,    20,    21,    22,     8,     9,    10,    11,    12,    13,
 312       14,    26,    24,    12,    13,    14,    15,     8,     9,    10,
 313       11,    12,    13,    14,    13,    14,    23,     8,     9,    10,
 314       11,    12,    13,    14,    10,    11,    12,    13,    14,    11,
 315       12,    13,    14,    27
 316 };
 317
 318 static const short yycheck[] =
 319 {
 320        1,    10,    11,     4,    13,    14,     9,     8,     9,    10,
 321       11,    12,    13,    14,     3,     4,     5,     6,     7,     8,
 322        9,     0,    23,     7,     8,     9,    15,     3,     4,     5,
 323        6,     7,     8,     9,     8,     9,    12,     3,     4,     5,
 324        6,     7,     8,     9,     5,     6,     7,     8,     9,     6,
 325        7,     8,     9,     0
 326 };
 327 #define YYPURE 1
 328
 329 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
 330 #line 3 "/usr/local/share/bison/bison.simple"
 331
 332 /* Skeleton output parser for bison,
 333
 334    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software
 335    Foundation, Inc.
 336
 337    This program is free software; you can redistribute it and/or modify
 338    it under the terms of the GNU General Public License as published by
 339    the Free Software Foundation; either version 2, or (at your option)
 340    any later version.
 341
 342    This program is distributed in the hope that it will be useful,
 343    but WITHOUT ANY WARRANTY; without even the implied warranty of
 344    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 345    GNU General Public License for more details.
 346
 347    You should have received a copy of the GNU General Public License
 348    along with this program; if not, write to the Free Software
 349    Foundation, Inc., 59 Temple Place - Suite 330,
 350    Boston, MA 02111-1307, USA.  */
 351
 352 /* As a special exception, when this file is copied by Bison into a
 353    Bison output file, you may use that output file without restriction.
 354    This special exception was added by the Free Software Foundation
 355    in version 1.24 of Bison.  */
 356
 357 /* This is the parser code that is written into each bison parser when
 358    the %semantic_parser declaration is not specified in the grammar.
 359    It was written by Richard Stallman by simplifying the hairy parser
 360    used when %semantic_parser is specified.  */
 361
 362 /* All symbols defined below should begin with yy or YY, to avoid
 363    infringing on user name space.  This should be done even for local
 364    variables, as they might otherwise be expanded by user macros.
 365    There are some unavoidable exceptions within include files to
 366    define necessary library symbols; they are noted "INFRINGES ON
 367    USER NAME SPACE" below.  */
 368
 369 #if ! defined (yyoverflow) || defined (YYERROR_VERBOSE)
 370
 371 /* The parser invokes alloca or malloc; define the necessary symbols.  */
 372
 373 # if YYSTACK_USE_ALLOCA
 374 #  define YYSTACK_ALLOC alloca
 375 # else
 376 #  ifndef YYSTACK_USE_ALLOCA
 377 #   if defined (alloca) || defined (_ALLOCA_H)
 378 #    define YYSTACK_ALLOC alloca
 379 #   else
 380 #    ifdef __GNUC__
 381 #     define YYSTACK_ALLOC __builtin_alloca
 382 #    endif
 383 #   endif
 384 #  endif
 385 # endif
 386
 387 # ifdef YYSTACK_ALLOC
 388    /* Pacify GCC's `empty if-body' warning. */
 389 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
 390 # else
 391 #  if defined (__STDC__) || defined (__cplusplus)
 392 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 393 #   define YYSIZE_T size_t
 394 #  endif
 395 #  define YYSTACK_ALLOC malloc
 396 #  define YYSTACK_FREE free
 397 # endif
 398 #endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */
 399
 400
 401 #if (! defined (yyoverflow) \
 402      && (! defined (__cplusplus) \
 403          || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 404
 405 /* A type that is properly aligned for any stack member.  */
 406 union yyalloc
 407 {
 408   short yyss;
 409   YYSTYPE yyvs;
 410 # if YYLSP_NEEDED
 411   YYLTYPE yyls;
 412 # endif
 413 };
 414
 415 /* The size of the maximum gap between one aligned stack and the next.  */
 416 # define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
 417
 418 /* The size of an array large to enough to hold all stacks, each with
 419    N elements.  */
 420 # if YYLSP_NEEDED
 421 #  define YYSTACK_BYTES(N) \
 422      ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE))      \
 423       + 2 * YYSTACK_GAP_MAX)
 424 # else
 425 #  define YYSTACK_BYTES(N) \
 426      ((N) * (sizeof (short) + sizeof (YYSTYPE))                         \
 427       + YYSTACK_GAP_MAX)
 428 # endif
 429
 430 /* Copy COUNT objects from FROM to TO.  The source and destination do
 431    not overlap.  */
 432 # ifndef YYCOPY
 433 #  if 1 < __GNUC__
 434 #   define YYCOPY(To, From, Count) \
 435       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 436 #  else
 437 #   define YYCOPY(To, From, Count)              \
 438       do                                        \
 439         {                                       \
 440           register YYSIZE_T yyi;                \
 441           for (yyi = 0; yyi < (Count); yyi++)   \
 442             (To)[yyi] = (From)[yyi];            \
 443         }                                       \
 444       while (0)
 445 #  endif
 446 # endif
 447
 448 /* Relocate STACK from its old location to the new one.  The
 449    local variables YYSIZE and YYSTACKSIZE give the old and new number of
 450    elements in the stack, and YYPTR gives the new location of the
 451    stack.  Advance YYPTR to a properly aligned location for the next
 452    stack.  */
 453 # define YYSTACK_RELOCATE(Stack)                                        \
 454     do                                                                  \
 455       {                                                                 \
 456         YYSIZE_T yynewbytes;                                            \
 457         YYCOPY (&yyptr->Stack, Stack, yysize);                          \
 458         Stack = &yyptr->Stack;                                          \
 459         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX;   \
 460         yyptr += yynewbytes / sizeof (*yyptr);                          \
 461       }                                                                 \
 462     while (0)
 463
 464 #endif
 465
 466
 467 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
 468 # define YYSIZE_T __SIZE_TYPE__
 469 #endif
 470 #if ! defined (YYSIZE_T) && defined (size_t)
 471 # define YYSIZE_T size_t
 472 #endif
 473 #if ! defined (YYSIZE_T)
 474 # if defined (__STDC__) || defined (__cplusplus)
 475 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 476 #  define YYSIZE_T size_t
 477 # endif
 478 #endif
 479 #if ! defined (YYSIZE_T)
 480 # define YYSIZE_T unsigned int
 481 #endif
 482
 483 #define yyerrok         (yyerrstatus = 0)
 484 #define yyclearin       (yychar = YYEMPTY)
 485 #define YYEMPTY         -2
 486 #define YYEOF           0
 487 #define YYACCEPT        goto yyacceptlab
 488 #define YYABORT         goto yyabortlab
 489 #define YYERROR         goto yyerrlab1
 490 /* Like YYERROR except do call yyerror.  This remains here temporarily
 491    to ease the transition to the new meaning of YYERROR, for GCC.
 492    Once GCC version 2 has supplanted version 1, this can go.  */
 493 #define YYFAIL          goto yyerrlab
 494 #define YYRECOVERING()  (!!yyerrstatus)
 495 #define YYBACKUP(Token, Value)                                  \
 496 do                                                              \
 497   if (yychar == YYEMPTY && yylen == 1)                          \
 498     {                                                           \
 499       yychar = (Token);                                         \
 500       yylval = (Value);                                         \
 501       yychar1 = YYTRANSLATE (yychar);                           \
 502       YYPOPSTACK;                                               \
 503       goto yybackup;                                            \
 504     }                                                           \
 505   else                                                          \
 506     {                                                           \
 507       yyerror ("syntax error: cannot back up");                 \
 508       YYERROR;                                                  \
 509     }                                                           \
 510 while (0)
 511
 512 #define YYTERROR        1
 513 #define YYERRCODE       256
 514
 515
 516 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
 517    are run).
 518
 519    When YYLLOC_DEFAULT is run, CURRENT is set the location of the
 520    first token.  By default, to implement support for ranges, extend
 521    its range to the last symbol.  */
 522
 523 #ifndef YYLLOC_DEFAULT
 524 # define YYLLOC_DEFAULT(Current, Rhs, N)        \
 525    Current.last_line   = Rhs[N].last_line;      \
 526    Current.last_column = Rhs[N].last_column;
 527 #endif
 528
 529
 530 /* YYLEX -- calling `yylex' with the right arguments.  */
 531
 532 #if YYPURE
 533 # if YYLSP_NEEDED
 534 #  ifdef YYLEX_PARAM
 535 #   define YYLEX                yylex (&yylval, &yylloc, YYLEX_PARAM)
 536 #  else
 537 #   define YYLEX                yylex (&yylval, &yylloc)
 538 #  endif
 539 # else /* !YYLSP_NEEDED */
 540 #  ifdef YYLEX_PARAM
 541 #   define YYLEX                yylex (&yylval, YYLEX_PARAM)
 542 #  else
 543 #   define YYLEX                yylex (&yylval)
 544 #  endif
 545 # endif /* !YYLSP_NEEDED */
 546 #else /* !YYPURE */
 547 # define YYLEX                  yylex ()
 548 #endif /* !YYPURE */
 549
 550
 551 /* Enable debugging if requested.  */
 552 #if YYDEBUG
 553
 554 # ifndef YYFPRINTF
 555 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
 556 #  define YYFPRINTF fprintf
 557 # endif
 558
 559 # define YYDPRINTF(Args)                        \
 560 do {                                            \
 561   if (yydebug)                                  \
 562     YYFPRINTF Args;                             \
 563 } while (0)
 564 /* Nonzero means print parse trace.  It is left uninitialized so that
 565    multiple parsers can coexist.  */
 566 int yydebug;
 567 #else /* !YYDEBUG */
 568 # define YYDPRINTF(Args)
 569 #endif /* !YYDEBUG */
 570
 571 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 572 #ifndef YYINITDEPTH
 573 # define YYINITDEPTH 200
 574 #endif
 575
 576 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
 577    if the built-in stack extension method is used).
 578
 579    Do not make this value too large; the results are undefined if
 580    SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
 581    evaluated with infinite-precision integer arithmetic.  */
 582
 583 #if YYMAXDEPTH == 0
 584 # undef YYMAXDEPTH
 585 #endif
 586
 587 #ifndef YYMAXDEPTH
 588 # define YYMAXDEPTH 10000
 589 #endif
 590 \f
 591 #ifdef YYERROR_VERBOSE
 592
 593 # ifndef yystrlen
 594 #  if defined (__GLIBC__) && defined (_STRING_H)
 595 #   define yystrlen strlen
 596 #  else
 597 /* Return the length of YYSTR.  */
 598 static YYSIZE_T
 599 #   if defined (__STDC__) || defined (__cplusplus)
 600 yystrlen (const char *yystr)
 601 #   else
 602 yystrlen (yystr)
 603      const char *yystr;
 604 #   endif
 605 {
 606   register const char *yys = yystr;
 607
 608   while (*yys++ != '\0')
 609     continue;
 610
 611   return yys - yystr - 1;
 612 }
 613 #  endif
 614 # endif
 615
 616 # ifndef yystpcpy
 617 #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
 618 #   define yystpcpy stpcpy
 619 #  else
 620 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
 621    YYDEST.  */
 622 static char *
 623 #   if defined (__STDC__) || defined (__cplusplus)
 624 yystpcpy (char *yydest, const char *yysrc)
 625 #   else
 626 yystpcpy (yydest, yysrc)
 627      char *yydest;
 628      const char *yysrc;
 629 #   endif
 630 {
 631   register char *yyd = yydest;
 632   register const char *yys = yysrc;
 633
 634   while ((*yyd++ = *yys++) != '\0')
 635     continue;
 636
 637   return yyd - 1;
 638 }
 639 #  endif
 640 # endif
 641 #endif
 642 \f
 643 #line 315 "/usr/local/share/bison/bison.simple"
 644
 645
 646 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
 647    into yyparse.  The argument should have type void *.
 648    It should actually point to an object.
 649    Grammar actions can access the variable by casting it
 650    to the proper pointer type.  */
 651
 652 #ifdef YYPARSE_PARAM
 653 # if defined (__STDC__) || defined (__cplusplus)
 654 #  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
 655 #  define YYPARSE_PARAM_DECL
 656 # else
 657 #  define YYPARSE_PARAM_ARG YYPARSE_PARAM
 658 #  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
 659 # endif
 660 #else /* !YYPARSE_PARAM */
 661 # define YYPARSE_PARAM_ARG
 662 # define YYPARSE_PARAM_DECL
 663 #endif /* !YYPARSE_PARAM */
 664
 665 /* Prevent warning if -Wstrict-prototypes.  */
 666 #ifdef __GNUC__
 667 # ifdef YYPARSE_PARAM
 668 int yyparse (void *);
 669 # else
 670 int yyparse (void);
 671 # endif
 672 #endif
 673
 674 /* YY_DECL_VARIABLES -- depending whether we use a pure parser,
 675    variables are global, or local to YYPARSE.  */
 676
 677 #define YY_DECL_NON_LSP_VARIABLES                       \
 678 /* The lookahead symbol.  */                            \
 679 int yychar;                                             \
 680                                                         \
 681 /* The semantic value of the lookahead symbol. */       \
 682 YYSTYPE yylval;                                         \
 683                                                         \
 684 /* Number of parse errors so far.  */                   \
 685 int yynerrs;
 686
 687 #if YYLSP_NEEDED
 688 # define YY_DECL_VARIABLES                      \
 689 YY_DECL_NON_LSP_VARIABLES                       \
 690                                                 \
 691 /* Location data for the lookahead symbol.  */  \
 692 YYLTYPE yylloc;
 693 #else
 694 # define YY_DECL_VARIABLES                      \
 695 YY_DECL_NON_LSP_VARIABLES
 696 #endif
 697
 698
 699 /* If nonreentrant, generate the variables here. */
 700
 701 #if !YYPURE
 702 YY_DECL_VARIABLES
 703 #endif  /* !YYPURE */
 704
 705 int
 706 yyparse (YYPARSE_PARAM_ARG)
 707      YYPARSE_PARAM_DECL
 708 {
 709   /* If reentrant, generate the variables here. */
 710 #if YYPURE
 711   YY_DECL_VARIABLES
 712 #endif  /* !YYPURE */
 713
 714   register int yystate;
 715   register int yyn;
 716   int yyresult;
 717   /* Number of tokens to shift before error messages enabled.  */
 718   int yyerrstatus;
 719   /* Lookahead token as an internal (translated) token number.  */
 720   int yychar1 = 0;
 721
 722   /* Three stacks and their tools:
 723      `yyss': related to states,
 724      `yyvs': related to semantic values,
 725      `yyls': related to locations.
 726
 727      Refer to the stacks thru separate pointers, to allow yyoverflow
 728      to reallocate them elsewhere.  */
 729
 730   /* The state stack. */
 731   short yyssa[YYINITDEPTH];
 732   short *yyss = yyssa;
 733   register short *yyssp;
 734
 735   /* The semantic value stack.  */
 736   YYSTYPE yyvsa[YYINITDEPTH];
 737   YYSTYPE *yyvs = yyvsa;
 738   register YYSTYPE *yyvsp;
 739
 740 #if YYLSP_NEEDED
 741   /* The location stack.  */
 742   YYLTYPE yylsa[YYINITDEPTH];
 743   YYLTYPE *yyls = yylsa;
 744   YYLTYPE *yylsp;
 745 #endif
 746
 747 #if YYLSP_NEEDED
 748 # define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
 749 #else
 750 # define YYPOPSTACK   (yyvsp--, yyssp--)
 751 #endif
 752
 753   YYSIZE_T yystacksize = YYINITDEPTH;
 754
 755
 756   /* The variables used to return semantic value and location from the
 757      action routines.  */
 758   YYSTYPE yyval;
 759 #if YYLSP_NEEDED
 760   YYLTYPE yyloc;
 761 #endif
 762
 763   /* When reducing, the number of symbols on the RHS of the reduced
 764      rule. */
 765   int yylen;
 766
 767   YYDPRINTF ((stderr, "Starting parse\n"));
 768
 769   yystate = 0;
 770   yyerrstatus = 0;
 771   yynerrs = 0;
 772   yychar = YYEMPTY;             /* Cause a token to be read.  */
 773
 774   /* Initialize stack pointers.
 775      Waste one element of value and location stack
 776      so that they stay on the same level as the state stack.
 777      The wasted elements are never initialized.  */
 778
 779   yyssp = yyss;
 780   yyvsp = yyvs;
 781 #if YYLSP_NEEDED
 782   yylsp = yyls;
 783 #endif
 784   goto yysetstate;
 785
 786 /*------------------------------------------------------------.
 787 | yynewstate -- Push a new state, which is found in yystate.  |
 788 `------------------------------------------------------------*/
 789  yynewstate:
 790   /* In all cases, when you get here, the value and location stacks
 791      have just been pushed. so pushing a state here evens the stacks.
 792      */
 793   yyssp++;
 794
 795  yysetstate:
 796   *yyssp = yystate;
 797
 798   if (yyssp >= yyss + yystacksize - 1)
 799     {
 800       /* Get the current used size of the three stacks, in elements.  */
 801       YYSIZE_T yysize = yyssp - yyss + 1;
 802
 803 #ifdef yyoverflow
 804       {
 805         /* Give user a chance to reallocate the stack. Use copies of
 806            these so that the &'s don't force the real ones into
 807            memory.  */
 808         YYSTYPE *yyvs1 = yyvs;
 809         short *yyss1 = yyss;
 810
 811         /* Each stack pointer address is followed by the size of the
 812            data in use in that stack, in bytes.  */
 813 # if YYLSP_NEEDED
 814         YYLTYPE *yyls1 = yyls;
 815         /* This used to be a conditional around just the two extra args,
 816            but that might be undefined if yyoverflow is a macro.  */
 817         yyoverflow ("parser stack overflow",
 818                     &yyss1, yysize * sizeof (*yyssp),
 819                     &yyvs1, yysize * sizeof (*yyvsp),
 820                     &yyls1, yysize * sizeof (*yylsp),
 821                     &yystacksize);
 822         yyls = yyls1;
 823 # else
 824         yyoverflow ("parser stack overflow",
 825                     &yyss1, yysize * sizeof (*yyssp),
 826                     &yyvs1, yysize * sizeof (*yyvsp),
 827                     &yystacksize);
 828 # endif
 829         yyss = yyss1;
 830         yyvs = yyvs1;
 831       }
 832 #else /* no yyoverflow */
 833 # ifndef YYSTACK_RELOCATE
 834       goto yyoverflowlab;
 835 # else
 836       /* Extend the stack our own way.  */
 837       if (yystacksize >= YYMAXDEPTH)
 838         goto yyoverflowlab;
 839       yystacksize *= 2;
 840       if (yystacksize > YYMAXDEPTH)
 841         yystacksize = YYMAXDEPTH;
 842
 843       {
 844         short *yyss1 = yyss;
 845         union yyalloc *yyptr =
 846           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
 847         if (! yyptr)
 848           goto yyoverflowlab;
 849         YYSTACK_RELOCATE (yyss);
 850         YYSTACK_RELOCATE (yyvs);
 851 # if YYLSP_NEEDED
 852         YYSTACK_RELOCATE (yyls);
 853 # endif
 854 # undef YYSTACK_RELOCATE
 855         if (yyss1 != yyssa)
 856           YYSTACK_FREE (yyss1);
 857       }
 858 # endif
 859 #endif /* no yyoverflow */
 860
 861       yyssp = yyss + yysize - 1;
 862       yyvsp = yyvs + yysize - 1;
 863 #if YYLSP_NEEDED
 864       yylsp = yyls + yysize - 1;
 865 #endif
 866
 867       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
 868                   (unsigned long int) yystacksize));
 869
 870       if (yyssp >= yyss + yystacksize - 1)
 871         YYABORT;
 872     }
 873
 874   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
 875
 876   goto yybackup;
 877
 878
 879 /*-----------.
 880 | yybackup.  |
 881 `-----------*/
 882 yybackup:
 883
 884 /* Do appropriate processing given the current state.  */
 885 /* Read a lookahead token if we need one and don't already have one.  */
 886 /* yyresume: */
 887
 888   /* First try to decide what to do without reference to lookahead token.  */
 889
 890   yyn = yypact[yystate];
 891   if (yyn == YYFLAG)
 892     goto yydefault;
 893
 894   /* Not known => get a lookahead token if don't already have one.  */
 895
 896   /* yychar is either YYEMPTY or YYEOF
 897      or a valid token in external form.  */
 898
 899   if (yychar == YYEMPTY)
 900     {
 901       YYDPRINTF ((stderr, "Reading a token: "));
 902       yychar = YYLEX;
 903     }
 904
 905   /* Convert token to internal form (in yychar1) for indexing tables with */
 906
 907   if (yychar <= 0)              /* This means end of input. */
 908     {
 909       yychar1 = 0;
 910       yychar = YYEOF;           /* Don't call YYLEX any more */
 911
 912       YYDPRINTF ((stderr, "Now at end of input.\n"));
 913     }
 914   else
 915     {
 916       yychar1 = YYTRANSLATE (yychar);
 917
 918 #if YYDEBUG
 919      /* We have to keep this `#if YYDEBUG', since we use variables
 920         which are defined only if `YYDEBUG' is set.  */
 921       if (yydebug)
 922         {
 923           YYFPRINTF (stderr, "Next token is %d (%s",
 924                      yychar, yytname[yychar1]);
 925           /* Give the individual parser a way to print the precise
 926              meaning of a token, for further debugging info.  */
 927 # ifdef YYPRINT
 928           YYPRINT (stderr, yychar, yylval);
 929 # endif
 930           YYFPRINTF (stderr, ")\n");
 931         }
 932 #endif
 933     }
 934
 935   yyn += yychar1;
 936   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
 937     goto yydefault;
 938
 939   yyn = yytable[yyn];
 940
 941   /* yyn is what to do for this token type in this state.
 942      Negative => reduce, -yyn is rule number.
 943      Positive => shift, yyn is new state.
 944        New state is final state => don't bother to shift,
 945        just return success.
 946      0, or most negative number => error.  */
 947
 948   if (yyn < 0)
 949     {
 950       if (yyn == YYFLAG)
 951         goto yyerrlab;
 952       yyn = -yyn;
 953       goto yyreduce;
 954     }
 955   else if (yyn == 0)
 956     goto yyerrlab;
 957
 958   if (yyn == YYFINAL)
 959     YYACCEPT;
 960
 961   /* Shift the lookahead token.  */
 962   YYDPRINTF ((stderr, "Shifting token %d (%s), ",
 963               yychar, yytname[yychar1]));
 964
 965   /* Discard the token being shifted unless it is eof.  */
 966   if (yychar != YYEOF)
 967     yychar = YYEMPTY;
 968
 969   *++yyvsp = yylval;
 970 #if YYLSP_NEEDED
 971   *++yylsp = yylloc;
 972 #endif
 973
 974   /* Count tokens shifted since error; after three, turn off error
 975      status.  */
 976   if (yyerrstatus)
 977     yyerrstatus--;
 978
 979   yystate = yyn;
 980   goto yynewstate;
 981
 982
 983 /*-----------------------------------------------------------.
 984 | yydefault -- do the default action for the current state.  |
 985 `-----------------------------------------------------------*/
 986 yydefault:
 987   yyn = yydefact[yystate];
 988   if (yyn == 0)
 989     goto yyerrlab;
 990   goto yyreduce;
 991
 992
 993 /*-----------------------------.
 994 | yyreduce -- Do a reduction.  |
 995 `-----------------------------*/
 996 yyreduce:
 997   /* yyn is the number of a rule to reduce with.  */
 998   yylen = yyr2[yyn];
 999
1000   /* If YYLEN is nonzero, implement the default value of the action:
1001      `$$ = $1'.
1002
1003      Otherwise, the following line sets YYVAL to the semantic value of
1004      the lookahead token.  This behavior is undocumented and Bison
1005      users should not rely upon it.  Assigning to YYVAL
1006      unconditionally makes the parser a bit smaller, and it avoids a
1007      GCC warning that YYVAL may be used uninitialized.  */
1008   yyval = yyvsp[1-yylen];
1009
1010 #if YYLSP_NEEDED
1011   /* Similarly for the default location.  Let the user run additional
1012      commands if for instance locations are ranges.  */
1013   yyloc = yylsp[1-yylen];
1014   YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
1015 #endif
1016
1017 #if YYDEBUG
1018   /* We have to keep this `#if YYDEBUG', since we use variables which
1019      are defined only if `YYDEBUG' is set.  */
1020   if (yydebug)
1021     {
1022       int yyi;
1023
1024       YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
1025                  yyn, yyrline[yyn]);
1026
1027       /* Print the symbols being reduced, and their result.  */
1028       for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)
1029         YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
1030       YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
1031     }
1032 #endif
1033
1034   switch (yyn) {
1035
1036 case 1:
1037 #line 185 "plural.y"
1038 {
1039             if (yyvsp[0].exp == NULL)
1040               YYABORT;
1041             ((struct parse_args *) arg)->res = yyvsp[0].exp;
1042           }
1043     break;
1044 case 2:
1045 #line 193 "plural.y"
1046 {
1047             yyval.exp = new_exp_3 (qmop, yyvsp[-4].exp, yyvsp[-2].exp, yyvsp[0].exp);
1048           }
1049     break;
1050 case 3:
1051 #line 197 "plural.y"
1052 {
1053             yyval.exp = new_exp_2 (lor, yyvsp[-2].exp, yyvsp[0].exp);
1054           }
1055     break;
1056 case 4:
1057 #line 201 "plural.y"
1058 {
1059             yyval.exp = new_exp_2 (land, yyvsp[-2].exp, yyvsp[0].exp);
1060           }
1061     break;
1062 case 5:
1063 #line 205 "plural.y"
1064 {
1065             yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
1066           }
1067     break;
1068 case 6:
1069 #line 209 "plural.y"
1070 {
1071             yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
1072           }
1073     break;
1074 case 7:
1075 #line 213 "plural.y"
1076 {
1077             yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
1078           }
1079     break;
1080 case 8:
1081 #line 217 "plural.y"
1082 {
1083             yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
1084           }
1085     break;
1086 case 9:
1087 #line 221 "plural.y"
1088 {
1089             yyval.exp = new_exp_1 (lnot, yyvsp[0].exp);
1090           }
1091     break;
1092 case 10:
1093 #line 225 "plural.y"
1094 {
1095             yyval.exp = new_exp_0 (var);
1096           }
1097     break;
1098 case 11:
1099 #line 229 "plural.y"
1100 {
1101             if ((yyval.exp = new_exp_0 (num)) != NULL)
1102               yyval.exp->val.num = yyvsp[0].num;
1103           }
1104     break;
1105 case 12:
1106 #line 234 "plural.y"
1107 {
1108             yyval.exp = yyvsp[-1].exp;
1109           }
1110     break;
1111 }
1112
1113 #line 705 "/usr/local/share/bison/bison.simple"
1114
1115 \f
1116   yyvsp -= yylen;
1117   yyssp -= yylen;
1118 #if YYLSP_NEEDED
1119   yylsp -= yylen;
1120 #endif
1121
1122 #if YYDEBUG
1123   if (yydebug)
1124     {
1125       short *yyssp1 = yyss - 1;
1126       YYFPRINTF (stderr, "state stack now");
1127       while (yyssp1 != yyssp)
1128         YYFPRINTF (stderr, " %d", *++yyssp1);
1129       YYFPRINTF (stderr, "\n");
1130     }
1131 #endif
1132
1133   *++yyvsp = yyval;
1134 #if YYLSP_NEEDED
1135   *++yylsp = yyloc;
1136 #endif
1137
1138   /* Now `shift' the result of the reduction.  Determine what state
1139      that goes to, based on the state we popped back to and the rule
1140      number reduced by.  */
1141
1142   yyn = yyr1[yyn];
1143
1144   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
1145   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1146     yystate = yytable[yystate];
1147   else
1148     yystate = yydefgoto[yyn - YYNTBASE];
1149
1150   goto yynewstate;
1151
1152
1153 /*------------------------------------.
1154 | yyerrlab -- here on detecting error |
1155 `------------------------------------*/
1156 yyerrlab:
1157   /* If not already recovering from an error, report this error.  */
1158   if (!yyerrstatus)
1159     {
1160       ++yynerrs;
1161
1162 #ifdef YYERROR_VERBOSE
1163       yyn = yypact[yystate];
1164
1165       if (yyn > YYFLAG && yyn < YYLAST)
1166         {
1167           YYSIZE_T yysize = 0;
1168           char *yymsg;
1169           int yyx, yycount;
1170
1171           yycount = 0;
1172           /* Start YYX at -YYN if negative to avoid negative indexes in
1173              YYCHECK.  */
1174           for (yyx = yyn < 0 ? -yyn : 0;
1175                yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
1176             if (yycheck[yyx + yyn] == yyx)
1177               yysize += yystrlen (yytname[yyx]) + 15, yycount++;
1178           yysize += yystrlen ("parse error, unexpected ") + 1;
1179           yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);
1180           yymsg = (char *) YYSTACK_ALLOC (yysize);
1181           if (yymsg != 0)
1182             {
1183               char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
1184               yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);
1185
1186               if (yycount < 5)
1187                 {
1188                   yycount = 0;
1189                   for (yyx = yyn < 0 ? -yyn : 0;
1190                        yyx < (int) (sizeof (yytname) / sizeof (char *));
1191                        yyx++)
1192                     if (yycheck[yyx + yyn] == yyx)
1193                       {
1194                         const char *yyq = ! yycount ? ", expecting " : " or ";
1195                         yyp = yystpcpy (yyp, yyq);
1196                         yyp = yystpcpy (yyp, yytname[yyx]);
1197                         yycount++;
1198                       }
1199                 }
1200               yyerror (yymsg);
1201               YYSTACK_FREE (yymsg);
1202             }
1203           else
1204             yyerror ("parse error; also virtual memory exhausted");
1205         }
1206       else
1207 #endif /* defined (YYERROR_VERBOSE) */
1208         yyerror ("parse error");
1209     }
1210   goto yyerrlab1;
1211
1212
1213 /*--------------------------------------------------.
1214 | yyerrlab1 -- error raised explicitly by an action |
1215 `--------------------------------------------------*/
1216 yyerrlab1:
1217   if (yyerrstatus == 3)
1218     {
1219       /* If just tried and failed to reuse lookahead token after an
1220          error, discard it.  */
1221
1222       /* return failure if at end of input */
1223       if (yychar == YYEOF)
1224         YYABORT;
1225       YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
1226                   yychar, yytname[yychar1]));
1227       yychar = YYEMPTY;
1228     }
1229
1230   /* Else will try to reuse lookahead token after shifting the error
1231      token.  */
1232
1233   yyerrstatus = 3;              /* Each real token shifted decrements this */
1234
1235   goto yyerrhandle;
1236
1237
1238 /*-------------------------------------------------------------------.
1239 | yyerrdefault -- current state does not do anything special for the |
1240 | error token.                                                       |
1241 `-------------------------------------------------------------------*/
1242 yyerrdefault:
1243 #if 0
1244   /* This is wrong; only states that explicitly want error tokens
1245      should shift them.  */
1246
1247   /* If its default is to accept any token, ok.  Otherwise pop it.  */
1248   yyn = yydefact[yystate];
1249   if (yyn)
1250     goto yydefault;
1251 #endif
1252
1253
1254 /*---------------------------------------------------------------.
1255 | yyerrpop -- pop the current state because it cannot handle the |
1256 | error token                                                    |
1257 `---------------------------------------------------------------*/
1258 yyerrpop:
1259   if (yyssp == yyss)
1260     YYABORT;
1261   yyvsp--;
1262   yystate = *--yyssp;
1263 #if YYLSP_NEEDED
1264   yylsp--;
1265 #endif
1266
1267 #if YYDEBUG
1268   if (yydebug)
1269     {
1270       short *yyssp1 = yyss - 1;
1271       YYFPRINTF (stderr, "Error: state stack now");
1272       while (yyssp1 != yyssp)
1273         YYFPRINTF (stderr, " %d", *++yyssp1);
1274       YYFPRINTF (stderr, "\n");
1275     }
1276 #endif
1277
1278 /*--------------.
1279 | yyerrhandle.  |
1280 `--------------*/
1281 yyerrhandle:
1282   yyn = yypact[yystate];
1283   if (yyn == YYFLAG)
1284     goto yyerrdefault;
1285
1286   yyn += YYTERROR;
1287   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
1288     goto yyerrdefault;
1289
1290   yyn = yytable[yyn];
1291   if (yyn < 0)
1292     {
1293       if (yyn == YYFLAG)
1294         goto yyerrpop;
1295       yyn = -yyn;
1296       goto yyreduce;
1297     }
1298   else if (yyn == 0)
1299     goto yyerrpop;
1300
1301   if (yyn == YYFINAL)
1302     YYACCEPT;
1303
1304   YYDPRINTF ((stderr, "Shifting error token, "));
1305
1306   *++yyvsp = yylval;
1307 #if YYLSP_NEEDED
1308   *++yylsp = yylloc;
1309 #endif
1310
1311   yystate = yyn;
1312   goto yynewstate;
1313
1314
1315 /*-------------------------------------.
1316 | yyacceptlab -- YYACCEPT comes here.  |
1317 `-------------------------------------*/
1318 yyacceptlab:
1319   yyresult = 0;
1320   goto yyreturn;
1321
1322 /*-----------------------------------.
1323 | yyabortlab -- YYABORT comes here.  |
1324 `-----------------------------------*/
1325 yyabortlab:
1326   yyresult = 1;
1327   goto yyreturn;
1328
1329 /*---------------------------------------------.
1330 | yyoverflowab -- parser overflow comes here.  |
1331 `---------------------------------------------*/
1332 yyoverflowlab:
1333   yyerror ("parser stack overflow");
1334   yyresult = 2;
1335   /* Fall through.  */
1336
1337 yyreturn:
1338 #ifndef yyoverflow
1339   if (yyss != yyssa)
1340     YYSTACK_FREE (yyss);
1341 #endif
1342   return yyresult;
1343 }
1344 #line 239 "plural.y"
1345
1346
1347 void
1348 internal_function
1349 FREE_EXPRESSION (exp)
1350      struct expression *exp;
1351 {
1352   if (exp == NULL)
1353     return;
1354
1355   /* Handle the recursive case.  */
1356   switch (exp->nargs)
1357     {
1358     case 3:
1359       FREE_EXPRESSION (exp->val.args[2]);
1360       /* FALLTHROUGH */
1361     case 2:
1362       FREE_EXPRESSION (exp->val.args[1]);
1363       /* FALLTHROUGH */
1364     case 1:
1365       FREE_EXPRESSION (exp->val.args[0]);
1366       /* FALLTHROUGH */
1367     default:
1368       break;
1369     }
1370
1371   free (exp);
1372 }
1373
1374
1375 #ifdef USE_BISON3
1376 static int
1377 yylex (lval, arg)
1378      YYSTYPE *lval;
1379      struct parse_args *arg;
1380 {
1381   const char **pexp = &arg->cp;
1382 #else
1383 static int
1384 yylex (lval, pexp)
1385      YYSTYPE *lval;
1386      const char **pexp;
1387 {
1388 #endif
1389   const char *exp = *pexp;
1390   int result;
1391
1392   while (1)
1393     {
1394       if (exp[0] == '\0')
1395         {
1396           *pexp = exp;
1397           return YYEOF;
1398         }
1399
1400       if (exp[0] != ' ' && exp[0] != '\t')
1401         break;
1402
1403       ++exp;
1404     }
1405
1406   result = *exp++;
1407   switch (result)
1408     {
1409     case '0': case '1': case '2': case '3': case '4':
1410     case '5': case '6': case '7': case '8': case '9':
1411       {
1412         unsigned long int n = result - '0';
1413         while (exp[0] >= '0' && exp[0] <= '9')
1414           {
1415             n *= 10;
1416             n += exp[0] - '0';
1417             ++exp;
1418           }
1419         lval->num = n;
1420         result = NUMBER;
1421       }
1422       break;
1423
1424     case '=':
1425       if (exp[0] == '=')
1426         {
1427           ++exp;
1428           lval->op = equal;
1429           result = EQUOP2;
1430         }
1431       else
1432         result = YYERRCODE;
1433       break;
1434
1435     case '!':
1436       if (exp[0] == '=')
1437         {
1438           ++exp;
1439           lval->op = not_equal;
1440           result = EQUOP2;
1441         }
1442       break;
1443
1444     case '&':
1445     case '|':
1446       if (exp[0] == result)
1447         ++exp;
1448       else
1449         result = YYERRCODE;
1450       break;
1451
1452     case '<':
1453       if (exp[0] == '=')
1454         {
1455           ++exp;
1456           lval->op = less_or_equal;
1457         }
1458       else
1459         lval->op = less_than;
1460       result = CMPOP2;
1461       break;
1462
1463     case '>':
1464       if (exp[0] == '=')
1465         {
1466           ++exp;
1467           lval->op = greater_or_equal;
1468         }
1469       else
1470         lval->op = greater_than;
1471       result = CMPOP2;
1472       break;
1473
1474     case '*':
1475       lval->op = mult;
1476       result = MULOP2;
1477       break;
1478
1479     case '/':
1480       lval->op = divide;
1481       result = MULOP2;
1482       break;
1483
1484     case '%':
1485       lval->op = module;
1486       result = MULOP2;
1487       break;
1488
1489     case '+':
1490       lval->op = plus;
1491       result = ADDOP2;
1492       break;
1493
1494     case '-':
1495       lval->op = minus;
1496       result = ADDOP2;
1497       break;
1498
1499     case 'n':
1500     case '?':
1501     case ':':
1502     case '(':
1503     case ')':
1504       /* Nothing, just return the character.  */
1505       break;
1506
1507     case ';':
1508     case '\n':
1509     case '\0':
1510       /* Be safe and let the user call this function again.  */
1511       --exp;
1512       result = YYEOF;
1513       break;
1514
1515     default:
1516       result = YYERRCODE;
1517 #if YYDEBUG != 0
1518       --exp;
1519 #endif
1520       break;
1521     }
1522
1523   *pexp = exp;
1524
1525   return result;
1526 }
1527
1528
1529 #ifdef USE_BISON3
1530 static void
1531 yyerror (arg, str)
1532      struct parse_args *arg;
1533 #else
1534 static void
1535 yyerror (str)
1536 #endif
1537      const char *str;
1538 {
1539   /* Do nothing.  We don't print error messages here.  */
1540 }