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