calc.c revision 1.1.1.1.2.1
1 /* A Bison parser, made by GNU Bison 2.7.12-4996. */ 2 3 /* Bison implementation for Yacc-like parsers in C 4 5 Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc. 6 7 This program is free software: you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation, either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 /* As a special exception, you may create a larger work that contains 21 part or all of the Bison parser skeleton and distribute that work 22 under terms of your choice, so long as that work isn't itself a 23 parser generator using the skeleton or a modified version thereof 24 as a parser skeleton. Alternatively, if you modify or redistribute 25 the parser skeleton itself, you may (at your option) remove this 26 special exception, which will cause the skeleton and the resulting 27 Bison output files to be licensed under the GNU General Public 28 License without this special exception. 29 30 This special exception was added by the Free Software Foundation in 31 version 2.2 of Bison. */ 32 33 /* C LALR(1) parser skeleton written by Richard Stallman, by 34 simplifying the original so-called "semantic" parser. */ 35 36 /* All symbols defined below should begin with yy or YY, to avoid 37 infringing on user name space. This should be done even for local 38 variables, as they might otherwise be expanded by user macros. 39 There are some unavoidable exceptions within include files to 40 define necessary library symbols; they are noted "INFRINGES ON 41 USER NAME SPACE" below. */ 42 43 /* Identify Bison output. */ 44 #define YYBISON 1 45 46 /* Bison version. */ 47 #define YYBISON_VERSION "2.7.12-4996" 48 49 /* Skeleton name. */ 50 #define YYSKELETON_NAME "yacc.c" 51 52 /* Pure parsers. */ 53 #define YYPURE 0 54 55 /* Push parsers. */ 56 #define YYPUSH 0 57 58 /* Pull parsers. */ 59 #define YYPULL 1 60 61 62 63 64 /* Copy the first part of user declarations. */ 65 /* Line 371 of yacc.c */ 66 #line 1 "calc.y" 67 68 /* A simple integer desk calculator using yacc and gmp. 69 70 Copyright 2000, 2001, 2002 Free Software Foundation, Inc. 71 72 This file is part of the GNU MP Library. 73 74 This program is free software; you can redistribute it and/or modify it under 75 the terms of the GNU General Public License as published by the Free Software 76 Foundation; either version 3 of the License, or (at your option) any later 77 version. 78 79 This program is distributed in the hope that it will be useful, but WITHOUT ANY 80 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A 81 PARTICULAR PURPOSE. See the GNU General Public License for more details. 82 83 You should have received a copy of the GNU General Public License along with 84 this program. If not, see http://www.gnu.org/licenses/. */ 85 86 87 /* This is a simple program, meant only to show one way to use GMP for this 88 sort of thing. There's few features, and error checking is minimal. 89 Standard input is read, calc_help() below shows the inputs accepted. 90 91 Expressions are evaluated as they're read. If user defined functions 92 were wanted it'd be necessary to build a parse tree like pexpr.c does, or 93 a list of operations for a stack based evaluator. That would also make 94 it possible to detect and optimize evaluations "mod m" like pexpr.c does. 95 96 A stack is used for intermediate values in the expression evaluation, 97 separate from the yacc parser stack. This is simple, makes error 98 recovery easy, minimizes the junk around mpz calls in the rules, and 99 saves initializing or clearing "mpz_t"s during a calculation. A 100 disadvantage though is that variables must be copied to the stack to be 101 worked on. A more sophisticated calculator or language system might be 102 able to avoid that when executing a compiled or semi-compiled form. 103 104 Avoiding repeated initializing and clearing of "mpz_t"s is important. In 105 this program the time spent parsing is obviously much greater than any 106 possible saving from this, but a proper calculator or language should 107 take some trouble over it. Don't be surprised if an init/clear takes 3 108 or more times as long as a 10 limb addition, depending on the system (see 109 the mpz_init_realloc_clear example in tune/README). */ 110 111 112 #include <stdio.h> 113 #include <stdlib.h> 114 #include <string.h> 115 #include "gmp.h" 116 #define NO_CALC_H /* because it conflicts with normal calc.c stuff */ 117 #include "calc-common.h" 118 119 120 #define numberof(x) (sizeof (x) / sizeof ((x)[0])) 121 122 123 void 124 calc_help (void) 125 { 126 printf ("Examples:\n"); 127 printf (" 2+3*4 expressions are evaluated\n"); 128 printf (" x=5^6 variables a to z can be set and used\n"); 129 printf ("Operators:\n"); 130 printf (" + - * arithmetic\n"); 131 printf (" / %% division and remainder (rounding towards negative infinity)\n"); 132 printf (" ^ exponentiation\n"); 133 printf (" ! factorial\n"); 134 printf (" << >> left and right shifts\n"); 135 printf (" <= >= > \\ comparisons, giving 1 if true, 0 if false\n"); 136 printf (" == != < /\n"); 137 printf (" && || logical and/or, giving 1 if true, 0 if false\n"); 138 printf ("Functions:\n"); 139 printf (" abs(n) absolute value\n"); 140 printf (" bin(n,m) binomial coefficient\n"); 141 printf (" fib(n) fibonacci number\n"); 142 printf (" gcd(a,b,..) greatest common divisor\n"); 143 printf (" kron(a,b) kronecker symbol\n"); 144 printf (" lcm(a,b,..) least common multiple\n"); 145 printf (" lucnum(n) lucas number\n"); 146 printf (" nextprime(n) next prime after n\n"); 147 printf (" powm(b,e,m) modulo powering, b^e%%m\n"); 148 printf (" root(n,r) r-th root\n"); 149 printf (" sqrt(n) square root\n"); 150 printf ("Other:\n"); 151 printf (" hex \\ set hex or decimal for input and output\n"); 152 printf (" decimal / (\"0x\" can be used for hex too)\n"); 153 printf (" quit exit program (EOF works too)\n"); 154 printf (" ; statements are separated with a ; or newline\n"); 155 printf (" \\ continue expressions with \\ before newline\n"); 156 printf (" # xxx comments are # though to newline\n"); 157 printf ("Hex numbers must be entered in upper case, to distinguish them from the\n"); 158 printf ("variables a to f (like in bc).\n"); 159 } 160 161 162 int ibase = 0; 163 int obase = 10; 164 165 166 /* The stack is a fixed size, which means there's a limit on the nesting 167 allowed in expressions. A more sophisticated program could let it grow 168 dynamically. */ 169 170 mpz_t stack[100]; 171 mpz_ptr sp = stack[0]; 172 173 #define CHECK_OVERFLOW() \ 174 if (sp >= stack[numberof(stack)]) /* FIXME */ \ 175 { \ 176 fprintf (stderr, \ 177 "Value stack overflow, too much nesting in expression\n"); \ 178 YYERROR; \ 179 } 180 181 #define CHECK_EMPTY() \ 182 if (sp != stack[0]) \ 183 { \ 184 fprintf (stderr, "Oops, expected the value stack to be empty\n"); \ 185 sp = stack[0]; \ 186 } 187 188 189 mpz_t variable[26]; 190 191 #define CHECK_VARIABLE(var) \ 192 if ((var) < 0 || (var) >= numberof (variable)) \ 193 { \ 194 fprintf (stderr, "Oops, bad variable somehow: %d\n", var); \ 195 YYERROR; \ 196 } 197 198 199 #define CHECK_UI(name,z) \ 200 if (! mpz_fits_ulong_p (z)) \ 201 { \ 202 fprintf (stderr, "%s too big\n", name); \ 203 YYERROR; \ 204 } 205 206 207 /* Line 371 of yacc.c */ 208 #line 209 "calc.c" 209 210 # ifndef YY_NULL 211 # if defined __cplusplus && 201103L <= __cplusplus 212 # define YY_NULL nullptr 213 # else 214 # define YY_NULL 0 215 # endif 216 # endif 217 218 /* Enabling verbose error messages. */ 219 #ifdef YYERROR_VERBOSE 220 # undef YYERROR_VERBOSE 221 # define YYERROR_VERBOSE 1 222 #else 223 # define YYERROR_VERBOSE 0 224 #endif 225 226 /* In a future release of Bison, this section will be replaced 227 by #include "y.tab.h". */ 228 #ifndef YY_YY_Y_TAB_H_INCLUDED 229 # define YY_YY_Y_TAB_H_INCLUDED 230 /* Enabling traces. */ 231 #ifndef YYDEBUG 232 # define YYDEBUG 0 233 #endif 234 #if YYDEBUG 235 extern int yydebug; 236 #endif 237 238 /* Tokens. */ 239 #ifndef YYTOKENTYPE 240 # define YYTOKENTYPE 241 /* Put the tokens into the symbol table, so that GDB and other debuggers 242 know about them. */ 243 enum yytokentype { 244 EOS = 258, 245 BAD = 259, 246 HELP = 260, 247 HEX = 261, 248 DECIMAL = 262, 249 QUIT = 263, 250 ABS = 264, 251 BIN = 265, 252 FIB = 266, 253 GCD = 267, 254 KRON = 268, 255 LCM = 269, 256 LUCNUM = 270, 257 NEXTPRIME = 271, 258 POWM = 272, 259 ROOT = 273, 260 SQRT = 274, 261 NUMBER = 275, 262 VARIABLE = 276, 263 LOR = 277, 264 LAND = 278, 265 GE = 279, 266 LE = 280, 267 NE = 281, 268 EQ = 282, 269 RSHIFT = 283, 270 LSHIFT = 284, 271 UMINUS = 285 272 }; 273 #endif 274 /* Tokens. */ 275 #define EOS 258 276 #define BAD 259 277 #define HELP 260 278 #define HEX 261 279 #define DECIMAL 262 280 #define QUIT 263 281 #define ABS 264 282 #define BIN 265 283 #define FIB 266 284 #define GCD 267 285 #define KRON 268 286 #define LCM 269 287 #define LUCNUM 270 288 #define NEXTPRIME 271 289 #define POWM 272 290 #define ROOT 273 291 #define SQRT 274 292 #define NUMBER 275 293 #define VARIABLE 276 294 #define LOR 277 295 #define LAND 278 296 #define GE 279 297 #define LE 280 298 #define NE 281 299 #define EQ 282 300 #define RSHIFT 283 301 #define LSHIFT 284 302 #define UMINUS 285 303 304 305 306 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 307 typedef union YYSTYPE 308 { 309 /* Line 387 of yacc.c */ 310 #line 142 "calc.y" 311 312 char *str; 313 int var; 314 315 316 /* Line 387 of yacc.c */ 317 #line 318 "calc.c" 318 } YYSTYPE; 319 # define YYSTYPE_IS_TRIVIAL 1 320 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 321 # define YYSTYPE_IS_DECLARED 1 322 #endif 323 324 extern YYSTYPE yylval; 325 326 #ifdef YYPARSE_PARAM 327 #if defined __STDC__ || defined __cplusplus 328 int yyparse (void *YYPARSE_PARAM); 329 #else 330 int yyparse (); 331 #endif 332 #else /* ! YYPARSE_PARAM */ 333 #if defined __STDC__ || defined __cplusplus 334 int yyparse (void); 335 #else 336 int yyparse (); 337 #endif 338 #endif /* ! YYPARSE_PARAM */ 339 340 #endif /* !YY_YY_Y_TAB_H_INCLUDED */ 341 342 /* Copy the second part of user declarations. */ 343 344 /* Line 390 of yacc.c */ 345 #line 346 "calc.c" 346 347 #ifdef short 348 # undef short 349 #endif 350 351 #ifdef YYTYPE_UINT8 352 typedef YYTYPE_UINT8 yytype_uint8; 353 #else 354 typedef unsigned char yytype_uint8; 355 #endif 356 357 #ifdef YYTYPE_INT8 358 typedef YYTYPE_INT8 yytype_int8; 359 #elif (defined __STDC__ || defined __C99__FUNC__ \ 360 || defined __cplusplus || defined _MSC_VER) 361 typedef signed char yytype_int8; 362 #else 363 typedef short int yytype_int8; 364 #endif 365 366 #ifdef YYTYPE_UINT16 367 typedef YYTYPE_UINT16 yytype_uint16; 368 #else 369 typedef unsigned short int yytype_uint16; 370 #endif 371 372 #ifdef YYTYPE_INT16 373 typedef YYTYPE_INT16 yytype_int16; 374 #else 375 typedef short int yytype_int16; 376 #endif 377 378 #ifndef YYSIZE_T 379 # ifdef __SIZE_TYPE__ 380 # define YYSIZE_T __SIZE_TYPE__ 381 # elif defined size_t 382 # define YYSIZE_T size_t 383 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 384 || defined __cplusplus || defined _MSC_VER) 385 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 386 # define YYSIZE_T size_t 387 # else 388 # define YYSIZE_T unsigned int 389 # endif 390 #endif 391 392 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 393 394 #ifndef YY_ 395 # if defined YYENABLE_NLS && YYENABLE_NLS 396 # if ENABLE_NLS 397 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 398 # define YY_(Msgid) dgettext ("bison-runtime", Msgid) 399 # endif 400 # endif 401 # ifndef YY_ 402 # define YY_(Msgid) Msgid 403 # endif 404 #endif 405 406 #ifndef __attribute__ 407 /* This feature is available in gcc versions 2.5 and later. */ 408 # if (! defined __GNUC__ || __GNUC__ < 2 \ 409 || (__GNUC__ == 2 && __GNUC_MINOR__ < 5)) 410 # define __attribute__(Spec) /* empty */ 411 # endif 412 #endif 413 414 /* Suppress unused-variable warnings by "using" E. */ 415 #if ! defined lint || defined __GNUC__ 416 # define YYUSE(E) ((void) (E)) 417 #else 418 # define YYUSE(E) /* empty */ 419 #endif 420 421 422 /* Identity function, used to suppress warnings about constant conditions. */ 423 #ifndef lint 424 # define YYID(N) (N) 425 #else 426 #if (defined __STDC__ || defined __C99__FUNC__ \ 427 || defined __cplusplus || defined _MSC_VER) 428 static int 429 YYID (int yyi) 430 #else 431 static int 432 YYID (yyi) 433 int yyi; 434 #endif 435 { 436 return yyi; 437 } 438 #endif 439 440 #if ! defined yyoverflow || YYERROR_VERBOSE 441 442 /* The parser invokes alloca or malloc; define the necessary symbols. */ 443 444 # ifdef YYSTACK_USE_ALLOCA 445 # if YYSTACK_USE_ALLOCA 446 # ifdef __GNUC__ 447 # define YYSTACK_ALLOC __builtin_alloca 448 # elif defined __BUILTIN_VA_ARG_INCR 449 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 450 # elif defined _AIX 451 # define YYSTACK_ALLOC __alloca 452 # elif defined _MSC_VER 453 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 454 # define alloca _alloca 455 # else 456 # define YYSTACK_ALLOC alloca 457 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 458 || defined __cplusplus || defined _MSC_VER) 459 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 460 /* Use EXIT_SUCCESS as a witness for stdlib.h. */ 461 # ifndef EXIT_SUCCESS 462 # define EXIT_SUCCESS 0 463 # endif 464 # endif 465 # endif 466 # endif 467 # endif 468 469 # ifdef YYSTACK_ALLOC 470 /* Pacify GCC's `empty if-body' warning. */ 471 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 472 # ifndef YYSTACK_ALLOC_MAXIMUM 473 /* The OS might guarantee only one guard page at the bottom of the stack, 474 and a page size can be as small as 4096 bytes. So we cannot safely 475 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 476 to allow for a few compiler-allocated temporary stack slots. */ 477 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 478 # endif 479 # else 480 # define YYSTACK_ALLOC YYMALLOC 481 # define YYSTACK_FREE YYFREE 482 # ifndef YYSTACK_ALLOC_MAXIMUM 483 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 484 # endif 485 # if (defined __cplusplus && ! defined EXIT_SUCCESS \ 486 && ! ((defined YYMALLOC || defined malloc) \ 487 && (defined YYFREE || defined free))) 488 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 489 # ifndef EXIT_SUCCESS 490 # define EXIT_SUCCESS 0 491 # endif 492 # endif 493 # ifndef YYMALLOC 494 # define YYMALLOC malloc 495 # if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 496 || defined __cplusplus || defined _MSC_VER) 497 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 498 # endif 499 # endif 500 # ifndef YYFREE 501 # define YYFREE free 502 # if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 503 || defined __cplusplus || defined _MSC_VER) 504 void free (void *); /* INFRINGES ON USER NAME SPACE */ 505 # endif 506 # endif 507 # endif 508 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 509 510 511 #if (! defined yyoverflow \ 512 && (! defined __cplusplus \ 513 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 514 515 /* A type that is properly aligned for any stack member. */ 516 union yyalloc 517 { 518 yytype_int16 yyss_alloc; 519 YYSTYPE yyvs_alloc; 520 }; 521 522 /* The size of the maximum gap between one aligned stack and the next. */ 523 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 524 525 /* The size of an array large to enough to hold all stacks, each with 526 N elements. */ 527 # define YYSTACK_BYTES(N) \ 528 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 529 + YYSTACK_GAP_MAXIMUM) 530 531 # define YYCOPY_NEEDED 1 532 533 /* Relocate STACK from its old location to the new one. The 534 local variables YYSIZE and YYSTACKSIZE give the old and new number of 535 elements in the stack, and YYPTR gives the new location of the 536 stack. Advance YYPTR to a properly aligned location for the next 537 stack. */ 538 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 539 do \ 540 { \ 541 YYSIZE_T yynewbytes; \ 542 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 543 Stack = &yyptr->Stack_alloc; \ 544 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 545 yyptr += yynewbytes / sizeof (*yyptr); \ 546 } \ 547 while (YYID (0)) 548 549 #endif 550 551 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED 552 /* Copy COUNT objects from SRC to DST. The source and destination do 553 not overlap. */ 554 # ifndef YYCOPY 555 # if defined __GNUC__ && 1 < __GNUC__ 556 # define YYCOPY(Dst, Src, Count) \ 557 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src))) 558 # else 559 # define YYCOPY(Dst, Src, Count) \ 560 do \ 561 { \ 562 YYSIZE_T yyi; \ 563 for (yyi = 0; yyi < (Count); yyi++) \ 564 (Dst)[yyi] = (Src)[yyi]; \ 565 } \ 566 while (YYID (0)) 567 # endif 568 # endif 569 #endif /* !YYCOPY_NEEDED */ 570 571 /* YYFINAL -- State number of the termination state. */ 572 #define YYFINAL 41 573 /* YYLAST -- Last index in YYTABLE. */ 574 #define YYLAST 552 575 576 /* YYNTOKENS -- Number of terminals. */ 577 #define YYNTOKENS 44 578 /* YYNNTS -- Number of nonterminals. */ 579 #define YYNNTS 7 580 /* YYNRULES -- Number of rules. */ 581 #define YYNRULES 49 582 /* YYNRULES -- Number of states. */ 583 #define YYNSTATES 118 584 585 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 586 #define YYUNDEFTOK 2 587 #define YYMAXUTOK 285 588 589 #define YYTRANSLATE(YYX) \ 590 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 591 592 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 593 static const yytype_uint8 yytranslate[] = 594 { 595 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 596 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 597 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 598 2, 2, 2, 39, 2, 2, 2, 36, 2, 2, 599 41, 42, 34, 32, 43, 33, 2, 35, 2, 2, 600 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 601 24, 40, 25, 2, 2, 2, 2, 2, 2, 2, 602 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 603 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 604 2, 2, 2, 2, 38, 2, 2, 2, 2, 2, 605 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 606 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 607 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 608 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 609 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 610 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 611 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 612 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 613 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 614 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 615 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 616 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 617 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 618 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 619 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 620 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 621 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 622 15, 16, 17, 18, 19, 20, 21, 22, 23, 26, 623 27, 28, 29, 30, 31, 37 624 }; 625 626 #if YYDEBUG 627 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 628 YYRHS. */ 629 static const yytype_uint8 yyprhs[] = 630 { 631 0, 0, 3, 5, 8, 11, 15, 18, 19, 21, 632 25, 27, 29, 31, 33, 37, 41, 45, 49, 53, 633 57, 61, 65, 69, 72, 75, 79, 83, 87, 91, 634 95, 99, 103, 107, 112, 119, 124, 129, 136, 141, 635 146, 151, 160, 167, 172, 174, 176, 178, 182, 184 636 }; 637 638 /* YYRHS -- A `-1'-separated list of the rules' RHS. */ 639 static const yytype_int8 yyrhs[] = 640 { 641 45, 0, -1, 47, -1, 46, 47, -1, 47, 3, 642 -1, 46, 47, 3, -1, 1, 3, -1, -1, 48, 643 -1, 21, 40, 48, -1, 5, -1, 6, -1, 7, 644 -1, 8, -1, 41, 48, 42, -1, 48, 32, 48, 645 -1, 48, 33, 48, -1, 48, 34, 48, -1, 48, 646 35, 48, -1, 48, 36, 48, -1, 48, 38, 48, 647 -1, 48, 31, 48, -1, 48, 30, 48, -1, 48, 648 39, -1, 33, 48, -1, 48, 24, 48, -1, 48, 649 27, 48, -1, 48, 29, 48, -1, 48, 28, 48, 650 -1, 48, 26, 48, -1, 48, 25, 48, -1, 48, 651 23, 48, -1, 48, 22, 48, -1, 9, 41, 48, 652 42, -1, 10, 41, 48, 43, 48, 42, -1, 11, 653 41, 48, 42, -1, 12, 41, 49, 42, -1, 13, 654 41, 48, 43, 48, 42, -1, 14, 41, 50, 42, 655 -1, 15, 41, 48, 42, -1, 16, 41, 48, 42, 656 -1, 17, 41, 48, 43, 48, 43, 48, 42, -1, 657 18, 41, 48, 43, 48, 42, -1, 19, 41, 48, 658 42, -1, 21, -1, 20, -1, 48, -1, 49, 43, 659 48, -1, 48, -1, 50, 43, 48, -1 660 }; 661 662 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 663 static const yytype_uint16 yyrline[] = 664 { 665 0, 167, 167, 168, 171, 172, 173, 175, 177, 182, 666 188, 189, 190, 191, 197, 198, 199, 200, 201, 202, 667 203, 205, 207, 209, 211, 213, 214, 215, 216, 217, 668 218, 220, 221, 223, 224, 226, 228, 229, 231, 232, 669 234, 235, 236, 238, 240, 246, 257, 258, 261, 262 670 }; 671 #endif 672 673 #if YYDEBUG || YYERROR_VERBOSE || 0 674 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 675 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 676 static const char *const yytname[] = 677 { 678 "$end", "error", "$undefined", "EOS", "BAD", "HELP", "HEX", "DECIMAL", 679 "QUIT", "ABS", "BIN", "FIB", "GCD", "KRON", "LCM", "LUCNUM", "NEXTPRIME", 680 "POWM", "ROOT", "SQRT", "NUMBER", "VARIABLE", "LOR", "LAND", "'<'", 681 "'>'", "GE", "LE", "NE", "EQ", "RSHIFT", "LSHIFT", "'+'", "'-'", "'*'", 682 "'/'", "'%'", "UMINUS", "'^'", "'!'", "'='", "'('", "')'", "','", 683 "$accept", "top", "statements", "statement", "e", "gcdlist", "lcmlist", YY_NULL 684 }; 685 #endif 686 687 # ifdef YYPRINT 688 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 689 token YYLEX-NUM. */ 690 static const yytype_uint16 yytoknum[] = 691 { 692 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 693 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 694 275, 276, 277, 278, 60, 62, 279, 280, 281, 282, 695 283, 284, 43, 45, 42, 47, 37, 285, 94, 33, 696 61, 40, 41, 44 697 }; 698 # endif 699 700 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 701 static const yytype_uint8 yyr1[] = 702 { 703 0, 44, 45, 45, 46, 46, 46, 47, 47, 47, 704 47, 47, 47, 47, 48, 48, 48, 48, 48, 48, 705 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 706 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 707 48, 48, 48, 48, 48, 48, 49, 49, 50, 50 708 }; 709 710 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 711 static const yytype_uint8 yyr2[] = 712 { 713 0, 2, 1, 2, 2, 3, 2, 0, 1, 3, 714 1, 1, 1, 1, 3, 3, 3, 3, 3, 3, 715 3, 3, 3, 2, 2, 3, 3, 3, 3, 3, 716 3, 3, 3, 4, 6, 4, 4, 6, 4, 4, 717 4, 8, 6, 4, 1, 1, 1, 3, 1, 3 718 }; 719 720 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM. 721 Performed when YYTABLE doesn't specify something else to do. Zero 722 means the default is an error. */ 723 static const yytype_uint8 yydefact[] = 724 { 725 0, 0, 10, 11, 12, 13, 0, 0, 0, 0, 726 0, 0, 0, 0, 0, 0, 0, 45, 44, 0, 727 0, 0, 7, 2, 8, 6, 0, 0, 0, 0, 728 0, 0, 0, 0, 0, 0, 0, 0, 44, 24, 729 0, 1, 3, 4, 0, 0, 0, 0, 0, 0, 730 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 731 23, 0, 0, 0, 46, 0, 0, 48, 0, 0, 732 0, 0, 0, 0, 9, 14, 5, 32, 31, 25, 733 30, 29, 26, 28, 27, 22, 21, 15, 16, 17, 734 18, 19, 20, 33, 0, 35, 36, 0, 0, 38, 735 0, 39, 40, 0, 0, 43, 0, 47, 0, 49, 736 0, 0, 34, 37, 0, 42, 0, 41 737 }; 738 739 /* YYDEFGOTO[NTERM-NUM]. */ 740 static const yytype_int8 yydefgoto[] = 741 { 742 -1, 21, 22, 23, 24, 65, 68 743 }; 744 745 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 746 STATE-NUM. */ 747 #define YYPACT_NINF -39 748 static const yytype_int16 yypact[] = 749 { 750 41, 3, -39, -39, -39, -39, 2, 4, 27, 32, 751 35, 36, 39, 42, 45, 46, 47, -39, -18, 124, 752 124, 89, 91, 87, 464, -39, 124, 124, 124, 124, 753 124, 124, 124, 124, 124, 124, 124, 124, -39, -36, 754 254, -39, 88, -39, 124, 124, 124, 124, 124, 124, 755 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 756 -39, 275, 144, 296, 464, -38, 166, 464, 29, 317, 757 338, 188, 210, 359, 464, -39, -39, 481, 497, 513, 758 513, 513, 513, 513, 513, 31, 31, -15, -15, -36, 759 -36, -36, -36, -39, 124, -39, -39, 124, 124, -39, 760 124, -39, -39, 124, 124, -39, 380, 464, 401, 464, 761 232, 422, -39, -39, 124, -39, 443, -39 762 }; 763 764 /* YYPGOTO[NTERM-NUM]. */ 765 static const yytype_int8 yypgoto[] = 766 { 767 -39, -39, -39, 70, -19, -39, -39 768 }; 769 770 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 771 positive, shift that token. If negative, reduce the rule which 772 number is the opposite. If YYTABLE_NINF, syntax error. */ 773 #define YYTABLE_NINF -8 774 static const yytype_int8 yytable[] = 775 { 776 39, 40, 59, 60, 96, 97, 25, 61, 62, 63, 777 64, 66, 67, 69, 70, 71, 72, 73, 74, 56, 778 57, 58, 37, 59, 60, 77, 78, 79, 80, 81, 779 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 780 92, -7, 1, 26, -7, 27, 2, 3, 4, 5, 781 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 782 16, 17, 18, 54, 55, 56, 57, 58, 28, 59, 783 60, 99, 100, 29, 19, 106, 30, 31, 107, 108, 784 32, 109, 20, 33, 110, 111, 34, 35, 36, 41, 785 43, 76, 42, 0, 0, 116, 2, 3, 4, 5, 786 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 787 16, 17, 18, 0, 0, 0, 0, 0, 0, 0, 788 0, 0, 0, 0, 19, 0, 0, 0, 0, 0, 789 0, 0, 20, 6, 7, 8, 9, 10, 11, 12, 790 13, 14, 15, 16, 17, 38, 0, 0, 0, 0, 791 0, 0, 0, 0, 0, 0, 0, 19, 0, 0, 792 0, 0, 0, 0, 0, 20, 44, 45, 46, 47, 793 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 794 58, 0, 59, 60, 0, 0, 0, 94, 44, 45, 795 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 796 56, 57, 58, 0, 59, 60, 0, 0, 0, 98, 797 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 798 54, 55, 56, 57, 58, 0, 59, 60, 0, 0, 799 0, 103, 44, 45, 46, 47, 48, 49, 50, 51, 800 52, 53, 54, 55, 56, 57, 58, 0, 59, 60, 801 0, 0, 0, 104, 44, 45, 46, 47, 48, 49, 802 50, 51, 52, 53, 54, 55, 56, 57, 58, 0, 803 59, 60, 0, 0, 0, 114, 44, 45, 46, 47, 804 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 805 58, 0, 59, 60, 0, 0, 75, 44, 45, 46, 806 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 807 57, 58, 0, 59, 60, 0, 0, 93, 44, 45, 808 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 809 56, 57, 58, 0, 59, 60, 0, 0, 95, 44, 810 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 811 55, 56, 57, 58, 0, 59, 60, 0, 0, 101, 812 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 813 54, 55, 56, 57, 58, 0, 59, 60, 0, 0, 814 102, 44, 45, 46, 47, 48, 49, 50, 51, 52, 815 53, 54, 55, 56, 57, 58, 0, 59, 60, 0, 816 0, 105, 44, 45, 46, 47, 48, 49, 50, 51, 817 52, 53, 54, 55, 56, 57, 58, 0, 59, 60, 818 0, 0, 112, 44, 45, 46, 47, 48, 49, 50, 819 51, 52, 53, 54, 55, 56, 57, 58, 0, 59, 820 60, 0, 0, 113, 44, 45, 46, 47, 48, 49, 821 50, 51, 52, 53, 54, 55, 56, 57, 58, 0, 822 59, 60, 0, 0, 115, 44, 45, 46, 47, 48, 823 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 824 0, 59, 60, 0, 0, 117, 44, 45, 46, 47, 825 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 826 58, 0, 59, 60, 45, 46, 47, 48, 49, 50, 827 51, 52, 53, 54, 55, 56, 57, 58, 0, 59, 828 60, 46, 47, 48, 49, 50, 51, 52, 53, 54, 829 55, 56, 57, 58, 0, 59, 60, -8, -8, -8, 830 -8, -8, -8, 52, 53, 54, 55, 56, 57, 58, 831 0, 59, 60 832 }; 833 834 #define yypact_value_is_default(Yystate) \ 835 (!!((Yystate) == (-39))) 836 837 #define yytable_value_is_error(Yytable_value) \ 838 (!!((Yytable_value) == (-8))) 839 840 static const yytype_int8 yycheck[] = 841 { 842 19, 20, 38, 39, 42, 43, 3, 26, 27, 28, 843 29, 30, 31, 32, 33, 34, 35, 36, 37, 34, 844 35, 36, 40, 38, 39, 44, 45, 46, 47, 48, 845 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 846 59, 0, 1, 41, 3, 41, 5, 6, 7, 8, 847 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 848 19, 20, 21, 32, 33, 34, 35, 36, 41, 38, 849 39, 42, 43, 41, 33, 94, 41, 41, 97, 98, 850 41, 100, 41, 41, 103, 104, 41, 41, 41, 0, 851 3, 3, 22, -1, -1, 114, 5, 6, 7, 8, 852 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 853 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, 854 -1, -1, -1, -1, 33, -1, -1, -1, -1, -1, 855 -1, -1, 41, 9, 10, 11, 12, 13, 14, 15, 856 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, 857 -1, -1, -1, -1, -1, -1, -1, 33, -1, -1, 858 -1, -1, -1, -1, -1, 41, 22, 23, 24, 25, 859 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 860 36, -1, 38, 39, -1, -1, -1, 43, 22, 23, 861 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 862 34, 35, 36, -1, 38, 39, -1, -1, -1, 43, 863 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 864 32, 33, 34, 35, 36, -1, 38, 39, -1, -1, 865 -1, 43, 22, 23, 24, 25, 26, 27, 28, 29, 866 30, 31, 32, 33, 34, 35, 36, -1, 38, 39, 867 -1, -1, -1, 43, 22, 23, 24, 25, 26, 27, 868 28, 29, 30, 31, 32, 33, 34, 35, 36, -1, 869 38, 39, -1, -1, -1, 43, 22, 23, 24, 25, 870 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 871 36, -1, 38, 39, -1, -1, 42, 22, 23, 24, 872 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 873 35, 36, -1, 38, 39, -1, -1, 42, 22, 23, 874 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 875 34, 35, 36, -1, 38, 39, -1, -1, 42, 22, 876 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 877 33, 34, 35, 36, -1, 38, 39, -1, -1, 42, 878 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 879 32, 33, 34, 35, 36, -1, 38, 39, -1, -1, 880 42, 22, 23, 24, 25, 26, 27, 28, 29, 30, 881 31, 32, 33, 34, 35, 36, -1, 38, 39, -1, 882 -1, 42, 22, 23, 24, 25, 26, 27, 28, 29, 883 30, 31, 32, 33, 34, 35, 36, -1, 38, 39, 884 -1, -1, 42, 22, 23, 24, 25, 26, 27, 28, 885 29, 30, 31, 32, 33, 34, 35, 36, -1, 38, 886 39, -1, -1, 42, 22, 23, 24, 25, 26, 27, 887 28, 29, 30, 31, 32, 33, 34, 35, 36, -1, 888 38, 39, -1, -1, 42, 22, 23, 24, 25, 26, 889 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 890 -1, 38, 39, -1, -1, 42, 22, 23, 24, 25, 891 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 892 36, -1, 38, 39, 23, 24, 25, 26, 27, 28, 893 29, 30, 31, 32, 33, 34, 35, 36, -1, 38, 894 39, 24, 25, 26, 27, 28, 29, 30, 31, 32, 895 33, 34, 35, 36, -1, 38, 39, 24, 25, 26, 896 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 897 -1, 38, 39 898 }; 899 900 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 901 symbol of state STATE-NUM. */ 902 static const yytype_uint8 yystos[] = 903 { 904 0, 1, 5, 6, 7, 8, 9, 10, 11, 12, 905 13, 14, 15, 16, 17, 18, 19, 20, 21, 33, 906 41, 45, 46, 47, 48, 3, 41, 41, 41, 41, 907 41, 41, 41, 41, 41, 41, 41, 40, 21, 48, 908 48, 0, 47, 3, 22, 23, 24, 25, 26, 27, 909 28, 29, 30, 31, 32, 33, 34, 35, 36, 38, 910 39, 48, 48, 48, 48, 49, 48, 48, 50, 48, 911 48, 48, 48, 48, 48, 42, 3, 48, 48, 48, 912 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 913 48, 48, 48, 42, 43, 42, 42, 43, 43, 42, 914 43, 42, 42, 43, 43, 42, 48, 48, 48, 48, 915 48, 48, 42, 42, 43, 42, 48, 42 916 }; 917 918 #define yyerrok (yyerrstatus = 0) 919 #define yyclearin (yychar = YYEMPTY) 920 #define YYEMPTY (-2) 921 #define YYEOF 0 922 923 #define YYACCEPT goto yyacceptlab 924 #define YYABORT goto yyabortlab 925 #define YYERROR goto yyerrorlab 926 927 928 /* Like YYERROR except do call yyerror. This remains here temporarily 929 to ease the transition to the new meaning of YYERROR, for GCC. 930 Once GCC version 2 has supplanted version 1, this can go. However, 931 YYFAIL appears to be in use. Nevertheless, it is formally deprecated 932 in Bison 2.4.2's NEWS entry, where a plan to phase it out is 933 discussed. */ 934 935 #define YYFAIL goto yyerrlab 936 #if defined YYFAIL 937 /* This is here to suppress warnings from the GCC cpp's 938 -Wunused-macros. Normally we don't worry about that warning, but 939 some users do, and we want to make it easy for users to remove 940 YYFAIL uses, which will produce warnings from Bison 2.5. */ 941 #endif 942 943 #define YYRECOVERING() (!!yyerrstatus) 944 945 #define YYBACKUP(Token, Value) \ 946 do \ 947 if (yychar == YYEMPTY) \ 948 { \ 949 yychar = (Token); \ 950 yylval = (Value); \ 951 YYPOPSTACK (yylen); \ 952 yystate = *yyssp; \ 953 goto yybackup; \ 954 } \ 955 else \ 956 { \ 957 yyerror (YY_("syntax error: cannot back up")); \ 958 YYERROR; \ 959 } \ 960 while (YYID (0)) 961 962 /* Error token number */ 963 #define YYTERROR 1 964 #define YYERRCODE 256 965 966 967 /* This macro is provided for backward compatibility. */ 968 #ifndef YY_LOCATION_PRINT 969 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 970 #endif 971 972 973 /* YYLEX -- calling `yylex' with the right arguments. */ 974 #ifdef YYLEX_PARAM 975 # define YYLEX yylex (YYLEX_PARAM) 976 #else 977 # define YYLEX yylex () 978 #endif 979 980 /* Enable debugging if requested. */ 981 #if YYDEBUG 982 983 # ifndef YYFPRINTF 984 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 985 # define YYFPRINTF fprintf 986 # endif 987 988 # define YYDPRINTF(Args) \ 989 do { \ 990 if (yydebug) \ 991 YYFPRINTF Args; \ 992 } while (YYID (0)) 993 994 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 995 do { \ 996 if (yydebug) \ 997 { \ 998 YYFPRINTF (stderr, "%s ", Title); \ 999 yy_symbol_print (stderr, \ 1000 Type, Value); \ 1001 YYFPRINTF (stderr, "\n"); \ 1002 } \ 1003 } while (YYID (0)) 1004 1005 1006 /*--------------------------------. 1007 | Print this symbol on YYOUTPUT. | 1008 `--------------------------------*/ 1009 1010 /*ARGSUSED*/ 1011 #if (defined __STDC__ || defined __C99__FUNC__ \ 1012 || defined __cplusplus || defined _MSC_VER) 1013 static void 1014 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 1015 #else 1016 static void 1017 yy_symbol_value_print (yyoutput, yytype, yyvaluep) 1018 FILE *yyoutput; 1019 int yytype; 1020 YYSTYPE const * const yyvaluep; 1021 #endif 1022 { 1023 FILE *yyo = yyoutput; 1024 YYUSE (yyo); 1025 if (!yyvaluep) 1026 return; 1027 # ifdef YYPRINT 1028 if (yytype < YYNTOKENS) 1029 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 1030 # else 1031 YYUSE (yyoutput); 1032 # endif 1033 YYUSE (yytype); 1034 } 1035 1036 1037 /*--------------------------------. 1038 | Print this symbol on YYOUTPUT. | 1039 `--------------------------------*/ 1040 1041 #if (defined __STDC__ || defined __C99__FUNC__ \ 1042 || defined __cplusplus || defined _MSC_VER) 1043 static void 1044 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 1045 #else 1046 static void 1047 yy_symbol_print (yyoutput, yytype, yyvaluep) 1048 FILE *yyoutput; 1049 int yytype; 1050 YYSTYPE const * const yyvaluep; 1051 #endif 1052 { 1053 if (yytype < YYNTOKENS) 1054 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 1055 else 1056 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 1057 1058 yy_symbol_value_print (yyoutput, yytype, yyvaluep); 1059 YYFPRINTF (yyoutput, ")"); 1060 } 1061 1062 /*------------------------------------------------------------------. 1063 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 1064 | TOP (included). | 1065 `------------------------------------------------------------------*/ 1066 1067 #if (defined __STDC__ || defined __C99__FUNC__ \ 1068 || defined __cplusplus || defined _MSC_VER) 1069 static void 1070 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 1071 #else 1072 static void 1073 yy_stack_print (yybottom, yytop) 1074 yytype_int16 *yybottom; 1075 yytype_int16 *yytop; 1076 #endif 1077 { 1078 YYFPRINTF (stderr, "Stack now"); 1079 for (; yybottom <= yytop; yybottom++) 1080 { 1081 int yybot = *yybottom; 1082 YYFPRINTF (stderr, " %d", yybot); 1083 } 1084 YYFPRINTF (stderr, "\n"); 1085 } 1086 1087 # define YY_STACK_PRINT(Bottom, Top) \ 1088 do { \ 1089 if (yydebug) \ 1090 yy_stack_print ((Bottom), (Top)); \ 1091 } while (YYID (0)) 1092 1093 1094 /*------------------------------------------------. 1095 | Report that the YYRULE is going to be reduced. | 1096 `------------------------------------------------*/ 1097 1098 #if (defined __STDC__ || defined __C99__FUNC__ \ 1099 || defined __cplusplus || defined _MSC_VER) 1100 static void 1101 yy_reduce_print (YYSTYPE *yyvsp, int yyrule) 1102 #else 1103 static void 1104 yy_reduce_print (yyvsp, yyrule) 1105 YYSTYPE *yyvsp; 1106 int yyrule; 1107 #endif 1108 { 1109 int yynrhs = yyr2[yyrule]; 1110 int yyi; 1111 unsigned long int yylno = yyrline[yyrule]; 1112 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 1113 yyrule - 1, yylno); 1114 /* The symbols being reduced. */ 1115 for (yyi = 0; yyi < yynrhs; yyi++) 1116 { 1117 YYFPRINTF (stderr, " $%d = ", yyi + 1); 1118 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 1119 &(yyvsp[(yyi + 1) - (yynrhs)]) 1120 ); 1121 YYFPRINTF (stderr, "\n"); 1122 } 1123 } 1124 1125 # define YY_REDUCE_PRINT(Rule) \ 1126 do { \ 1127 if (yydebug) \ 1128 yy_reduce_print (yyvsp, Rule); \ 1129 } while (YYID (0)) 1130 1131 /* Nonzero means print parse trace. It is left uninitialized so that 1132 multiple parsers can coexist. */ 1133 int yydebug; 1134 #else /* !YYDEBUG */ 1135 # define YYDPRINTF(Args) 1136 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 1137 # define YY_STACK_PRINT(Bottom, Top) 1138 # define YY_REDUCE_PRINT(Rule) 1139 #endif /* !YYDEBUG */ 1140 1141 1142 /* YYINITDEPTH -- initial size of the parser's stacks. */ 1143 #ifndef YYINITDEPTH 1144 # define YYINITDEPTH 200 1145 #endif 1146 1147 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 1148 if the built-in stack extension method is used). 1149 1150 Do not make this value too large; the results are undefined if 1151 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 1152 evaluated with infinite-precision integer arithmetic. */ 1153 1154 #ifndef YYMAXDEPTH 1155 # define YYMAXDEPTH 10000 1156 #endif 1157 1158 1159 #if YYERROR_VERBOSE 1160 1161 # ifndef yystrlen 1162 # if defined __GLIBC__ && defined _STRING_H 1163 # define yystrlen strlen 1164 # else 1165 /* Return the length of YYSTR. */ 1166 #if (defined __STDC__ || defined __C99__FUNC__ \ 1167 || defined __cplusplus || defined _MSC_VER) 1168 static YYSIZE_T 1169 yystrlen (const char *yystr) 1170 #else 1171 static YYSIZE_T 1172 yystrlen (yystr) 1173 const char *yystr; 1174 #endif 1175 { 1176 YYSIZE_T yylen; 1177 for (yylen = 0; yystr[yylen]; yylen++) 1178 continue; 1179 return yylen; 1180 } 1181 # endif 1182 # endif 1183 1184 # ifndef yystpcpy 1185 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 1186 # define yystpcpy stpcpy 1187 # else 1188 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 1189 YYDEST. */ 1190 #if (defined __STDC__ || defined __C99__FUNC__ \ 1191 || defined __cplusplus || defined _MSC_VER) 1192 static char * 1193 yystpcpy (char *yydest, const char *yysrc) 1194 #else 1195 static char * 1196 yystpcpy (yydest, yysrc) 1197 char *yydest; 1198 const char *yysrc; 1199 #endif 1200 { 1201 char *yyd = yydest; 1202 const char *yys = yysrc; 1203 1204 while ((*yyd++ = *yys++) != '\0') 1205 continue; 1206 1207 return yyd - 1; 1208 } 1209 # endif 1210 # endif 1211 1212 # ifndef yytnamerr 1213 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 1214 quotes and backslashes, so that it's suitable for yyerror. The 1215 heuristic is that double-quoting is unnecessary unless the string 1216 contains an apostrophe, a comma, or backslash (other than 1217 backslash-backslash). YYSTR is taken from yytname. If YYRES is 1218 null, do not copy; instead, return the length of what the result 1219 would have been. */ 1220 static YYSIZE_T 1221 yytnamerr (char *yyres, const char *yystr) 1222 { 1223 if (*yystr == '"') 1224 { 1225 YYSIZE_T yyn = 0; 1226 char const *yyp = yystr; 1227 1228 for (;;) 1229 switch (*++yyp) 1230 { 1231 case '\'': 1232 case ',': 1233 goto do_not_strip_quotes; 1234 1235 case '\\': 1236 if (*++yyp != '\\') 1237 goto do_not_strip_quotes; 1238 /* Fall through. */ 1239 default: 1240 if (yyres) 1241 yyres[yyn] = *yyp; 1242 yyn++; 1243 break; 1244 1245 case '"': 1246 if (yyres) 1247 yyres[yyn] = '\0'; 1248 return yyn; 1249 } 1250 do_not_strip_quotes: ; 1251 } 1252 1253 if (! yyres) 1254 return yystrlen (yystr); 1255 1256 return yystpcpy (yyres, yystr) - yyres; 1257 } 1258 # endif 1259 1260 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message 1261 about the unexpected token YYTOKEN for the state stack whose top is 1262 YYSSP. 1263 1264 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is 1265 not large enough to hold the message. In that case, also set 1266 *YYMSG_ALLOC to the required number of bytes. Return 2 if the 1267 required number of bytes is too large to store. */ 1268 static int 1269 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, 1270 yytype_int16 *yyssp, int yytoken) 1271 { 1272 YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]); 1273 YYSIZE_T yysize = yysize0; 1274 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1275 /* Internationalized format string. */ 1276 const char *yyformat = YY_NULL; 1277 /* Arguments of yyformat. */ 1278 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1279 /* Number of reported tokens (one for the "unexpected", one per 1280 "expected"). */ 1281 int yycount = 0; 1282 1283 /* There are many possibilities here to consider: 1284 - Assume YYFAIL is not used. It's too flawed to consider. See 1285 <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html> 1286 for details. YYERROR is fine as it does not invoke this 1287 function. 1288 - If this state is a consistent state with a default action, then 1289 the only way this function was invoked is if the default action 1290 is an error action. In that case, don't check for expected 1291 tokens because there are none. 1292 - The only way there can be no lookahead present (in yychar) is if 1293 this state is a consistent state with a default action. Thus, 1294 detecting the absence of a lookahead is sufficient to determine 1295 that there is no unexpected or expected token to report. In that 1296 case, just report a simple "syntax error". 1297 - Don't assume there isn't a lookahead just because this state is a 1298 consistent state with a default action. There might have been a 1299 previous inconsistent state, consistent state with a non-default 1300 action, or user semantic action that manipulated yychar. 1301 - Of course, the expected token list depends on states to have 1302 correct lookahead information, and it depends on the parser not 1303 to perform extra reductions after fetching a lookahead from the 1304 scanner and before detecting a syntax error. Thus, state merging 1305 (from LALR or IELR) and default reductions corrupt the expected 1306 token list. However, the list is correct for canonical LR with 1307 one exception: it will still contain any token that will not be 1308 accepted due to an error action in a later state. 1309 */ 1310 if (yytoken != YYEMPTY) 1311 { 1312 int yyn = yypact[*yyssp]; 1313 yyarg[yycount++] = yytname[yytoken]; 1314 if (!yypact_value_is_default (yyn)) 1315 { 1316 /* Start YYX at -YYN if negative to avoid negative indexes in 1317 YYCHECK. In other words, skip the first -YYN actions for 1318 this state because they are default actions. */ 1319 int yyxbegin = yyn < 0 ? -yyn : 0; 1320 /* Stay within bounds of both yycheck and yytname. */ 1321 int yychecklim = YYLAST - yyn + 1; 1322 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 1323 int yyx; 1324 1325 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 1326 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR 1327 && !yytable_value_is_error (yytable[yyx + yyn])) 1328 { 1329 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 1330 { 1331 yycount = 1; 1332 yysize = yysize0; 1333 break; 1334 } 1335 yyarg[yycount++] = yytname[yyx]; 1336 { 1337 YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]); 1338 if (! (yysize <= yysize1 1339 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 1340 return 2; 1341 yysize = yysize1; 1342 } 1343 } 1344 } 1345 } 1346 1347 switch (yycount) 1348 { 1349 # define YYCASE_(N, S) \ 1350 case N: \ 1351 yyformat = S; \ 1352 break 1353 YYCASE_(0, YY_("syntax error")); 1354 YYCASE_(1, YY_("syntax error, unexpected %s")); 1355 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); 1356 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); 1357 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); 1358 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); 1359 # undef YYCASE_ 1360 } 1361 1362 { 1363 YYSIZE_T yysize1 = yysize + yystrlen (yyformat); 1364 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 1365 return 2; 1366 yysize = yysize1; 1367 } 1368 1369 if (*yymsg_alloc < yysize) 1370 { 1371 *yymsg_alloc = 2 * yysize; 1372 if (! (yysize <= *yymsg_alloc 1373 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) 1374 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; 1375 return 1; 1376 } 1377 1378 /* Avoid sprintf, as that infringes on the user's name space. 1379 Don't have undefined behavior even if the translation 1380 produced a string with the wrong number of "%s"s. */ 1381 { 1382 char *yyp = *yymsg; 1383 int yyi = 0; 1384 while ((*yyp = *yyformat) != '\0') 1385 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) 1386 { 1387 yyp += yytnamerr (yyp, yyarg[yyi++]); 1388 yyformat += 2; 1389 } 1390 else 1391 { 1392 yyp++; 1393 yyformat++; 1394 } 1395 } 1396 return 0; 1397 } 1398 #endif /* YYERROR_VERBOSE */ 1399 1400 /*-----------------------------------------------. 1401 | Release the memory associated to this symbol. | 1402 `-----------------------------------------------*/ 1403 1404 /*ARGSUSED*/ 1405 #if (defined __STDC__ || defined __C99__FUNC__ \ 1406 || defined __cplusplus || defined _MSC_VER) 1407 static void 1408 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 1409 #else 1410 static void 1411 yydestruct (yymsg, yytype, yyvaluep) 1412 const char *yymsg; 1413 int yytype; 1414 YYSTYPE *yyvaluep; 1415 #endif 1416 { 1417 YYUSE (yyvaluep); 1418 1419 if (!yymsg) 1420 yymsg = "Deleting"; 1421 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1422 1423 YYUSE (yytype); 1424 } 1425 1426 1427 1428 1429 /* The lookahead symbol. */ 1430 int yychar; 1431 1432 1433 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1434 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1435 # define YY_IGNORE_MAYBE_UNINITIALIZED_END 1436 #endif 1437 #ifndef YY_INITIAL_VALUE 1438 # define YY_INITIAL_VALUE(Value) /* Nothing. */ 1439 #endif 1440 1441 /* The semantic value of the lookahead symbol. */ 1442 YYSTYPE yylval YY_INITIAL_VALUE(yyval_default); 1443 1444 /* Number of syntax errors so far. */ 1445 int yynerrs; 1446 1447 1448 /*----------. 1449 | yyparse. | 1450 `----------*/ 1451 1452 #ifdef YYPARSE_PARAM 1453 #if (defined __STDC__ || defined __C99__FUNC__ \ 1454 || defined __cplusplus || defined _MSC_VER) 1455 int 1456 yyparse (void *YYPARSE_PARAM) 1457 #else 1458 int 1459 yyparse (YYPARSE_PARAM) 1460 void *YYPARSE_PARAM; 1461 #endif 1462 #else /* ! YYPARSE_PARAM */ 1463 #if (defined __STDC__ || defined __C99__FUNC__ \ 1464 || defined __cplusplus || defined _MSC_VER) 1465 int 1466 yyparse (void) 1467 #else 1468 int 1469 yyparse () 1470 1471 #endif 1472 #endif 1473 { 1474 int yystate; 1475 /* Number of tokens to shift before error messages enabled. */ 1476 int yyerrstatus; 1477 1478 /* The stacks and their tools: 1479 `yyss': related to states. 1480 `yyvs': related to semantic values. 1481 1482 Refer to the stacks through separate pointers, to allow yyoverflow 1483 to reallocate them elsewhere. */ 1484 1485 /* The state stack. */ 1486 yytype_int16 yyssa[YYINITDEPTH]; 1487 yytype_int16 *yyss; 1488 yytype_int16 *yyssp; 1489 1490 /* The semantic value stack. */ 1491 YYSTYPE yyvsa[YYINITDEPTH]; 1492 YYSTYPE *yyvs; 1493 YYSTYPE *yyvsp; 1494 1495 YYSIZE_T yystacksize; 1496 1497 int yyn; 1498 int yyresult; 1499 /* Lookahead token as an internal (translated) token number. */ 1500 int yytoken = 0; 1501 /* The variables used to return semantic value and location from the 1502 action routines. */ 1503 YYSTYPE yyval; 1504 1505 #if YYERROR_VERBOSE 1506 /* Buffer for error messages, and its allocated size. */ 1507 char yymsgbuf[128]; 1508 char *yymsg = yymsgbuf; 1509 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 1510 #endif 1511 1512 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1513 1514 /* The number of symbols on the RHS of the reduced rule. 1515 Keep to zero when no symbol should be popped. */ 1516 int yylen = 0; 1517 1518 yyssp = yyss = yyssa; 1519 yyvsp = yyvs = yyvsa; 1520 yystacksize = YYINITDEPTH; 1521 1522 YYDPRINTF ((stderr, "Starting parse\n")); 1523 1524 yystate = 0; 1525 yyerrstatus = 0; 1526 yynerrs = 0; 1527 yychar = YYEMPTY; /* Cause a token to be read. */ 1528 goto yysetstate; 1529 1530 /*------------------------------------------------------------. 1531 | yynewstate -- Push a new state, which is found in yystate. | 1532 `------------------------------------------------------------*/ 1533 yynewstate: 1534 /* In all cases, when you get here, the value and location stacks 1535 have just been pushed. So pushing a state here evens the stacks. */ 1536 yyssp++; 1537 1538 yysetstate: 1539 *yyssp = yystate; 1540 1541 if (yyss + yystacksize - 1 <= yyssp) 1542 { 1543 /* Get the current used size of the three stacks, in elements. */ 1544 YYSIZE_T yysize = yyssp - yyss + 1; 1545 1546 #ifdef yyoverflow 1547 { 1548 /* Give user a chance to reallocate the stack. Use copies of 1549 these so that the &'s don't force the real ones into 1550 memory. */ 1551 YYSTYPE *yyvs1 = yyvs; 1552 yytype_int16 *yyss1 = yyss; 1553 1554 /* Each stack pointer address is followed by the size of the 1555 data in use in that stack, in bytes. This used to be a 1556 conditional around just the two extra args, but that might 1557 be undefined if yyoverflow is a macro. */ 1558 yyoverflow (YY_("memory exhausted"), 1559 &yyss1, yysize * sizeof (*yyssp), 1560 &yyvs1, yysize * sizeof (*yyvsp), 1561 &yystacksize); 1562 1563 yyss = yyss1; 1564 yyvs = yyvs1; 1565 } 1566 #else /* no yyoverflow */ 1567 # ifndef YYSTACK_RELOCATE 1568 goto yyexhaustedlab; 1569 # else 1570 /* Extend the stack our own way. */ 1571 if (YYMAXDEPTH <= yystacksize) 1572 goto yyexhaustedlab; 1573 yystacksize *= 2; 1574 if (YYMAXDEPTH < yystacksize) 1575 yystacksize = YYMAXDEPTH; 1576 1577 { 1578 yytype_int16 *yyss1 = yyss; 1579 union yyalloc *yyptr = 1580 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1581 if (! yyptr) 1582 goto yyexhaustedlab; 1583 YYSTACK_RELOCATE (yyss_alloc, yyss); 1584 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 1585 # undef YYSTACK_RELOCATE 1586 if (yyss1 != yyssa) 1587 YYSTACK_FREE (yyss1); 1588 } 1589 # endif 1590 #endif /* no yyoverflow */ 1591 1592 yyssp = yyss + yysize - 1; 1593 yyvsp = yyvs + yysize - 1; 1594 1595 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1596 (unsigned long int) yystacksize)); 1597 1598 if (yyss + yystacksize - 1 <= yyssp) 1599 YYABORT; 1600 } 1601 1602 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1603 1604 if (yystate == YYFINAL) 1605 YYACCEPT; 1606 1607 goto yybackup; 1608 1609 /*-----------. 1610 | yybackup. | 1611 `-----------*/ 1612 yybackup: 1613 1614 /* Do appropriate processing given the current state. Read a 1615 lookahead token if we need one and don't already have one. */ 1616 1617 /* First try to decide what to do without reference to lookahead token. */ 1618 yyn = yypact[yystate]; 1619 if (yypact_value_is_default (yyn)) 1620 goto yydefault; 1621 1622 /* Not known => get a lookahead token if don't already have one. */ 1623 1624 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 1625 if (yychar == YYEMPTY) 1626 { 1627 YYDPRINTF ((stderr, "Reading a token: ")); 1628 yychar = YYLEX; 1629 } 1630 1631 if (yychar <= YYEOF) 1632 { 1633 yychar = yytoken = YYEOF; 1634 YYDPRINTF ((stderr, "Now at end of input.\n")); 1635 } 1636 else 1637 { 1638 yytoken = YYTRANSLATE (yychar); 1639 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1640 } 1641 1642 /* If the proper action on seeing token YYTOKEN is to reduce or to 1643 detect an error, take that action. */ 1644 yyn += yytoken; 1645 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1646 goto yydefault; 1647 yyn = yytable[yyn]; 1648 if (yyn <= 0) 1649 { 1650 if (yytable_value_is_error (yyn)) 1651 goto yyerrlab; 1652 yyn = -yyn; 1653 goto yyreduce; 1654 } 1655 1656 /* Count tokens shifted since error; after three, turn off error 1657 status. */ 1658 if (yyerrstatus) 1659 yyerrstatus--; 1660 1661 /* Shift the lookahead token. */ 1662 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1663 1664 /* Discard the shifted token. */ 1665 yychar = YYEMPTY; 1666 1667 yystate = yyn; 1668 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1669 *++yyvsp = yylval; 1670 YY_IGNORE_MAYBE_UNINITIALIZED_END 1671 1672 goto yynewstate; 1673 1674 1675 /*-----------------------------------------------------------. 1676 | yydefault -- do the default action for the current state. | 1677 `-----------------------------------------------------------*/ 1678 yydefault: 1679 yyn = yydefact[yystate]; 1680 if (yyn == 0) 1681 goto yyerrlab; 1682 goto yyreduce; 1683 1684 1685 /*-----------------------------. 1686 | yyreduce -- Do a reduction. | 1687 `-----------------------------*/ 1688 yyreduce: 1689 /* yyn is the number of a rule to reduce with. */ 1690 yylen = yyr2[yyn]; 1691 1692 /* If YYLEN is nonzero, implement the default value of the action: 1693 `$$ = $1'. 1694 1695 Otherwise, the following line sets YYVAL to garbage. 1696 This behavior is undocumented and Bison 1697 users should not rely upon it. Assigning to YYVAL 1698 unconditionally makes the parser a bit smaller, and it avoids a 1699 GCC warning that YYVAL may be used uninitialized. */ 1700 yyval = yyvsp[1-yylen]; 1701 1702 1703 YY_REDUCE_PRINT (yyn); 1704 switch (yyn) 1705 { 1706 case 6: 1707 /* Line 1787 of yacc.c */ 1708 #line 173 "calc.y" 1709 { sp = stack[0]; yyerrok; } 1710 break; 1711 1712 case 8: 1713 /* Line 1787 of yacc.c */ 1714 #line 177 "calc.y" 1715 { 1716 mpz_out_str (stdout, obase, sp); putchar ('\n'); 1717 sp--; 1718 CHECK_EMPTY (); 1719 } 1720 break; 1721 1722 case 9: 1723 /* Line 1787 of yacc.c */ 1724 #line 182 "calc.y" 1725 { 1726 CHECK_VARIABLE ((yyvsp[(1) - (3)].var)); 1727 mpz_swap (variable[(yyvsp[(1) - (3)].var)], sp); 1728 sp--; 1729 CHECK_EMPTY (); 1730 } 1731 break; 1732 1733 case 10: 1734 /* Line 1787 of yacc.c */ 1735 #line 188 "calc.y" 1736 { calc_help (); } 1737 break; 1738 1739 case 11: 1740 /* Line 1787 of yacc.c */ 1741 #line 189 "calc.y" 1742 { ibase = 16; obase = -16; } 1743 break; 1744 1745 case 12: 1746 /* Line 1787 of yacc.c */ 1747 #line 190 "calc.y" 1748 { ibase = 0; obase = 10; } 1749 break; 1750 1751 case 13: 1752 /* Line 1787 of yacc.c */ 1753 #line 191 "calc.y" 1754 { exit (0); } 1755 break; 1756 1757 case 15: 1758 /* Line 1787 of yacc.c */ 1759 #line 198 "calc.y" 1760 { sp--; mpz_add (sp, sp, sp+1); } 1761 break; 1762 1763 case 16: 1764 /* Line 1787 of yacc.c */ 1765 #line 199 "calc.y" 1766 { sp--; mpz_sub (sp, sp, sp+1); } 1767 break; 1768 1769 case 17: 1770 /* Line 1787 of yacc.c */ 1771 #line 200 "calc.y" 1772 { sp--; mpz_mul (sp, sp, sp+1); } 1773 break; 1774 1775 case 18: 1776 /* Line 1787 of yacc.c */ 1777 #line 201 "calc.y" 1778 { sp--; mpz_fdiv_q (sp, sp, sp+1); } 1779 break; 1780 1781 case 19: 1782 /* Line 1787 of yacc.c */ 1783 #line 202 "calc.y" 1784 { sp--; mpz_fdiv_r (sp, sp, sp+1); } 1785 break; 1786 1787 case 20: 1788 /* Line 1787 of yacc.c */ 1789 #line 203 "calc.y" 1790 { CHECK_UI ("Exponent", sp); 1791 sp--; mpz_pow_ui (sp, sp, mpz_get_ui (sp+1)); } 1792 break; 1793 1794 case 21: 1795 /* Line 1787 of yacc.c */ 1796 #line 205 "calc.y" 1797 { CHECK_UI ("Shift count", sp); 1798 sp--; mpz_mul_2exp (sp, sp, mpz_get_ui (sp+1)); } 1799 break; 1800 1801 case 22: 1802 /* Line 1787 of yacc.c */ 1803 #line 207 "calc.y" 1804 { CHECK_UI ("Shift count", sp); 1805 sp--; mpz_fdiv_q_2exp (sp, sp, mpz_get_ui (sp+1)); } 1806 break; 1807 1808 case 23: 1809 /* Line 1787 of yacc.c */ 1810 #line 209 "calc.y" 1811 { CHECK_UI ("Factorial", sp); 1812 mpz_fac_ui (sp, mpz_get_ui (sp)); } 1813 break; 1814 1815 case 24: 1816 /* Line 1787 of yacc.c */ 1817 #line 211 "calc.y" 1818 { mpz_neg (sp, sp); } 1819 break; 1820 1821 case 25: 1822 /* Line 1787 of yacc.c */ 1823 #line 213 "calc.y" 1824 { sp--; mpz_set_ui (sp, mpz_cmp (sp, sp+1) < 0); } 1825 break; 1826 1827 case 26: 1828 /* Line 1787 of yacc.c */ 1829 #line 214 "calc.y" 1830 { sp--; mpz_set_ui (sp, mpz_cmp (sp, sp+1) <= 0); } 1831 break; 1832 1833 case 27: 1834 /* Line 1787 of yacc.c */ 1835 #line 215 "calc.y" 1836 { sp--; mpz_set_ui (sp, mpz_cmp (sp, sp+1) == 0); } 1837 break; 1838 1839 case 28: 1840 /* Line 1787 of yacc.c */ 1841 #line 216 "calc.y" 1842 { sp--; mpz_set_ui (sp, mpz_cmp (sp, sp+1) != 0); } 1843 break; 1844 1845 case 29: 1846 /* Line 1787 of yacc.c */ 1847 #line 217 "calc.y" 1848 { sp--; mpz_set_ui (sp, mpz_cmp (sp, sp+1) >= 0); } 1849 break; 1850 1851 case 30: 1852 /* Line 1787 of yacc.c */ 1853 #line 218 "calc.y" 1854 { sp--; mpz_set_ui (sp, mpz_cmp (sp, sp+1) > 0); } 1855 break; 1856 1857 case 31: 1858 /* Line 1787 of yacc.c */ 1859 #line 220 "calc.y" 1860 { sp--; mpz_set_ui (sp, mpz_sgn (sp) && mpz_sgn (sp+1)); } 1861 break; 1862 1863 case 32: 1864 /* Line 1787 of yacc.c */ 1865 #line 221 "calc.y" 1866 { sp--; mpz_set_ui (sp, mpz_sgn (sp) || mpz_sgn (sp+1)); } 1867 break; 1868 1869 case 33: 1870 /* Line 1787 of yacc.c */ 1871 #line 223 "calc.y" 1872 { mpz_abs (sp, sp); } 1873 break; 1874 1875 case 34: 1876 /* Line 1787 of yacc.c */ 1877 #line 224 "calc.y" 1878 { sp--; CHECK_UI ("Binomial base", sp+1); 1879 mpz_bin_ui (sp, sp, mpz_get_ui (sp+1)); } 1880 break; 1881 1882 case 35: 1883 /* Line 1787 of yacc.c */ 1884 #line 226 "calc.y" 1885 { CHECK_UI ("Fibonacci", sp); 1886 mpz_fib_ui (sp, mpz_get_ui (sp)); } 1887 break; 1888 1889 case 37: 1890 /* Line 1787 of yacc.c */ 1891 #line 229 "calc.y" 1892 { sp--; mpz_set_si (sp, 1893 mpz_kronecker (sp, sp+1)); } 1894 break; 1895 1896 case 39: 1897 /* Line 1787 of yacc.c */ 1898 #line 232 "calc.y" 1899 { CHECK_UI ("Lucas number", sp); 1900 mpz_lucnum_ui (sp, mpz_get_ui (sp)); } 1901 break; 1902 1903 case 40: 1904 /* Line 1787 of yacc.c */ 1905 #line 234 "calc.y" 1906 { mpz_nextprime (sp, sp); } 1907 break; 1908 1909 case 41: 1910 /* Line 1787 of yacc.c */ 1911 #line 235 "calc.y" 1912 { sp -= 2; mpz_powm (sp, sp, sp+1, sp+2); } 1913 break; 1914 1915 case 42: 1916 /* Line 1787 of yacc.c */ 1917 #line 236 "calc.y" 1918 { sp--; CHECK_UI ("Nth-root", sp+1); 1919 mpz_root (sp, sp, mpz_get_ui (sp+1)); } 1920 break; 1921 1922 case 43: 1923 /* Line 1787 of yacc.c */ 1924 #line 238 "calc.y" 1925 { mpz_sqrt (sp, sp); } 1926 break; 1927 1928 case 44: 1929 /* Line 1787 of yacc.c */ 1930 #line 240 "calc.y" 1931 { 1932 sp++; 1933 CHECK_OVERFLOW (); 1934 CHECK_VARIABLE ((yyvsp[(1) - (1)].var)); 1935 mpz_set (sp, variable[(yyvsp[(1) - (1)].var)]); 1936 } 1937 break; 1938 1939 case 45: 1940 /* Line 1787 of yacc.c */ 1941 #line 246 "calc.y" 1942 { 1943 sp++; 1944 CHECK_OVERFLOW (); 1945 if (mpz_set_str (sp, (yyvsp[(1) - (1)].str), ibase) != 0) 1946 { 1947 fprintf (stderr, "Invalid number: %s\n", (yyvsp[(1) - (1)].str)); 1948 YYERROR; 1949 } 1950 } 1951 break; 1952 1953 case 47: 1954 /* Line 1787 of yacc.c */ 1955 #line 258 "calc.y" 1956 { sp--; mpz_gcd (sp, sp, sp+1); } 1957 break; 1958 1959 case 49: 1960 /* Line 1787 of yacc.c */ 1961 #line 262 "calc.y" 1962 { sp--; mpz_lcm (sp, sp, sp+1); } 1963 break; 1964 1965 1966 /* Line 1787 of yacc.c */ 1967 #line 1968 "calc.c" 1968 default: break; 1969 } 1970 /* User semantic actions sometimes alter yychar, and that requires 1971 that yytoken be updated with the new translation. We take the 1972 approach of translating immediately before every use of yytoken. 1973 One alternative is translating here after every semantic action, 1974 but that translation would be missed if the semantic action invokes 1975 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 1976 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 1977 incorrect destructor might then be invoked immediately. In the 1978 case of YYERROR or YYBACKUP, subsequent parser actions might lead 1979 to an incorrect destructor call or verbose syntax error message 1980 before the lookahead is translated. */ 1981 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 1982 1983 YYPOPSTACK (yylen); 1984 yylen = 0; 1985 YY_STACK_PRINT (yyss, yyssp); 1986 1987 *++yyvsp = yyval; 1988 1989 /* Now `shift' the result of the reduction. Determine what state 1990 that goes to, based on the state we popped back to and the rule 1991 number reduced by. */ 1992 1993 yyn = yyr1[yyn]; 1994 1995 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 1996 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 1997 yystate = yytable[yystate]; 1998 else 1999 yystate = yydefgoto[yyn - YYNTOKENS]; 2000 2001 goto yynewstate; 2002 2003 2004 /*------------------------------------. 2005 | yyerrlab -- here on detecting error | 2006 `------------------------------------*/ 2007 yyerrlab: 2008 /* Make sure we have latest lookahead translation. See comments at 2009 user semantic actions for why this is necessary. */ 2010 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); 2011 2012 /* If not already recovering from an error, report this error. */ 2013 if (!yyerrstatus) 2014 { 2015 ++yynerrs; 2016 #if ! YYERROR_VERBOSE 2017 yyerror (YY_("syntax error")); 2018 #else 2019 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 2020 yyssp, yytoken) 2021 { 2022 char const *yymsgp = YY_("syntax error"); 2023 int yysyntax_error_status; 2024 yysyntax_error_status = YYSYNTAX_ERROR; 2025 if (yysyntax_error_status == 0) 2026 yymsgp = yymsg; 2027 else if (yysyntax_error_status == 1) 2028 { 2029 if (yymsg != yymsgbuf) 2030 YYSTACK_FREE (yymsg); 2031 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); 2032 if (!yymsg) 2033 { 2034 yymsg = yymsgbuf; 2035 yymsg_alloc = sizeof yymsgbuf; 2036 yysyntax_error_status = 2; 2037 } 2038 else 2039 { 2040 yysyntax_error_status = YYSYNTAX_ERROR; 2041 yymsgp = yymsg; 2042 } 2043 } 2044 yyerror (yymsgp); 2045 if (yysyntax_error_status == 2) 2046 goto yyexhaustedlab; 2047 } 2048 # undef YYSYNTAX_ERROR 2049 #endif 2050 } 2051 2052 2053 2054 if (yyerrstatus == 3) 2055 { 2056 /* If just tried and failed to reuse lookahead token after an 2057 error, discard it. */ 2058 2059 if (yychar <= YYEOF) 2060 { 2061 /* Return failure if at end of input. */ 2062 if (yychar == YYEOF) 2063 YYABORT; 2064 } 2065 else 2066 { 2067 yydestruct ("Error: discarding", 2068 yytoken, &yylval); 2069 yychar = YYEMPTY; 2070 } 2071 } 2072 2073 /* Else will try to reuse lookahead token after shifting the error 2074 token. */ 2075 goto yyerrlab1; 2076 2077 2078 /*---------------------------------------------------. 2079 | yyerrorlab -- error raised explicitly by YYERROR. | 2080 `---------------------------------------------------*/ 2081 yyerrorlab: 2082 2083 /* Pacify compilers like GCC when the user code never invokes 2084 YYERROR and the label yyerrorlab therefore never appears in user 2085 code. */ 2086 if (/*CONSTCOND*/ 0) 2087 goto yyerrorlab; 2088 2089 /* Do not reclaim the symbols of the rule which action triggered 2090 this YYERROR. */ 2091 YYPOPSTACK (yylen); 2092 yylen = 0; 2093 YY_STACK_PRINT (yyss, yyssp); 2094 yystate = *yyssp; 2095 goto yyerrlab1; 2096 2097 2098 /*-------------------------------------------------------------. 2099 | yyerrlab1 -- common code for both syntax error and YYERROR. | 2100 `-------------------------------------------------------------*/ 2101 yyerrlab1: 2102 yyerrstatus = 3; /* Each real token shifted decrements this. */ 2103 2104 for (;;) 2105 { 2106 yyn = yypact[yystate]; 2107 if (!yypact_value_is_default (yyn)) 2108 { 2109 yyn += YYTERROR; 2110 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 2111 { 2112 yyn = yytable[yyn]; 2113 if (0 < yyn) 2114 break; 2115 } 2116 } 2117 2118 /* Pop the current state because it cannot handle the error token. */ 2119 if (yyssp == yyss) 2120 YYABORT; 2121 2122 2123 yydestruct ("Error: popping", 2124 yystos[yystate], yyvsp); 2125 YYPOPSTACK (1); 2126 yystate = *yyssp; 2127 YY_STACK_PRINT (yyss, yyssp); 2128 } 2129 2130 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 2131 *++yyvsp = yylval; 2132 YY_IGNORE_MAYBE_UNINITIALIZED_END 2133 2134 2135 /* Shift the error token. */ 2136 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 2137 2138 yystate = yyn; 2139 goto yynewstate; 2140 2141 2142 /*-------------------------------------. 2143 | yyacceptlab -- YYACCEPT comes here. | 2144 `-------------------------------------*/ 2145 yyacceptlab: 2146 yyresult = 0; 2147 goto yyreturn; 2148 2149 /*-----------------------------------. 2150 | yyabortlab -- YYABORT comes here. | 2151 `-----------------------------------*/ 2152 yyabortlab: 2153 yyresult = 1; 2154 goto yyreturn; 2155 2156 #if !defined yyoverflow || YYERROR_VERBOSE 2157 /*-------------------------------------------------. 2158 | yyexhaustedlab -- memory exhaustion comes here. | 2159 `-------------------------------------------------*/ 2160 yyexhaustedlab: 2161 yyerror (YY_("memory exhausted")); 2162 yyresult = 2; 2163 /* Fall through. */ 2164 #endif 2165 2166 yyreturn: 2167 if (yychar != YYEMPTY) 2168 { 2169 /* Make sure we have latest lookahead translation. See comments at 2170 user semantic actions for why this is necessary. */ 2171 yytoken = YYTRANSLATE (yychar); 2172 yydestruct ("Cleanup: discarding lookahead", 2173 yytoken, &yylval); 2174 } 2175 /* Do not reclaim the symbols of the rule which action triggered 2176 this YYABORT or YYACCEPT. */ 2177 YYPOPSTACK (yylen); 2178 YY_STACK_PRINT (yyss, yyssp); 2179 while (yyssp != yyss) 2180 { 2181 yydestruct ("Cleanup: popping", 2182 yystos[*yyssp], yyvsp); 2183 YYPOPSTACK (1); 2184 } 2185 #ifndef yyoverflow 2186 if (yyss != yyssa) 2187 YYSTACK_FREE (yyss); 2188 #endif 2189 #if YYERROR_VERBOSE 2190 if (yymsg != yymsgbuf) 2191 YYSTACK_FREE (yymsg); 2192 #endif 2193 /* Make sure YYID is used. */ 2194 return YYID (yyresult); 2195 } 2196 2197 2198 /* Line 2050 of yacc.c */ 2199 #line 264 "calc.y" 2200 2201 2202 yyerror (char *s) 2203 { 2204 fprintf (stderr, "%s\n", s); 2205 } 2206 2207 int calc_option_readline = -1; 2208 2209 int 2210 main (int argc, char *argv[]) 2211 { 2212 int i; 2213 2214 for (i = 1; i < argc; i++) 2215 { 2216 if (strcmp (argv[i], "--readline") == 0) 2217 calc_option_readline = 1; 2218 else if (strcmp (argv[i], "--noreadline") == 0) 2219 calc_option_readline = 0; 2220 else if (strcmp (argv[i], "--help") == 0) 2221 { 2222 printf ("Usage: calc [--option]...\n"); 2223 printf (" --readline use readline\n"); 2224 printf (" --noreadline don't use readline\n"); 2225 printf (" --help this message\n"); 2226 printf ("Readline is only available when compiled in,\n"); 2227 printf ("and in that case it's the default on a tty.\n"); 2228 exit (0); 2229 } 2230 else 2231 { 2232 fprintf (stderr, "Unrecognised option: %s\n", argv[i]); 2233 exit (1); 2234 } 2235 } 2236 2237 #if WITH_READLINE 2238 calc_init_readline (); 2239 #else 2240 if (calc_option_readline == 1) 2241 { 2242 fprintf (stderr, "Readline support not available\n"); 2243 exit (1); 2244 } 2245 #endif 2246 2247 for (i = 0; i < numberof (variable); i++) 2248 mpz_init (variable[i]); 2249 2250 for (i = 0; i < numberof (stack); i++) 2251 mpz_init (stack[i]); 2252 2253 return yyparse (); 2254 } 2255
Indexes created Sat Mar 21 00:23:06 UTC 2026