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