intl/plural.c

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