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