intl/plural.c

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