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