intl/plural.c

   1
   2 /*  A Bison parser, made from plural.y
   3     by GNU Bison version 1.28  */
   4
   5 #define YYBISON 1  /* Identify Bison output.  */
   6
   7 #define yyparse __gettextparse
   8 #define yylex __gettextlex
   9 #define yyerror __gettexterror
  10 #define yylval __gettextlval
  11 #define yychar __gettextchar
  12 #define yydebug __gettextdebug
  13 #define yynerrs __gettextnerrs
  14 #define EQUOP2  257
  15 #define CMPOP2  258
  16 #define ADDOP2  259
  17 #define MULOP2  260
  18 #define NUMBER  261
  19
  20 #line 1 "plural.y"
  21
  22 /* Expression parsing for plural form selection.
  23    Copyright (C) 2000, 2001 Free Software Foundation, Inc.
  24    Written by Ulrich Drepper <drepper@cygnus.com>, 2000.
  25
  26    This program is free software; you can redistribute it and/or modify it
  27    under the terms of the GNU Library General Public License as published
  28    by the Free Software Foundation; either version 2, or (at your option)
  29    any later version.
  30
  31    This program is distributed in the hope that it will be useful,
  32    but WITHOUT ANY WARRANTY; without even the implied warranty of
  33    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  34    Library General Public License for more details.
  35
  36    You should have received a copy of the GNU Library General Public
  37    License along with this program; if not, write to the Free Software
  38    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  39    USA.  */
  40
  41 /* The bison generated parser uses alloca.  AIX 3 forces us to put this
  42    declaration at the beginning of the file.  The declaration in bison's
  43    skeleton file comes too late.  This must come before <config.h>
  44    because <config.h> may include arbitrary system headers.  */
  45 #if defined _AIX && !defined __GNUC__
  46  #pragma alloca
  47 #endif
  48
  49 #ifdef HAVE_CONFIG_H
  50 # include <config.h>
  51 #endif
  52
  53 #include <stddef.h>
  54 #include <stdlib.h>
  55 #include "plural-exp.h"
  56
  57 /* The main function generated by the parser is called __gettextparse,
  58    but we want it to be called PLURAL_PARSE.  */
  59 #ifndef _LIBC
  60 # define __gettextparse PLURAL_PARSE
  61 #endif
  62
  63 #define YYLEX_PARAM     &((struct parse_args *) arg)->cp
  64 #define YYPARSE_PARAM   arg
  65
  66 #line 49 "plural.y"
  67 typedef union {
  68   unsigned long int num;
  69   enum operator op;
  70   struct expression *exp;
  71 } YYSTYPE;
  72 #line 55 "plural.y"
  73
  74 /* Prototypes for local functions.  */
  75 static struct expression *new_exp PARAMS ((int nargs, enum operator op,
  76                                            struct expression * const *args));
  77 static inline struct expression *new_exp_0 PARAMS ((enum operator op));
  78 static inline struct expression *new_exp_1 PARAMS ((enum operator op,
  79                                                    struct expression *right));
  80 static struct expression *new_exp_2 PARAMS ((enum operator op,
  81                                              struct expression *left,
  82                                              struct expression *right));
  83 static inline struct expression *new_exp_3 PARAMS ((enum operator op,
  84                                                    struct expression *bexp,
  85                                                    struct expression *tbranch,
  86                                                    struct expression *fbranch));
  87 static int yylex PARAMS ((YYSTYPE *lval, const char **pexp));
  88 static void yyerror PARAMS ((const char *str));
  89
  90 /* Allocation of expressions.  */
  91
  92 static struct expression *
  93 new_exp (nargs, op, args)
  94      int nargs;
  95      enum operator op;
  96      struct expression * const *args;
  97 {
  98   int i;
  99   struct expression *newp;
 100
 101   /* If any of the argument could not be malloc'ed, just return NULL.  */
 102   for (i = nargs - 1; i >= 0; i--)
 103     if (args[i] == NULL)
 104       goto fail;
 105
 106   /* Allocate a new expression.  */
 107   newp = (struct expression *) malloc (sizeof (*newp));
 108   if (newp != NULL)
 109     {
 110       newp->nargs = nargs;
 111       newp->operation = op;
 112       for (i = nargs - 1; i >= 0; i--)
 113         newp->val.args[i] = args[i];
 114       return newp;
 115     }
 116
 117  fail:
 118   for (i = nargs - 1; i >= 0; i--)
 119     FREE_EXPRESSION (args[i]);
 120
 121   return NULL;
 122 }
 123
 124 static inline struct expression *
 125 new_exp_0 (op)
 126      enum operator op;
 127 {
 128   return new_exp (0, op, NULL);
 129 }
 130
 131 static inline struct expression *
 132 new_exp_1 (op, right)
 133      enum operator op;
 134      struct expression *right;
 135 {
 136   struct expression *args[1];
 137
 138   args[0] = right;
 139   return new_exp (1, op, args);
 140 }
 141
 142 static struct expression *
 143 new_exp_2 (op, left, right)
 144      enum operator op;
 145      struct expression *left;
 146      struct expression *right;
 147 {
 148   struct expression *args[2];
 149
 150   args[0] = left;
 151   args[1] = right;
 152   return new_exp (2, op, args);
 153 }
 154
 155 static inline struct expression *
 156 new_exp_3 (op, bexp, tbranch, fbranch)
 157      enum operator op;
 158      struct expression *bexp;
 159      struct expression *tbranch;
 160      struct expression *fbranch;
 161 {
 162   struct expression *args[3];
 163
 164   args[0] = bexp;
 165   args[1] = tbranch;
 166   args[2] = fbranch;
 167   return new_exp (3, op, args);
 168 }
 169
 170 #include <stdio.h>
 171
 172 #ifndef __cplusplus
 173 #ifndef __STDC__
 174 #define const
 175 #endif
 176 #endif
 177
 178
 179
 180 #define YYFINAL         27
 181 #define YYFLAG          -32768
 182 #define YYNTBASE        16
 183
 184 #define YYTRANSLATE(x) ((unsigned)(x) <= 261 ? yytranslate[x] : 18)
 185
 186 static const char yytranslate[] = {     0,
 187      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 188      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 189      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 190      2,     2,    10,     2,     2,     2,     2,     5,     2,    14,
 191     15,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 192      2,     2,     2,     2,     2,     2,     2,    12,     2,     2,
 193      2,     2,     3,     2,     2,     2,     2,     2,     2,     2,
 194      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 195      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 196      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 197      2,     2,     2,     2,     2,     2,     2,     2,     2,    13,
 198      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 199      2,     2,     2,     4,     2,     2,     2,     2,     2,     2,
 200      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 201      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 202      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 203      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 204      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 205      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 206      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 207      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 208      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 209      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 210      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 211      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 212      2,     2,     2,     2,     2,     1,     6,     7,     8,     9,
 213     11
 214 };
 215
 216 #if YYDEBUG != 0
 217 static const short yyprhs[] = {     0,
 218      0,     2,     8,    12,    16,    20,    24,    28,    32,    35,
 219     37,    39
 220 };
 221
 222 static const short yyrhs[] = {    17,
 223      0,    17,     3,    17,    12,    17,     0,    17,     4,    17,
 224      0,    17,     5,    17,     0,    17,     6,    17,     0,    17,
 225      7,    17,     0,    17,     8,    17,     0,    17,     9,    17,
 226      0,    10,    17,     0,    13,     0,    11,     0,    14,    17,
 227     15,     0
 228 };
 229
 230 #endif
 231
 232 #if YYDEBUG != 0
 233 static const short yyrline[] = { 0,
 234    174,   182,   186,   190,   194,   198,   202,   206,   210,   214,
 235    218,   223
 236 };
 237 #endif
 238
 239
 240 #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
 241
 242 static const char * const yytname[] = {   "$","error","$undefined.","'?'","'|'",
 243 "'&'","EQUOP2","CMPOP2","ADDOP2","MULOP2","'!'","NUMBER","':'","'n'","'('","')'",
 244 "start","exp", NULL
 245 };
 246 #endif
 247
 248 static const short yyr1[] = {     0,
 249     16,    17,    17,    17,    17,    17,    17,    17,    17,    17,
 250     17,    17
 251 };
 252
 253 static const short yyr2[] = {     0,
 254      1,     5,     3,     3,     3,     3,     3,     3,     2,     1,
 255      1,     3
 256 };
 257
 258 static const short yydefact[] = {     0,
 259      0,    11,    10,     0,     1,     9,     0,     0,     0,     0,
 260      0,     0,     0,     0,    12,     0,     3,     4,     5,     6,
 261      7,     8,     0,     2,     0,     0,     0
 262 };
 263
 264 static const short yydefgoto[] = {    25,
 265      5
 266 };
 267
 268 static const short yypact[] = {    -9,
 269     -9,-32768,-32768,    -9,    34,-32768,    11,    -9,    -9,    -9,
 270     -9,    -9,    -9,    -9,-32768,    24,    39,    43,    16,    26,
 271     -3,-32768,    -9,    34,    21,    53,-32768
 272 };
 273
 274 static const short yypgoto[] = {-32768,
 275     -1
 276 };
 277
 278
 279 #define YYLAST          53
 280
 281
 282 static const short yytable[] = {     6,
 283      1,     2,     7,     3,     4,    14,    16,    17,    18,    19,
 284     20,    21,    22,     8,     9,    10,    11,    12,    13,    14,
 285     26,    24,    12,    13,    14,    15,     8,     9,    10,    11,
 286     12,    13,    14,    13,    14,    23,     8,     9,    10,    11,
 287     12,    13,    14,    10,    11,    12,    13,    14,    11,    12,
 288     13,    14,    27
 289 };
 290
 291 static const short yycheck[] = {     1,
 292     10,    11,     4,    13,    14,     9,     8,     9,    10,    11,
 293     12,    13,    14,     3,     4,     5,     6,     7,     8,     9,
 294      0,    23,     7,     8,     9,    15,     3,     4,     5,     6,
 295      7,     8,     9,     8,     9,    12,     3,     4,     5,     6,
 296      7,     8,     9,     5,     6,     7,     8,     9,     6,     7,
 297      8,     9,     0
 298 };
 299 #define YYPURE 1
 300
 301 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
 302 #line 3 "/usr/local/share/bison.simple"
 303 /* This file comes from bison-1.28.  */
 304
 305 /* Skeleton output parser for bison,
 306    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
 307
 308    This program is free software; you can redistribute it and/or modify
 309    it under the terms of the GNU General Public License as published by
 310    the Free Software Foundation; either version 2, or (at your option)
 311    any later version.
 312
 313    This program is distributed in the hope that it will be useful,
 314    but WITHOUT ANY WARRANTY; without even the implied warranty of
 315    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 316    GNU General Public License for more details.
 317
 318    You should have received a copy of the GNU General Public License
 319    along with this program; if not, write to the Free Software
 320    Foundation, Inc., 59 Temple Place - Suite 330,
 321    Boston, MA 02111-1307, USA.  */
 322
 323 /* As a special exception, when this file is copied by Bison into a
 324    Bison output file, you may use that output file without restriction.
 325    This special exception was added by the Free Software Foundation
 326    in version 1.24 of Bison.  */
 327
 328 /* This is the parser code that is written into each bison parser
 329   when the %semantic_parser declaration is not specified in the grammar.
 330   It was written by Richard Stallman by simplifying the hairy parser
 331   used when %semantic_parser is specified.  */
 332
 333 #ifndef YYSTACK_USE_ALLOCA
 334 #ifdef alloca
 335 #define YYSTACK_USE_ALLOCA
 336 #else /* alloca not defined */
 337 #ifdef __GNUC__
 338 #define YYSTACK_USE_ALLOCA
 339 #define alloca __builtin_alloca
 340 #else /* not GNU C.  */
 341 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
 342 #define YYSTACK_USE_ALLOCA
 343 #include <alloca.h>
 344 #else /* not sparc */
 345 /* We think this test detects Watcom and Microsoft C.  */
 346 /* This used to test MSDOS, but that is a bad idea
 347    since that symbol is in the user namespace.  */
 348 #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
 349 #if 0 /* No need for malloc.h, which pollutes the namespace;
 350          instead, just don't use alloca.  */
 351 #include <malloc.h>
 352 #endif
 353 #else /* not MSDOS, or __TURBOC__ */
 354 #if defined(_AIX)
 355 /* I don't know what this was needed for, but it pollutes the namespace.
 356    So I turned it off.   rms, 2 May 1997.  */
 357 /* #include <malloc.h>  */
 358  #pragma alloca
 359 #define YYSTACK_USE_ALLOCA
 360 #else /* not MSDOS, or __TURBOC__, or _AIX */
 361 #if 0
 362 #ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
 363                  and on HPUX 10.  Eventually we can turn this on.  */
 364 #define YYSTACK_USE_ALLOCA
 365 #define alloca __builtin_alloca
 366 #endif /* __hpux */
 367 #endif
 368 #endif /* not _AIX */
 369 #endif /* not MSDOS, or __TURBOC__ */
 370 #endif /* not sparc */
 371 #endif /* not GNU C */
 372 #endif /* alloca not defined */
 373 #endif /* YYSTACK_USE_ALLOCA not defined */
 374
 375 #ifdef YYSTACK_USE_ALLOCA
 376 #define YYSTACK_ALLOC alloca
 377 #else
 378 #define YYSTACK_ALLOC malloc
 379 #endif
 380
 381 /* Note: there must be only one dollar sign in this file.
 382    It is replaced by the list of actions, each action
 383    as one case of the switch.  */
 384
 385 #define yyerrok         (yyerrstatus = 0)
 386 #define yyclearin       (yychar = YYEMPTY)
 387 #define YYEMPTY         -2
 388 #define YYEOF           0
 389 #define YYACCEPT        goto yyacceptlab
 390 #define YYABORT         goto yyabortlab
 391 #define YYERROR         goto yyerrlab1
 392 /* Like YYERROR except do call yyerror.
 393    This remains here temporarily to ease the
 394    transition to the new meaning of YYERROR, for GCC.
 395    Once GCC version 2 has supplanted version 1, this can go.  */
 396 #define YYFAIL          goto yyerrlab
 397 #define YYRECOVERING()  (!!yyerrstatus)
 398 #define YYBACKUP(token, value) \
 399 do                                                              \
 400   if (yychar == YYEMPTY && yylen == 1)                          \
 401     { yychar = (token), yylval = (value);                       \
 402       yychar1 = YYTRANSLATE (yychar);                           \
 403       YYPOPSTACK;                                               \
 404       goto yybackup;                                            \
 405     }                                                           \
 406   else                                                          \
 407     { yyerror ("syntax error: cannot back up"); YYERROR; }      \
 408 while (0)
 409
 410 #define YYTERROR        1
 411 #define YYERRCODE       256
 412
 413 #ifndef YYPURE
 414 #define YYLEX           yylex()
 415 #endif
 416
 417 #ifdef YYPURE
 418 #ifdef YYLSP_NEEDED
 419 #ifdef YYLEX_PARAM
 420 #define YYLEX           yylex(&yylval, &yylloc, YYLEX_PARAM)
 421 #else
 422 #define YYLEX           yylex(&yylval, &yylloc)
 423 #endif
 424 #else /* not YYLSP_NEEDED */
 425 #ifdef YYLEX_PARAM
 426 #define YYLEX           yylex(&yylval, YYLEX_PARAM)
 427 #else
 428 #define YYLEX           yylex(&yylval)
 429 #endif
 430 #endif /* not YYLSP_NEEDED */
 431 #endif
 432
 433 /* If nonreentrant, generate the variables here */
 434
 435 #ifndef YYPURE
 436
 437 int     yychar;                 /*  the lookahead symbol                */
 438 YYSTYPE yylval;                 /*  the semantic value of the           */
 439                                 /*  lookahead symbol                    */
 440
 441 #ifdef YYLSP_NEEDED
 442 YYLTYPE yylloc;                 /*  location data for the lookahead     */
 443                                 /*  symbol                              */
 444 #endif
 445
 446 int yynerrs;                    /*  number of parse errors so far       */
 447 #endif  /* not YYPURE */
 448
 449 #if YYDEBUG != 0
 450 int yydebug;                    /*  nonzero means print parse trace     */
 451 /* Since this is uninitialized, it does not stop multiple parsers
 452    from coexisting.  */
 453 #endif
 454
 455 /*  YYINITDEPTH indicates the initial size of the parser's stacks       */
 456
 457 #ifndef YYINITDEPTH
 458 #define YYINITDEPTH 200
 459 #endif
 460
 461 /*  YYMAXDEPTH is the maximum size the stacks can grow to
 462     (effective only if the built-in stack extension method is used).  */
 463
 464 #if YYMAXDEPTH == 0
 465 #undef YYMAXDEPTH
 466 #endif
 467
 468 #ifndef YYMAXDEPTH
 469 #define YYMAXDEPTH 10000
 470 #endif
 471 \f
 472 /* Define __yy_memcpy.  Note that the size argument
 473    should be passed with type unsigned int, because that is what the non-GCC
 474    definitions require.  With GCC, __builtin_memcpy takes an arg
 475    of type size_t, but it can handle unsigned int.  */
 476
 477 #if __GNUC__ > 1                /* GNU C and GNU C++ define this.  */
 478 #define __yy_memcpy(TO,FROM,COUNT)      __builtin_memcpy(TO,FROM,COUNT)
 479 #else                           /* not GNU C or C++ */
 480 #ifndef __cplusplus
 481
 482 /* This is the most reliable way to avoid incompatibilities
 483    in available built-in functions on various systems.  */
 484 static void
 485 __yy_memcpy (to, from, count)
 486      char *to;
 487      char *from;
 488      unsigned int count;
 489 {
 490   register char *f = from;
 491   register char *t = to;
 492   register int i = count;
 493
 494   while (i-- > 0)
 495     *t++ = *f++;
 496 }
 497
 498 #else /* __cplusplus */
 499
 500 /* This is the most reliable way to avoid incompatibilities
 501    in available built-in functions on various systems.  */
 502 static void
 503 __yy_memcpy (char *to, char *from, unsigned int count)
 504 {
 505   register char *t = to;
 506   register char *f = from;
 507   register int i = count;
 508
 509   while (i-- > 0)
 510     *t++ = *f++;
 511 }
 512
 513 #endif
 514 #endif
 515 \f
 516 #line 217 "/usr/local/share/bison.simple"
 517
 518 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
 519    into yyparse.  The argument should have type void *.
 520    It should actually point to an object.
 521    Grammar actions can access the variable by casting it
 522    to the proper pointer type.  */
 523
 524 #ifdef YYPARSE_PARAM
 525 #ifdef __cplusplus
 526 #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
 527 #define YYPARSE_PARAM_DECL
 528 #else /* not __cplusplus */
 529 #define YYPARSE_PARAM_ARG YYPARSE_PARAM
 530 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
 531 #endif /* not __cplusplus */
 532 #else /* not YYPARSE_PARAM */
 533 #define YYPARSE_PARAM_ARG
 534 #define YYPARSE_PARAM_DECL
 535 #endif /* not YYPARSE_PARAM */
 536
 537 /* Prevent warning if -Wstrict-prototypes.  */
 538 #ifdef __GNUC__
 539 #ifdef YYPARSE_PARAM
 540 int yyparse (void *);
 541 #else
 542 int yyparse (void);
 543 #endif
 544 #endif
 545
 546 int
 547 yyparse(YYPARSE_PARAM_ARG)
 548      YYPARSE_PARAM_DECL
 549 {
 550   register int yystate;
 551   register int yyn;
 552   register short *yyssp;
 553   register YYSTYPE *yyvsp;
 554   int yyerrstatus;      /*  number of tokens to shift before error messages enabled */
 555   int yychar1 = 0;              /*  lookahead token as an internal (translated) token number */
 556
 557   short yyssa[YYINITDEPTH];     /*  the state stack                     */
 558   YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack            */
 559
 560   short *yyss = yyssa;          /*  refer to the stacks thru separate pointers */
 561   YYSTYPE *yyvs = yyvsa;        /*  to allow yyoverflow to reallocate them elsewhere */
 562
 563 #ifdef YYLSP_NEEDED
 564   YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack                  */
 565   YYLTYPE *yyls = yylsa;
 566   YYLTYPE *yylsp;
 567
 568 #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
 569 #else
 570 #define YYPOPSTACK   (yyvsp--, yyssp--)
 571 #endif
 572
 573   int yystacksize = YYINITDEPTH;
 574   int yyfree_stacks = 0;
 575
 576 #ifdef YYPURE
 577   int yychar;
 578   YYSTYPE yylval;
 579   int yynerrs;
 580 #ifdef YYLSP_NEEDED
 581   YYLTYPE yylloc;
 582 #endif
 583 #endif
 584
 585   YYSTYPE yyval;                /*  the variable used to return         */
 586                                 /*  semantic values from the action     */
 587                                 /*  routines                            */
 588
 589   int yylen;
 590
 591 #if YYDEBUG != 0
 592   if (yydebug)
 593     fprintf(stderr, "Starting parse\n");
 594 #endif
 595
 596   yystate = 0;
 597   yyerrstatus = 0;
 598   yynerrs = 0;
 599   yychar = YYEMPTY;             /* Cause a token to be read.  */
 600
 601   /* Initialize stack pointers.
 602      Waste one element of value and location stack
 603      so that they stay on the same level as the state stack.
 604      The wasted elements are never initialized.  */
 605
 606   yyssp = yyss - 1;
 607   yyvsp = yyvs;
 608 #ifdef YYLSP_NEEDED
 609   yylsp = yyls;
 610 #endif
 611
 612 /* Push a new state, which is found in  yystate  .  */
 613 /* In all cases, when you get here, the value and location stacks
 614    have just been pushed. so pushing a state here evens the stacks.  */
 615 yynewstate:
 616
 617   *++yyssp = yystate;
 618
 619   if (yyssp >= yyss + yystacksize - 1)
 620     {
 621       /* Give user a chance to reallocate the stack */
 622       /* Use copies of these so that the &'s don't force the real ones into memory. */
 623       YYSTYPE *yyvs1 = yyvs;
 624       short *yyss1 = yyss;
 625 #ifdef YYLSP_NEEDED
 626       YYLTYPE *yyls1 = yyls;
 627 #endif
 628
 629       /* Get the current used size of the three stacks, in elements.  */
 630       int size = yyssp - yyss + 1;
 631
 632 #ifdef yyoverflow
 633       /* Each stack pointer address is followed by the size of
 634          the data in use in that stack, in bytes.  */
 635 #ifdef YYLSP_NEEDED
 636       /* This used to be a conditional around just the two extra args,
 637          but that might be undefined if yyoverflow is a macro.  */
 638       yyoverflow("parser stack overflow",
 639                  &yyss1, size * sizeof (*yyssp),
 640                  &yyvs1, size * sizeof (*yyvsp),
 641                  &yyls1, size * sizeof (*yylsp),
 642                  &yystacksize);
 643 #else
 644       yyoverflow("parser stack overflow",
 645                  &yyss1, size * sizeof (*yyssp),
 646                  &yyvs1, size * sizeof (*yyvsp),
 647                  &yystacksize);
 648 #endif
 649
 650       yyss = yyss1; yyvs = yyvs1;
 651 #ifdef YYLSP_NEEDED
 652       yyls = yyls1;
 653 #endif
 654 #else /* no yyoverflow */
 655       /* Extend the stack our own way.  */
 656       if (yystacksize >= YYMAXDEPTH)
 657         {
 658           yyerror("parser stack overflow");
 659           if (yyfree_stacks)
 660             {
 661               free (yyss);
 662               free (yyvs);
 663 #ifdef YYLSP_NEEDED
 664               free (yyls);
 665 #endif
 666             }
 667           return 2;
 668         }
 669       yystacksize *= 2;
 670       if (yystacksize > YYMAXDEPTH)
 671         yystacksize = YYMAXDEPTH;
 672 #ifndef YYSTACK_USE_ALLOCA
 673       yyfree_stacks = 1;
 674 #endif
 675       yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
 676       __yy_memcpy ((char *)yyss, (char *)yyss1,
 677                    size * (unsigned int) sizeof (*yyssp));
 678       yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
 679       __yy_memcpy ((char *)yyvs, (char *)yyvs1,
 680                    size * (unsigned int) sizeof (*yyvsp));
 681 #ifdef YYLSP_NEEDED
 682       yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
 683       __yy_memcpy ((char *)yyls, (char *)yyls1,
 684                    size * (unsigned int) sizeof (*yylsp));
 685 #endif
 686 #endif /* no yyoverflow */
 687
 688       yyssp = yyss + size - 1;
 689       yyvsp = yyvs + size - 1;
 690 #ifdef YYLSP_NEEDED
 691       yylsp = yyls + size - 1;
 692 #endif
 693
 694 #if YYDEBUG != 0
 695       if (yydebug)
 696         fprintf(stderr, "Stack size increased to %d\n", yystacksize);
 697 #endif
 698
 699       if (yyssp >= yyss + yystacksize - 1)
 700         YYABORT;
 701     }
 702
 703 #if YYDEBUG != 0
 704   if (yydebug)
 705     fprintf(stderr, "Entering state %d\n", yystate);
 706 #endif
 707
 708   goto yybackup;
 709  yybackup:
 710
 711 /* Do appropriate processing given the current state.  */
 712 /* Read a lookahead token if we need one and don't already have one.  */
 713 /* yyresume: */
 714
 715   /* First try to decide what to do without reference to lookahead token.  */
 716
 717   yyn = yypact[yystate];
 718   if (yyn == YYFLAG)
 719     goto yydefault;
 720
 721   /* Not known => get a lookahead token if don't already have one.  */
 722
 723   /* yychar is either YYEMPTY or YYEOF
 724      or a valid token in external form.  */
 725
 726   if (yychar == YYEMPTY)
 727     {
 728 #if YYDEBUG != 0
 729       if (yydebug)
 730         fprintf(stderr, "Reading a token: ");
 731 #endif
 732       yychar = YYLEX;
 733     }
 734
 735   /* Convert token to internal form (in yychar1) for indexing tables with */
 736
 737   if (yychar <= 0)              /* This means end of input. */
 738     {
 739       yychar1 = 0;
 740       yychar = YYEOF;           /* Don't call YYLEX any more */
 741
 742 #if YYDEBUG != 0
 743       if (yydebug)
 744         fprintf(stderr, "Now at end of input.\n");
 745 #endif
 746     }
 747   else
 748     {
 749       yychar1 = YYTRANSLATE(yychar);
 750
 751 #if YYDEBUG != 0
 752       if (yydebug)
 753         {
 754           fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
 755           /* Give the individual parser a way to print the precise meaning
 756              of a token, for further debugging info.  */
 757 #ifdef YYPRINT
 758           YYPRINT (stderr, yychar, yylval);
 759 #endif
 760           fprintf (stderr, ")\n");
 761         }
 762 #endif
 763     }
 764
 765   yyn += yychar1;
 766   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
 767     goto yydefault;
 768
 769   yyn = yytable[yyn];
 770
 771   /* yyn is what to do for this token type in this state.
 772      Negative => reduce, -yyn is rule number.
 773      Positive => shift, yyn is new state.
 774        New state is final state => don't bother to shift,
 775        just return success.
 776      0, or most negative number => error.  */
 777
 778   if (yyn < 0)
 779     {
 780       if (yyn == YYFLAG)
 781         goto yyerrlab;
 782       yyn = -yyn;
 783       goto yyreduce;
 784     }
 785   else if (yyn == 0)
 786     goto yyerrlab;
 787
 788   if (yyn == YYFINAL)
 789     YYACCEPT;
 790
 791   /* Shift the lookahead token.  */
 792
 793 #if YYDEBUG != 0
 794   if (yydebug)
 795     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
 796 #endif
 797
 798   /* Discard the token being shifted unless it is eof.  */
 799   if (yychar != YYEOF)
 800     yychar = YYEMPTY;
 801
 802   *++yyvsp = yylval;
 803 #ifdef YYLSP_NEEDED
 804   *++yylsp = yylloc;
 805 #endif
 806
 807   /* count tokens shifted since error; after three, turn off error status.  */
 808   if (yyerrstatus) yyerrstatus--;
 809
 810   yystate = yyn;
 811   goto yynewstate;
 812
 813 /* Do the default action for the current state.  */
 814 yydefault:
 815
 816   yyn = yydefact[yystate];
 817   if (yyn == 0)
 818     goto yyerrlab;
 819
 820 /* Do a reduction.  yyn is the number of a rule to reduce with.  */
 821 yyreduce:
 822   yylen = yyr2[yyn];
 823   if (yylen > 0)
 824     yyval = yyvsp[1-yylen]; /* implement default value of the action */
 825
 826 #if YYDEBUG != 0
 827   if (yydebug)
 828     {
 829       int i;
 830
 831       fprintf (stderr, "Reducing via rule %d (line %d), ",
 832                yyn, yyrline[yyn]);
 833
 834       /* Print the symbols being reduced, and their result.  */
 835       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
 836         fprintf (stderr, "%s ", yytname[yyrhs[i]]);
 837       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
 838     }
 839 #endif
 840
 841
 842   switch (yyn) {
 843
 844 case 1:
 845 #line 175 "plural.y"
 846 {
 847             if (yyvsp[0].exp == NULL)
 848               YYABORT;
 849             ((struct parse_args *) arg)->res = yyvsp[0].exp;
 850           ;
 851     break;}
 852 case 2:
 853 #line 183 "plural.y"
 854 {
 855             yyval.exp = new_exp_3 (qmop, yyvsp[-4].exp, yyvsp[-2].exp, yyvsp[0].exp);
 856           ;
 857     break;}
 858 case 3:
 859 #line 187 "plural.y"
 860 {
 861             yyval.exp = new_exp_2 (lor, yyvsp[-2].exp, yyvsp[0].exp);
 862           ;
 863     break;}
 864 case 4:
 865 #line 191 "plural.y"
 866 {
 867             yyval.exp = new_exp_2 (land, yyvsp[-2].exp, yyvsp[0].exp);
 868           ;
 869     break;}
 870 case 5:
 871 #line 195 "plural.y"
 872 {
 873             yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
 874           ;
 875     break;}
 876 case 6:
 877 #line 199 "plural.y"
 878 {
 879             yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
 880           ;
 881     break;}
 882 case 7:
 883 #line 203 "plural.y"
 884 {
 885             yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
 886           ;
 887     break;}
 888 case 8:
 889 #line 207 "plural.y"
 890 {
 891             yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);
 892           ;
 893     break;}
 894 case 9:
 895 #line 211 "plural.y"
 896 {
 897             yyval.exp = new_exp_1 (lnot, yyvsp[0].exp);
 898           ;
 899     break;}
 900 case 10:
 901 #line 215 "plural.y"
 902 {
 903             yyval.exp = new_exp_0 (var);
 904           ;
 905     break;}
 906 case 11:
 907 #line 219 "plural.y"
 908 {
 909             if ((yyval.exp = new_exp_0 (num)) != NULL)
 910               yyval.exp->val.num = yyvsp[0].num;
 911           ;
 912     break;}
 913 case 12:
 914 #line 224 "plural.y"
 915 {
 916             yyval.exp = yyvsp[-1].exp;
 917           ;
 918     break;}
 919 }
 920    /* the action file gets copied in in place of this dollarsign */
 921 #line 543 "/usr/local/share/bison.simple"
 922 \f
 923   yyvsp -= yylen;
 924   yyssp -= yylen;
 925 #ifdef YYLSP_NEEDED
 926   yylsp -= yylen;
 927 #endif
 928
 929 #if YYDEBUG != 0
 930   if (yydebug)
 931     {
 932       short *ssp1 = yyss - 1;
 933       fprintf (stderr, "state stack now");
 934       while (ssp1 != yyssp)
 935         fprintf (stderr, " %d", *++ssp1);
 936       fprintf (stderr, "\n");
 937     }
 938 #endif
 939
 940   *++yyvsp = yyval;
 941
 942 #ifdef YYLSP_NEEDED
 943   yylsp++;
 944   if (yylen == 0)
 945     {
 946       yylsp->first_line = yylloc.first_line;
 947       yylsp->first_column = yylloc.first_column;
 948       yylsp->last_line = (yylsp-1)->last_line;
 949       yylsp->last_column = (yylsp-1)->last_column;
 950       yylsp->text = 0;
 951     }
 952   else
 953     {
 954       yylsp->last_line = (yylsp+yylen-1)->last_line;
 955       yylsp->last_column = (yylsp+yylen-1)->last_column;
 956     }
 957 #endif
 958
 959   /* Now "shift" the result of the reduction.
 960      Determine what state that goes to,
 961      based on the state we popped back to
 962      and the rule number reduced by.  */
 963
 964   yyn = yyr1[yyn];
 965
 966   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
 967   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
 968     yystate = yytable[yystate];
 969   else
 970     yystate = yydefgoto[yyn - YYNTBASE];
 971
 972   goto yynewstate;
 973
 974 yyerrlab:   /* here on detecting error */
 975
 976   if (! yyerrstatus)
 977     /* If not already recovering from an error, report this error.  */
 978     {
 979       ++yynerrs;
 980
 981 #ifdef YYERROR_VERBOSE
 982       yyn = yypact[yystate];
 983
 984       if (yyn > YYFLAG && yyn < YYLAST)
 985         {
 986           int size = 0;
 987           char *msg;
 988           int x, count;
 989
 990           count = 0;
 991           /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
 992           for (x = (yyn < 0 ? -yyn : 0);
 993                x < (sizeof(yytname) / sizeof(char *)); x++)
 994             if (yycheck[x + yyn] == x)
 995               size += strlen(yytname[x]) + 15, count++;
 996           msg = (char *) malloc(size + 15);
 997           if (msg != 0)
 998             {
 999               strcpy(msg, "parse error");
1000
1001               if (count < 5)
1002                 {
1003                   count = 0;
1004                   for (x = (yyn < 0 ? -yyn : 0);
1005                        x < (sizeof(yytname) / sizeof(char *)); x++)
1006                     if (yycheck[x + yyn] == x)
1007                       {
1008                         strcat(msg, count == 0 ? ", expecting `" : " or `");
1009                         strcat(msg, yytname[x]);
1010                         strcat(msg, "'");
1011                         count++;
1012                       }
1013                 }
1014               yyerror(msg);
1015               free(msg);
1016             }
1017           else
1018             yyerror ("parse error; also virtual memory exceeded");
1019         }
1020       else
1021 #endif /* YYERROR_VERBOSE */
1022         yyerror("parse error");
1023     }
1024
1025   goto yyerrlab1;
1026 yyerrlab1:   /* here on error raised explicitly by an action */
1027
1028   if (yyerrstatus == 3)
1029     {
1030       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
1031
1032       /* return failure if at end of input */
1033       if (yychar == YYEOF)
1034         YYABORT;
1035
1036 #if YYDEBUG != 0
1037       if (yydebug)
1038         fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
1039 #endif
1040
1041       yychar = YYEMPTY;
1042     }
1043
1044   /* Else will try to reuse lookahead token
1045      after shifting the error token.  */
1046
1047   yyerrstatus = 3;              /* Each real token shifted decrements this */
1048
1049   goto yyerrhandle;
1050
1051 yyerrdefault:  /* current state does not do anything special for the error token. */
1052
1053 #if 0
1054   /* This is wrong; only states that explicitly want error tokens
1055      should shift them.  */
1056   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
1057   if (yyn) goto yydefault;
1058 #endif
1059
1060 yyerrpop:   /* pop the current state because it cannot handle the error token */
1061
1062   if (yyssp == yyss) YYABORT;
1063   yyvsp--;
1064   yystate = *--yyssp;
1065 #ifdef YYLSP_NEEDED
1066   yylsp--;
1067 #endif
1068
1069 #if YYDEBUG != 0
1070   if (yydebug)
1071     {
1072       short *ssp1 = yyss - 1;
1073       fprintf (stderr, "Error: state stack now");
1074       while (ssp1 != yyssp)
1075         fprintf (stderr, " %d", *++ssp1);
1076       fprintf (stderr, "\n");
1077     }
1078 #endif
1079
1080 yyerrhandle:
1081
1082   yyn = yypact[yystate];
1083   if (yyn == YYFLAG)
1084     goto yyerrdefault;
1085
1086   yyn += YYTERROR;
1087   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
1088     goto yyerrdefault;
1089
1090   yyn = yytable[yyn];
1091   if (yyn < 0)
1092     {
1093       if (yyn == YYFLAG)
1094         goto yyerrpop;
1095       yyn = -yyn;
1096       goto yyreduce;
1097     }
1098   else if (yyn == 0)
1099     goto yyerrpop;
1100
1101   if (yyn == YYFINAL)
1102     YYACCEPT;
1103
1104 #if YYDEBUG != 0
1105   if (yydebug)
1106     fprintf(stderr, "Shifting error token, ");
1107 #endif
1108
1109   *++yyvsp = yylval;
1110 #ifdef YYLSP_NEEDED
1111   *++yylsp = yylloc;
1112 #endif
1113
1114   yystate = yyn;
1115   goto yynewstate;
1116
1117  yyacceptlab:
1118   /* YYACCEPT comes here.  */
1119   if (yyfree_stacks)
1120     {
1121       free (yyss);
1122       free (yyvs);
1123 #ifdef YYLSP_NEEDED
1124       free (yyls);
1125 #endif
1126     }
1127   return 0;
1128
1129  yyabortlab:
1130   /* YYABORT comes here.  */
1131   if (yyfree_stacks)
1132     {
1133       free (yyss);
1134       free (yyvs);
1135 #ifdef YYLSP_NEEDED
1136       free (yyls);
1137 #endif
1138     }
1139   return 1;
1140 }
1141 #line 229 "plural.y"
1142
1143
1144 void
1145 internal_function
1146 FREE_EXPRESSION (exp)
1147      struct expression *exp;
1148 {
1149   if (exp == NULL)
1150     return;
1151
1152   /* Handle the recursive case.  */
1153   switch (exp->nargs)
1154     {
1155     case 3:
1156       FREE_EXPRESSION (exp->val.args[2]);
1157       /* FALLTHROUGH */
1158     case 2:
1159       FREE_EXPRESSION (exp->val.args[1]);
1160       /* FALLTHROUGH */
1161     case 1:
1162       FREE_EXPRESSION (exp->val.args[0]);
1163       /* FALLTHROUGH */
1164     default:
1165       break;
1166     }
1167
1168   free (exp);
1169 }
1170
1171
1172 static int
1173 yylex (lval, pexp)
1174      YYSTYPE *lval;
1175      const char **pexp;
1176 {
1177   const char *exp = *pexp;
1178   int result;
1179
1180   while (1)
1181     {
1182       if (exp[0] == '\0')
1183         {
1184           *pexp = exp;
1185           return YYEOF;
1186         }
1187
1188       if (exp[0] != ' ' && exp[0] != '\t')
1189         break;
1190
1191       ++exp;
1192     }
1193
1194   result = *exp++;
1195   switch (result)
1196     {
1197     case '0': case '1': case '2': case '3': case '4':
1198     case '5': case '6': case '7': case '8': case '9':
1199       {
1200         unsigned long int n = result - '0';
1201         while (exp[0] >= '0' && exp[0] <= '9')
1202           {
1203             n *= 10;
1204             n += exp[0] - '0';
1205             ++exp;
1206           }
1207         lval->num = n;
1208         result = NUMBER;
1209       }
1210       break;
1211
1212     case '=':
1213       if (exp[0] == '=')
1214         {
1215           ++exp;
1216           lval->op = equal;
1217           result = EQUOP2;
1218         }
1219       else
1220         result = YYERRCODE;
1221       break;
1222
1223     case '!':
1224       if (exp[0] == '=')
1225         {
1226           ++exp;
1227           lval->op = not_equal;
1228           result = EQUOP2;
1229         }
1230       break;
1231
1232     case '&':
1233     case '|':
1234       if (exp[0] == result)
1235         ++exp;
1236       else
1237         result = YYERRCODE;
1238       break;
1239
1240     case '<':
1241       if (exp[0] == '=')
1242         {
1243           ++exp;
1244           lval->op = less_or_equal;
1245         }
1246       else
1247         lval->op = less_than;
1248       result = CMPOP2;
1249       break;
1250
1251     case '>':
1252       if (exp[0] == '=')
1253         {
1254           ++exp;
1255           lval->op = greater_or_equal;
1256         }
1257       else
1258         lval->op = greater_than;
1259       result = CMPOP2;
1260       break;
1261
1262     case '*':
1263       lval->op = mult;
1264       result = MULOP2;
1265       break;
1266
1267     case '/':
1268       lval->op = divide;
1269       result = MULOP2;
1270       break;
1271
1272     case '%':
1273       lval->op = module;
1274       result = MULOP2;
1275       break;
1276
1277     case '+':
1278       lval->op = plus;
1279       result = ADDOP2;
1280       break;
1281
1282     case '-':
1283       lval->op = minus;
1284       result = ADDOP2;
1285       break;
1286
1287     case 'n':
1288     case '?':
1289     case ':':
1290     case '(':
1291     case ')':
1292       /* Nothing, just return the character.  */
1293       break;
1294
1295     case ';':
1296     case '\n':
1297     case '\0':
1298       /* Be safe and let the user call this function again.  */
1299       --exp;
1300       result = YYEOF;
1301       break;
1302
1303     default:
1304       result = YYERRCODE;
1305 #if YYDEBUG != 0
1306       --exp;
1307 #endif
1308       break;
1309     }
1310
1311   *pexp = exp;
1312
1313   return result;
1314 }
1315
1316
1317 static void
1318 yyerror (str)
1319      const char *str;
1320 {
1321   /* Do nothing.  We don't print error messages here.  */
1322 }