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