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 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 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 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 } 1493