1/* A Bison parser, made by GNU Bison 1.875. */ 2 3/* Skeleton parser for Yacc-like parsing with Bison, 4 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 2, or (at your option) 9 any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 59 Temple Place - Suite 330, 19 Boston, MA 02111-1307, USA. */ 20 21/* As a special exception, when this file is copied by Bison into a 22 Bison output file, you may use that output file without restriction. 23 This special exception was added by the Free Software Foundation 24 in version 1.24 of Bison. */ 25 26/* Written by Richard Stallman by simplifying the original so called 27 ``semantic'' parser. */ 28 29/* All symbols defined below should begin with yy or YY, to avoid 30 infringing on user name space. This should be done even for local 31 variables, as they might otherwise be expanded by user macros. 32 There are some unavoidable exceptions within include files to 33 define necessary library symbols; they are noted "INFRINGES ON 34 USER NAME SPACE" below. */ 35 36/* Identify Bison output. */ 37#define YYBISON 1 38 39/* Skeleton name. */ 40#define YYSKELETON_NAME "yacc.c" 41 42/* Pure parsers. */ 43#define YYPURE 0 44 45/* Using locations. */ 46#define YYLSP_NEEDED 0 47 48 49 50/* Tokens. */ 51#ifndef YYTOKENTYPE 52# define YYTOKENTYPE 53 /* Put the tokens into the symbol table, so that GDB and other debuggers 54 know about them. */ 55 enum yytokentype { 56 INT = 258, 57 HEX = 259, 58 ERROR = 260, 59 UINT = 261, 60 M2_TRUE = 262, 61 M2_FALSE = 263, 62 CHAR = 264, 63 FLOAT = 265, 64 STRING = 266, 65 NAME = 267, 66 BLOCKNAME = 268, 67 IDENT = 269, 68 VARNAME = 270, 69 TYPENAME = 271, 70 SIZE = 272, 71 CAP = 273, 72 ORD = 274, 73 HIGH = 275, 74 ABS = 276, 75 MIN_FUNC = 277, 76 MAX_FUNC = 278, 77 FLOAT_FUNC = 279, 78 VAL = 280, 79 CHR = 281, 80 ODD = 282, 81 TRUNC = 283, 82 INC = 284, 83 DEC = 285, 84 INCL = 286, 85 EXCL = 287, 86 COLONCOLON = 288, 87 INTERNAL_VAR = 289, 88 ABOVE_COMMA = 290, 89 ASSIGN = 291, 90 IN = 292, 91 NOTEQUAL = 293, 92 GEQ = 294, 93 LEQ = 295, 94 OROR = 296, 95 LOGICAL_AND = 297, 96 MOD = 298, 97 DIV = 299, 98 UNARY = 300, 99 DOT = 301, 100 NOT = 302, 101 QID = 303 102 }; 103#endif 104#define INT 258 105#define HEX 259 106#define ERROR 260 107#define UINT 261 108#define M2_TRUE 262 109#define M2_FALSE 263 110#define CHAR 264 111#define FLOAT 265 112#define STRING 266 113#define NAME 267 114#define BLOCKNAME 268 115#define IDENT 269 116#define VARNAME 270 117#define TYPENAME 271 118#define SIZE 272 119#define CAP 273 120#define ORD 274 121#define HIGH 275 122#define ABS 276 123#define MIN_FUNC 277 124#define MAX_FUNC 278 125#define FLOAT_FUNC 279 126#define VAL 280 127#define CHR 281 128#define ODD 282 129#define TRUNC 283 130#define INC 284 131#define DEC 285 132#define INCL 286 133#define EXCL 287 134#define COLONCOLON 288 135#define INTERNAL_VAR 289 136#define ABOVE_COMMA 290 137#define ASSIGN 291 138#define IN 292 139#define NOTEQUAL 293 140#define GEQ 294 141#define LEQ 295 142#define OROR 296 143#define LOGICAL_AND 297 144#define MOD 298 145#define DIV 299 146#define UNARY 300 147#define DOT 301 148#define NOT 302 149#define QID 303 150 151 152 153 154/* Copy the first part of user declarations. */ 155#line 41 "m2-exp.y" 156 157 158#include "defs.h" 159#include "gdb_string.h" 160#include "expression.h" 161#include "language.h" 162#include "value.h" 163#include "parser-defs.h" 164#include "m2-lang.h" 165#include "bfd.h" /* Required by objfiles.h. */ 166#include "symfile.h" /* Required by objfiles.h. */ 167#include "objfiles.h" /* For have_full_symbols and have_partial_symbols */ 168#include "block.h" 169 170/* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc), 171 as well as gratuitiously global symbol names, so we can have multiple 172 yacc generated parsers in gdb. Note that these are only the variables 173 produced by yacc. If other parser generators (bison, byacc, etc) produce 174 additional global names that conflict at link time, then those parser 175 generators need to be fixed instead of adding those names to this list. */ 176 177#define yymaxdepth m2_maxdepth 178#define yyparse m2_parse 179#define yylex m2_lex 180#define yyerror m2_error 181#define yylval m2_lval 182#define yychar m2_char 183#define yydebug m2_debug 184#define yypact m2_pact 185#define yyr1 m2_r1 186#define yyr2 m2_r2 187#define yydef m2_def 188#define yychk m2_chk 189#define yypgo m2_pgo 190#define yyact m2_act 191#define yyexca m2_exca 192#define yyerrflag m2_errflag 193#define yynerrs m2_nerrs 194#define yyps m2_ps 195#define yypv m2_pv 196#define yys m2_s 197#define yy_yys m2_yys 198#define yystate m2_state 199#define yytmp m2_tmp 200#define yyv m2_v 201#define yy_yyv m2_yyv 202#define yyval m2_val 203#define yylloc m2_lloc 204#define yyreds m2_reds /* With YYDEBUG defined */ 205#define yytoks m2_toks /* With YYDEBUG defined */ 206#define yyname m2_name /* With YYDEBUG defined */ 207#define yyrule m2_rule /* With YYDEBUG defined */ 208#define yylhs m2_yylhs 209#define yylen m2_yylen 210#define yydefred m2_yydefred 211#define yydgoto m2_yydgoto 212#define yysindex m2_yysindex 213#define yyrindex m2_yyrindex 214#define yygindex m2_yygindex 215#define yytable m2_yytable 216#define yycheck m2_yycheck 217 218#ifndef YYDEBUG 219#define YYDEBUG 1 /* Default to yydebug support */ 220#endif 221 222#define YYFPRINTF parser_fprintf 223 224int yyparse (void); 225 226static int yylex (void); 227 228void yyerror (char *); 229 230#if 0 231static char *make_qualname (char *, char *); 232#endif 233 234static int parse_number (int); 235 236/* The sign of the number being parsed. */ 237static int number_sign = 1; 238 239/* The block that the module specified by the qualifer on an identifer is 240 contained in, */ 241#if 0 242static struct block *modblock=0; 243#endif 244 245 246 247/* Enabling traces. */ 248#ifndef YYDEBUG 249# define YYDEBUG 0 250#endif 251 252/* Enabling verbose error messages. */ 253#ifdef YYERROR_VERBOSE 254# undef YYERROR_VERBOSE 255# define YYERROR_VERBOSE 1 256#else 257# define YYERROR_VERBOSE 0 258#endif 259 260#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) 261#line 137 "m2-exp.y" 262typedef union YYSTYPE { 263 LONGEST lval; 264 ULONGEST ulval; 265 DOUBLEST dval; 266 struct symbol *sym; 267 struct type *tval; 268 struct stoken sval; 269 int voidval; 270 struct block *bval; 271 enum exp_opcode opcode; 272 struct internalvar *ivar; 273 274 struct type **tvec; 275 int *ivec; 276 } YYSTYPE; 277/* Line 191 of yacc.c. */ 278# define yystype YYSTYPE /* obsolescent; will be withdrawn */ 279# define YYSTYPE_IS_DECLARED 1 280# define YYSTYPE_IS_TRIVIAL 1 281#endif 282 283 284 285/* Copy the second part of user declarations. */ 286 287 288/* Line 214 of yacc.c. */ 289 290#if ! defined (yyoverflow) || YYERROR_VERBOSE 291 292/* The parser invokes alloca or xmalloc; define the necessary symbols. */ 293 294# if YYSTACK_USE_ALLOCA 295# define YYSTACK_ALLOC alloca 296# else 297# ifndef YYSTACK_USE_ALLOCA 298# if defined (alloca) || defined (_ALLOCA_H) 299# define YYSTACK_ALLOC alloca 300# else 301# ifdef __GNUC__ 302# define YYSTACK_ALLOC __builtin_alloca 303# endif 304# endif 305# endif 306# endif 307 308# ifdef YYSTACK_ALLOC 309 /* Pacify GCC's `empty if-body' warning. */ 310# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) 311# else 312# if defined (__STDC__) || defined (__cplusplus) 313# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 314# define YYSIZE_T size_t 315# endif 316# define YYSTACK_ALLOC xmalloc 317# define YYSTACK_FREE free 318# endif 319#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ 320 321 322#if (! defined (yyoverflow) \ 323 && (! defined (__cplusplus) \ 324 || (YYSTYPE_IS_TRIVIAL))) 325 326/* A type that is properly aligned for any stack member. */ 327union yyalloc 328{ 329 short yyss; 330 YYSTYPE yyvs; 331 }; 332 333/* The size of the maximum gap between one aligned stack and the next. */ 334# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 335 336/* The size of an array large to enough to hold all stacks, each with 337 N elements. */ 338# define YYSTACK_BYTES(N) \ 339 ((N) * (sizeof (short) + sizeof (YYSTYPE)) \ 340 + YYSTACK_GAP_MAXIMUM) 341 342/* Copy COUNT objects from FROM to TO. The source and destination do 343 not overlap. */ 344# ifndef YYCOPY 345# if 1 < __GNUC__ 346# define YYCOPY(To, From, Count) \ 347 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 348# else 349# define YYCOPY(To, From, Count) \ 350 do \ 351 { \ 352 register YYSIZE_T yyi; \ 353 for (yyi = 0; yyi < (Count); yyi++) \ 354 (To)[yyi] = (From)[yyi]; \ 355 } \ 356 while (0) 357# endif 358# endif 359 360/* Relocate STACK from its old location to the new one. The 361 local variables YYSIZE and YYSTACKSIZE give the old and new number of 362 elements in the stack, and YYPTR gives the new location of the 363 stack. Advance YYPTR to a properly aligned location for the next 364 stack. */ 365# define YYSTACK_RELOCATE(Stack) \ 366 do \ 367 { \ 368 YYSIZE_T yynewbytes; \ 369 YYCOPY (&yyptr->Stack, Stack, yysize); \ 370 Stack = &yyptr->Stack; \ 371 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 372 yyptr += yynewbytes / sizeof (*yyptr); \ 373 } \ 374 while (0) 375 376#endif 377 378#if defined (__STDC__) || defined (__cplusplus) 379 typedef signed char yysigned_char; 380#else 381 typedef short yysigned_char; 382#endif 383 384/* YYFINAL -- State number of the termination state. */ 385#define YYFINAL 67 386/* YYLAST -- Last index in YYTABLE. */ 387#define YYLAST 848 388 389/* YYNTOKENS -- Number of terminals. */ 390#define YYNTOKENS 68 391/* YYNNTS -- Number of nonterminals. */ 392#define YYNNTS 15 393/* YYNRULES -- Number of rules. */ 394#define YYNRULES 80 395/* YYNRULES -- Number of states. */ 396#define YYNSTATES 181 397 398/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 399#define YYUNDEFTOK 2 400#define YYMAXUTOK 303 401 402#define YYTRANSLATE(YYX) \ 403 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 404 405/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 406static const unsigned char yytranslate[] = 407{ 408 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 409 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 410 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 411 2, 2, 2, 2, 2, 41, 2, 2, 47, 2, 412 59, 64, 52, 50, 35, 51, 2, 53, 2, 2, 413 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 414 38, 40, 39, 2, 49, 2, 2, 2, 2, 2, 415 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 416 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 417 2, 58, 2, 67, 57, 2, 2, 2, 2, 2, 418 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 419 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 420 2, 2, 2, 65, 2, 66, 61, 2, 2, 2, 421 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 422 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 423 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 424 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 425 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 426 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 427 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 428 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 429 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 430 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 431 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 432 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 433 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 434 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 435 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 436 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 437 36, 37, 42, 43, 44, 45, 46, 48, 54, 55, 438 56, 60, 62, 63 439}; 440 441#if YYDEBUG 442/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 443 YYRHS. */ 444static const unsigned short yyprhs[] = 445{ 446 0, 0, 3, 5, 7, 9, 12, 13, 17, 20, 447 23, 25, 27, 32, 37, 42, 47, 52, 57, 62, 448 69, 74, 79, 84, 87, 92, 99, 104, 111, 115, 449 117, 121, 128, 135, 139, 144, 145, 151, 152, 158, 450 159, 161, 165, 167, 171, 176, 181, 185, 189, 193, 451 197, 201, 205, 209, 213, 217, 221, 225, 229, 233, 452 237, 241, 245, 249, 253, 255, 257, 259, 261, 263, 453 265, 267, 272, 274, 276, 278, 282, 284, 286, 290, 454 292 455}; 456 457/* YYRHS -- A `-1'-separated list of the rules' RHS. */ 458static const yysigned_char yyrhs[] = 459{ 460 69, 0, -1, 71, -1, 70, -1, 82, -1, 71, 461 57, -1, -1, 51, 72, 71, -1, 50, 71, -1, 462 73, 71, -1, 62, -1, 61, -1, 18, 59, 71, 463 64, -1, 19, 59, 71, 64, -1, 21, 59, 71, 464 64, -1, 20, 59, 71, 64, -1, 22, 59, 82, 465 64, -1, 23, 59, 82, 64, -1, 24, 59, 71, 466 64, -1, 25, 59, 82, 35, 71, 64, -1, 26, 467 59, 71, 64, -1, 27, 59, 71, 64, -1, 28, 468 59, 71, 64, -1, 17, 71, -1, 29, 59, 71, 469 64, -1, 29, 59, 71, 35, 71, 64, -1, 30, 470 59, 71, 64, -1, 30, 59, 71, 35, 71, 64, 471 -1, 71, 60, 12, -1, 74, -1, 71, 42, 74, 472 -1, 31, 59, 71, 35, 71, 64, -1, 32, 59, 473 71, 35, 71, 64, -1, 65, 77, 66, -1, 82, 474 65, 77, 66, -1, -1, 71, 58, 75, 78, 67, 475 -1, -1, 71, 59, 76, 77, 64, -1, -1, 71, 476 -1, 77, 35, 71, -1, 71, -1, 78, 35, 71, 477 -1, 65, 82, 66, 71, -1, 82, 59, 71, 64, 478 -1, 59, 71, 64, -1, 71, 49, 71, -1, 71, 479 52, 71, -1, 71, 53, 71, -1, 71, 55, 71, 480 -1, 71, 54, 71, -1, 71, 50, 71, -1, 71, 481 51, 71, -1, 71, 40, 71, -1, 71, 43, 71, 482 -1, 71, 41, 71, -1, 71, 45, 71, -1, 71, 483 44, 71, -1, 71, 38, 71, -1, 71, 39, 71, 484 -1, 71, 48, 71, -1, 71, 46, 71, -1, 71, 485 37, 71, -1, 7, -1, 8, -1, 3, -1, 6, 486 -1, 9, -1, 10, -1, 81, -1, 17, 59, 82, 487 64, -1, 11, -1, 80, -1, 13, -1, 79, 33, 488 13, -1, 80, -1, 34, -1, 79, 33, 12, -1, 489 12, -1, 16, -1 490}; 491 492/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 493static const unsigned short yyrline[] = 494{ 495 0, 205, 205, 206, 209, 218, 223, 222, 229, 233, 496 237, 238, 241, 245, 249, 253, 257, 263, 269, 273, 497 279, 283, 287, 291, 296, 300, 306, 310, 316, 322, 498 325, 329, 333, 337, 339, 349, 345, 359, 356, 366, 499 369, 373, 378, 383, 388, 394, 400, 408, 412, 416, 500 420, 424, 428, 432, 436, 440, 442, 446, 450, 454, 501 458, 462, 466, 470, 477, 483, 489, 496, 505, 513, 502 520, 523, 530, 537, 541, 550, 562, 570, 574, 590, 503 641 504}; 505#endif 506 507#if YYDEBUG || YYERROR_VERBOSE 508/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 509 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 510static const char *const yytname[] = 511{ 512 "$end", "error", "$undefined", "INT", "HEX", "ERROR", "UINT", "M2_TRUE", 513 "M2_FALSE", "CHAR", "FLOAT", "STRING", "NAME", "BLOCKNAME", "IDENT", 514 "VARNAME", "TYPENAME", "SIZE", "CAP", "ORD", "HIGH", "ABS", "MIN_FUNC", 515 "MAX_FUNC", "FLOAT_FUNC", "VAL", "CHR", "ODD", "TRUNC", "INC", "DEC", 516 "INCL", "EXCL", "COLONCOLON", "INTERNAL_VAR", "','", "ABOVE_COMMA", 517 "ASSIGN", "'<'", "'>'", "'='", "'#'", "IN", "NOTEQUAL", "GEQ", "LEQ", 518 "OROR", "'&'", "LOGICAL_AND", "'@'", "'+'", "'-'", "'*'", "'/'", "MOD", 519 "DIV", "UNARY", "'^'", "'['", "'('", "DOT", "'~'", "NOT", "QID", "')'", 520 "'{'", "'}'", "']'", "$accept", "start", "type_exp", "exp", "@1", 521 "not_exp", "set", "@2", "@3", "arglist", "non_empty_arglist", "block", 522 "fblock", "variable", "type", 0 523}; 524#endif 525 526# ifdef YYPRINT 527/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 528 token YYLEX-NUM. */ 529static const unsigned short yytoknum[] = 530{ 531 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 532 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 533 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 534 285, 286, 287, 288, 289, 44, 290, 291, 60, 62, 535 61, 35, 292, 293, 294, 295, 296, 38, 297, 64, 536 43, 45, 42, 47, 298, 299, 300, 94, 91, 40, 537 301, 126, 302, 303, 41, 123, 125, 93 538}; 539# endif 540 541/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 542static const unsigned char yyr1[] = 543{ 544 0, 68, 69, 69, 70, 71, 72, 71, 71, 71, 545 73, 73, 71, 71, 71, 71, 71, 71, 71, 71, 546 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 547 71, 71, 71, 74, 74, 75, 71, 76, 71, 77, 548 77, 77, 78, 78, 71, 71, 71, 71, 71, 71, 549 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 550 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 551 71, 71, 71, 79, 80, 80, 81, 81, 81, 81, 552 82 553}; 554 555/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 556static const unsigned char yyr2[] = 557{ 558 0, 2, 1, 1, 1, 2, 0, 3, 2, 2, 559 1, 1, 4, 4, 4, 4, 4, 4, 4, 6, 560 4, 4, 4, 2, 4, 6, 4, 6, 3, 1, 561 3, 6, 6, 3, 4, 0, 5, 0, 5, 0, 562 1, 3, 1, 3, 4, 4, 3, 3, 3, 3, 563 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 564 3, 3, 3, 3, 1, 1, 1, 1, 1, 1, 565 1, 4, 1, 1, 1, 3, 1, 1, 3, 1, 566 1 567}; 568 569/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state 570 STATE-NUM when YYTABLE doesn't specify something else to do. Zero 571 means the default is an error. */ 572static const unsigned char yydefact[] = 573{ 574 0, 66, 67, 64, 65, 68, 69, 72, 79, 74, 575 80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 576 0, 0, 0, 0, 0, 0, 0, 77, 0, 6, 577 0, 11, 10, 39, 0, 3, 2, 0, 29, 0, 578 76, 70, 4, 0, 23, 0, 0, 0, 0, 0, 579 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 580 0, 8, 0, 0, 40, 0, 0, 1, 0, 0, 581 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 582 0, 0, 0, 0, 0, 0, 5, 35, 37, 0, 583 9, 0, 0, 39, 0, 0, 0, 0, 0, 0, 584 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 585 7, 46, 0, 33, 0, 63, 59, 60, 54, 56, 586 39, 30, 0, 55, 58, 57, 62, 61, 47, 52, 587 53, 48, 49, 51, 50, 0, 39, 28, 78, 75, 588 0, 0, 71, 12, 13, 15, 14, 16, 17, 18, 589 0, 20, 21, 22, 0, 24, 0, 26, 0, 0, 590 41, 44, 42, 0, 0, 45, 34, 0, 0, 0, 591 0, 0, 0, 36, 38, 19, 25, 27, 31, 32, 592 43 593}; 594 595/* YYDEFGOTO[NTERM-NUM]. */ 596static const short yydefgoto[] = 597{ 598 -1, 34, 35, 64, 62, 37, 38, 135, 136, 65, 599 163, 39, 40, 41, 45 600}; 601 602/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 603 STATE-NUM. */ 604#define YYPACT_NINF -92 605static const short yypact[] = 606{ 607 157, -92, -92, -92, -92, -92, -92, -92, -92, -92, 608 -92, 217, -53, -27, -18, -17, -8, 2, 8, 14, 609 28, 29, 30, 31, 32, 34, 35, -92, 157, -92, 610 157, -92, -92, 157, 44, -92, 744, 157, -92, 62, 611 64, -92, -34, 157, 6, -34, 157, 157, 157, 157, 612 13, 13, 157, 13, 157, 157, 157, 157, 157, 157, 613 157, 6, 157, 79, 744, -30, -39, -92, 157, 157, 614 157, 157, 157, -15, 157, 157, 157, 157, 157, 157, 615 157, 157, 157, 157, 157, 157, -92, -92, -92, 86, 616 6, -4, 157, 157, -25, 302, 330, 358, 386, 36, 617 37, 414, 67, 442, 470, 498, 246, 274, 694, 720, 618 6, -92, 157, -92, 157, 768, -36, -36, -36, -36, 619 157, -92, 40, -36, -36, -36, 144, 203, 779, 788, 620 788, 6, 6, 6, 6, 157, 157, -92, -92, -92, 621 526, -28, -92, -92, -92, -92, -92, -92, -92, -92, 622 157, -92, -92, -92, 157, -92, 157, -92, 157, 157, 623 744, 6, 744, -32, -31, -92, -92, 554, 582, 610, 624 638, 666, 157, -92, -92, -92, -92, -92, -92, -92, 625 744 626}; 627 628/* YYPGOTO[NTERM-NUM]. */ 629static const yysigned_char yypgoto[] = 630{ 631 -92, -92, -92, 0, -92, -92, 26, -92, -92, -91, 632 -92, -92, -92, -92, 53 633}; 634 635/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 636 positive, shift that token. If negative, reduce the rule which 637 number is the opposite. If zero, do what YYDEFACT says. 638 If YYTABLE_NINF, syntax error. */ 639#define YYTABLE_NINF -74 640static const short yytable[] = 641{ 642 36, 10, 141, 172, 112, 112, 46, 112, 138, 139, 643 77, 44, 78, 79, 80, 81, 82, 83, 84, 85, 644 92, 86, 87, 88, 89, 92, 93, 114, 61, 10, 645 63, 93, 47, 174, 92, 173, 113, 90, 166, 142, 646 93, 48, 49, 63, 67, 164, 95, 96, 97, 98, 647 120, 50, 101, 42, 103, 104, 105, 106, 107, 108, 648 109, 51, 110, 86, 87, 88, 89, 52, 115, 116, 649 117, 118, 119, 53, 123, 124, 125, 126, 127, 128, 650 129, 130, 131, 132, 133, 134, 66, 54, 55, 56, 651 57, 58, 140, 59, 60, 91, 94, -73, 137, 121, 652 147, 148, 150, 99, 100, 93, 102, 0, 0, 0, 653 0, 0, 160, 0, 161, 0, 68, 69, 70, 71, 654 72, 73, 74, 75, 76, 77, 122, 78, 79, 80, 655 81, 82, 83, 84, 85, 162, 86, 87, 88, 89, 656 0, 0, 0, 111, 0, 0, 0, 0, 0, 0, 657 167, 0, 0, 0, 168, 0, 169, 0, 170, 171, 658 1, 0, 0, 2, 3, 4, 5, 6, 7, 8, 659 9, 0, 180, 10, 11, 12, 13, 14, 15, 16, 660 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 661 0, 27, 78, 79, 80, 81, 82, 83, 84, 85, 662 0, 86, 87, 88, 89, 0, 0, 28, 29, 0, 663 0, 0, 0, 0, 0, 0, 30, 0, 31, 32, 664 1, 0, 33, 2, 3, 4, 5, 6, 7, 8, 665 9, 0, 0, 10, 11, 12, 13, 14, 15, 16, 666 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 667 0, 27, 79, 80, 81, 82, 83, 84, 85, 0, 668 86, 87, 88, 89, 0, 0, 0, 28, 29, 0, 669 0, 0, 0, 0, 0, 0, 43, 0, 31, 32, 670 0, 154, 33, 68, 69, 70, 71, 72, 73, 74, 671 75, 76, 77, 0, 78, 79, 80, 81, 82, 83, 672 84, 85, 0, 86, 87, 88, 89, 0, 0, 156, 673 155, 68, 69, 70, 71, 72, 73, 74, 75, 76, 674 77, 0, 78, 79, 80, 81, 82, 83, 84, 85, 675 0, 86, 87, 88, 89, 0, 0, 0, 157, 68, 676 69, 70, 71, 72, 73, 74, 75, 76, 77, 0, 677 78, 79, 80, 81, 82, 83, 84, 85, 0, 86, 678 87, 88, 89, 0, 0, 0, 143, 68, 69, 70, 679 71, 72, 73, 74, 75, 76, 77, 0, 78, 79, 680 80, 81, 82, 83, 84, 85, 0, 86, 87, 88, 681 89, 0, 0, 0, 144, 68, 69, 70, 71, 72, 682 73, 74, 75, 76, 77, 0, 78, 79, 80, 81, 683 82, 83, 84, 85, 0, 86, 87, 88, 89, 0, 684 0, 0, 145, 68, 69, 70, 71, 72, 73, 74, 685 75, 76, 77, 0, 78, 79, 80, 81, 82, 83, 686 84, 85, 0, 86, 87, 88, 89, 0, 0, 0, 687 146, 68, 69, 70, 71, 72, 73, 74, 75, 76, 688 77, 0, 78, 79, 80, 81, 82, 83, 84, 85, 689 0, 86, 87, 88, 89, 0, 0, 0, 149, 68, 690 69, 70, 71, 72, 73, 74, 75, 76, 77, 0, 691 78, 79, 80, 81, 82, 83, 84, 85, 0, 86, 692 87, 88, 89, 0, 0, 0, 151, 68, 69, 70, 693 71, 72, 73, 74, 75, 76, 77, 0, 78, 79, 694 80, 81, 82, 83, 84, 85, 0, 86, 87, 88, 695 89, 0, 0, 0, 152, 68, 69, 70, 71, 72, 696 73, 74, 75, 76, 77, 0, 78, 79, 80, 81, 697 82, 83, 84, 85, 0, 86, 87, 88, 89, 0, 698 0, 0, 153, 68, 69, 70, 71, 72, 73, 74, 699 75, 76, 77, 0, 78, 79, 80, 81, 82, 83, 700 84, 85, 0, 86, 87, 88, 89, 0, 0, 0, 701 165, 68, 69, 70, 71, 72, 73, 74, 75, 76, 702 77, 0, 78, 79, 80, 81, 82, 83, 84, 85, 703 0, 86, 87, 88, 89, 0, 0, 0, 175, 68, 704 69, 70, 71, 72, 73, 74, 75, 76, 77, 0, 705 78, 79, 80, 81, 82, 83, 84, 85, 0, 86, 706 87, 88, 89, 0, 0, 0, 176, 68, 69, 70, 707 71, 72, 73, 74, 75, 76, 77, 0, 78, 79, 708 80, 81, 82, 83, 84, 85, 0, 86, 87, 88, 709 89, 0, 0, 0, 177, 68, 69, 70, 71, 72, 710 73, 74, 75, 76, 77, 0, 78, 79, 80, 81, 711 82, 83, 84, 85, 0, 86, 87, 88, 89, 0, 712 0, 0, 178, 68, 69, 70, 71, 72, 73, 74, 713 75, 76, 77, 0, 78, 79, 80, 81, 82, 83, 714 84, 85, 0, 86, 87, 88, 89, 0, 0, 158, 715 179, 68, 69, 70, 71, 72, 73, 74, 75, 76, 716 77, 0, 78, 79, 80, 81, 82, 83, 84, 85, 717 0, 86, 87, 88, 89, 159, 0, 68, 69, 70, 718 71, 72, 73, 74, 75, 76, 77, 0, 78, 79, 719 80, 81, 82, 83, 84, 85, 0, 86, 87, 88, 720 89, 68, 69, 70, 71, 72, 73, 74, 75, 76, 721 77, 0, 78, 79, 80, 81, 82, 83, 84, 85, 722 0, 86, 87, 88, 89, -74, 69, 70, 71, 72, 723 73, 74, 75, 76, 77, 0, 78, 79, 80, 81, 724 82, 83, 84, 85, 0, 86, 87, 88, 89, 80, 725 81, 82, 83, 84, 85, 0, 86, 87, 88, 89, 726 82, 83, 84, 85, 0, 86, 87, 88, 89 727}; 728 729static const short yycheck[] = 730{ 731 0, 16, 93, 35, 35, 35, 59, 35, 12, 13, 732 46, 11, 48, 49, 50, 51, 52, 53, 54, 55, 733 59, 57, 58, 59, 60, 59, 65, 66, 28, 16, 734 30, 65, 59, 64, 59, 67, 66, 37, 66, 64, 735 65, 59, 59, 43, 0, 136, 46, 47, 48, 49, 736 65, 59, 52, 0, 54, 55, 56, 57, 58, 59, 737 60, 59, 62, 57, 58, 59, 60, 59, 68, 69, 738 70, 71, 72, 59, 74, 75, 76, 77, 78, 79, 739 80, 81, 82, 83, 84, 85, 33, 59, 59, 59, 740 59, 59, 92, 59, 59, 33, 43, 33, 12, 73, 741 64, 64, 35, 50, 51, 65, 53, -1, -1, -1, 742 -1, -1, 112, -1, 114, -1, 37, 38, 39, 40, 743 41, 42, 43, 44, 45, 46, 73, 48, 49, 50, 744 51, 52, 53, 54, 55, 135, 57, 58, 59, 60, 745 -1, -1, -1, 64, -1, -1, -1, -1, -1, -1, 746 150, -1, -1, -1, 154, -1, 156, -1, 158, 159, 747 3, -1, -1, 6, 7, 8, 9, 10, 11, 12, 748 13, -1, 172, 16, 17, 18, 19, 20, 21, 22, 749 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 750 -1, 34, 48, 49, 50, 51, 52, 53, 54, 55, 751 -1, 57, 58, 59, 60, -1, -1, 50, 51, -1, 752 -1, -1, -1, -1, -1, -1, 59, -1, 61, 62, 753 3, -1, 65, 6, 7, 8, 9, 10, 11, 12, 754 13, -1, -1, 16, 17, 18, 19, 20, 21, 22, 755 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 756 -1, 34, 49, 50, 51, 52, 53, 54, 55, -1, 757 57, 58, 59, 60, -1, -1, -1, 50, 51, -1, 758 -1, -1, -1, -1, -1, -1, 59, -1, 61, 62, 759 -1, 35, 65, 37, 38, 39, 40, 41, 42, 43, 760 44, 45, 46, -1, 48, 49, 50, 51, 52, 53, 761 54, 55, -1, 57, 58, 59, 60, -1, -1, 35, 762 64, 37, 38, 39, 40, 41, 42, 43, 44, 45, 763 46, -1, 48, 49, 50, 51, 52, 53, 54, 55, 764 -1, 57, 58, 59, 60, -1, -1, -1, 64, 37, 765 38, 39, 40, 41, 42, 43, 44, 45, 46, -1, 766 48, 49, 50, 51, 52, 53, 54, 55, -1, 57, 767 58, 59, 60, -1, -1, -1, 64, 37, 38, 39, 768 40, 41, 42, 43, 44, 45, 46, -1, 48, 49, 769 50, 51, 52, 53, 54, 55, -1, 57, 58, 59, 770 60, -1, -1, -1, 64, 37, 38, 39, 40, 41, 771 42, 43, 44, 45, 46, -1, 48, 49, 50, 51, 772 52, 53, 54, 55, -1, 57, 58, 59, 60, -1, 773 -1, -1, 64, 37, 38, 39, 40, 41, 42, 43, 774 44, 45, 46, -1, 48, 49, 50, 51, 52, 53, 775 54, 55, -1, 57, 58, 59, 60, -1, -1, -1, 776 64, 37, 38, 39, 40, 41, 42, 43, 44, 45, 777 46, -1, 48, 49, 50, 51, 52, 53, 54, 55, 778 -1, 57, 58, 59, 60, -1, -1, -1, 64, 37, 779 38, 39, 40, 41, 42, 43, 44, 45, 46, -1, 780 48, 49, 50, 51, 52, 53, 54, 55, -1, 57, 781 58, 59, 60, -1, -1, -1, 64, 37, 38, 39, 782 40, 41, 42, 43, 44, 45, 46, -1, 48, 49, 783 50, 51, 52, 53, 54, 55, -1, 57, 58, 59, 784 60, -1, -1, -1, 64, 37, 38, 39, 40, 41, 785 42, 43, 44, 45, 46, -1, 48, 49, 50, 51, 786 52, 53, 54, 55, -1, 57, 58, 59, 60, -1, 787 -1, -1, 64, 37, 38, 39, 40, 41, 42, 43, 788 44, 45, 46, -1, 48, 49, 50, 51, 52, 53, 789 54, 55, -1, 57, 58, 59, 60, -1, -1, -1, 790 64, 37, 38, 39, 40, 41, 42, 43, 44, 45, 791 46, -1, 48, 49, 50, 51, 52, 53, 54, 55, 792 -1, 57, 58, 59, 60, -1, -1, -1, 64, 37, 793 38, 39, 40, 41, 42, 43, 44, 45, 46, -1, 794 48, 49, 50, 51, 52, 53, 54, 55, -1, 57, 795 58, 59, 60, -1, -1, -1, 64, 37, 38, 39, 796 40, 41, 42, 43, 44, 45, 46, -1, 48, 49, 797 50, 51, 52, 53, 54, 55, -1, 57, 58, 59, 798 60, -1, -1, -1, 64, 37, 38, 39, 40, 41, 799 42, 43, 44, 45, 46, -1, 48, 49, 50, 51, 800 52, 53, 54, 55, -1, 57, 58, 59, 60, -1, 801 -1, -1, 64, 37, 38, 39, 40, 41, 42, 43, 802 44, 45, 46, -1, 48, 49, 50, 51, 52, 53, 803 54, 55, -1, 57, 58, 59, 60, -1, -1, 35, 804 64, 37, 38, 39, 40, 41, 42, 43, 44, 45, 805 46, -1, 48, 49, 50, 51, 52, 53, 54, 55, 806 -1, 57, 58, 59, 60, 35, -1, 37, 38, 39, 807 40, 41, 42, 43, 44, 45, 46, -1, 48, 49, 808 50, 51, 52, 53, 54, 55, -1, 57, 58, 59, 809 60, 37, 38, 39, 40, 41, 42, 43, 44, 45, 810 46, -1, 48, 49, 50, 51, 52, 53, 54, 55, 811 -1, 57, 58, 59, 60, 37, 38, 39, 40, 41, 812 42, 43, 44, 45, 46, -1, 48, 49, 50, 51, 813 52, 53, 54, 55, -1, 57, 58, 59, 60, 50, 814 51, 52, 53, 54, 55, -1, 57, 58, 59, 60, 815 52, 53, 54, 55, -1, 57, 58, 59, 60 816}; 817 818/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 819 symbol of state STATE-NUM. */ 820static const unsigned char yystos[] = 821{ 822 0, 3, 6, 7, 8, 9, 10, 11, 12, 13, 823 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 824 26, 27, 28, 29, 30, 31, 32, 34, 50, 51, 825 59, 61, 62, 65, 69, 70, 71, 73, 74, 79, 826 80, 81, 82, 59, 71, 82, 59, 59, 59, 59, 827 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 828 59, 71, 72, 71, 71, 77, 82, 0, 37, 38, 829 39, 40, 41, 42, 43, 44, 45, 46, 48, 49, 830 50, 51, 52, 53, 54, 55, 57, 58, 59, 60, 831 71, 33, 59, 65, 82, 71, 71, 71, 71, 82, 832 82, 71, 82, 71, 71, 71, 71, 71, 71, 71, 833 71, 64, 35, 66, 66, 71, 71, 71, 71, 71, 834 65, 74, 82, 71, 71, 71, 71, 71, 71, 71, 835 71, 71, 71, 71, 71, 75, 76, 12, 12, 13, 836 71, 77, 64, 64, 64, 64, 64, 64, 64, 64, 837 35, 64, 64, 64, 35, 64, 35, 64, 35, 35, 838 71, 71, 71, 78, 77, 64, 66, 71, 71, 71, 839 71, 71, 35, 67, 64, 64, 64, 64, 64, 64, 840 71 841}; 842 843#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) 844# define YYSIZE_T __SIZE_TYPE__ 845#endif 846#if ! defined (YYSIZE_T) && defined (size_t) 847# define YYSIZE_T size_t 848#endif 849#if ! defined (YYSIZE_T) 850# if defined (__STDC__) || defined (__cplusplus) 851# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 852# define YYSIZE_T size_t 853# endif 854#endif 855#if ! defined (YYSIZE_T) 856# define YYSIZE_T unsigned int 857#endif 858 859#define yyerrok (yyerrstatus = 0) 860#define yyclearin (yychar = YYEMPTY) 861#define YYEMPTY (-2) 862#define YYEOF 0 863 864#define YYACCEPT goto yyacceptlab 865#define YYABORT goto yyabortlab 866#define YYERROR goto yyerrlab1 867 868/* Like YYERROR except do call yyerror. This remains here temporarily 869 to ease the transition to the new meaning of YYERROR, for GCC. 870 Once GCC version 2 has supplanted version 1, this can go. */ 871 872#define YYFAIL goto yyerrlab 873 874#define YYRECOVERING() (!!yyerrstatus) 875 876#define YYBACKUP(Token, Value) \ 877do \ 878 if (yychar == YYEMPTY && yylen == 1) \ 879 { \ 880 yychar = (Token); \ 881 yylval = (Value); \ 882 yytoken = YYTRANSLATE (yychar); \ 883 YYPOPSTACK; \ 884 goto yybackup; \ 885 } \ 886 else \ 887 { \ 888 yyerror ("syntax error: cannot back up");\ 889 YYERROR; \ 890 } \ 891while (0) 892 893#define YYTERROR 1 894#define YYERRCODE 256 895 896/* YYLLOC_DEFAULT -- Compute the default location (before the actions 897 are run). */ 898 899#ifndef YYLLOC_DEFAULT 900# define YYLLOC_DEFAULT(Current, Rhs, N) \ 901 Current.first_line = Rhs[1].first_line; \ 902 Current.first_column = Rhs[1].first_column; \ 903 Current.last_line = Rhs[N].last_line; \ 904 Current.last_column = Rhs[N].last_column; 905#endif 906 907/* YYLEX -- calling `yylex' with the right arguments. */ 908 909#ifdef YYLEX_PARAM 910# define YYLEX yylex (YYLEX_PARAM) 911#else 912# define YYLEX yylex () 913#endif 914 915/* Enable debugging if requested. */ 916#if YYDEBUG 917 918# ifndef YYFPRINTF 919# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 920# define YYFPRINTF fprintf 921# endif 922 923# define YYDPRINTF(Args) \ 924do { \ 925 if (yydebug) \ 926 YYFPRINTF Args; \ 927} while (0) 928 929# define YYDSYMPRINT(Args) \ 930do { \ 931 if (yydebug) \ 932 yysymprint Args; \ 933} while (0) 934 935# define YYDSYMPRINTF(Title, Token, Value, Location) \ 936do { \ 937 if (yydebug) \ 938 { \ 939 YYFPRINTF (stderr, "%s ", Title); \ 940 yysymprint (stderr, \ 941 Token, Value); \ 942 YYFPRINTF (stderr, "\n"); \ 943 } \ 944} while (0) 945 946/*------------------------------------------------------------------. 947| yy_stack_print -- Print the state stack from its BOTTOM up to its | 948| TOP (cinluded). | 949`------------------------------------------------------------------*/ 950 951#if defined (__STDC__) || defined (__cplusplus) 952static void 953yy_stack_print (short *bottom, short *top) 954#else 955static void 956yy_stack_print (bottom, top) 957 short *bottom; 958 short *top; 959#endif 960{ 961 YYFPRINTF (stderr, "Stack now"); 962 for (/* Nothing. */; bottom <= top; ++bottom) 963 YYFPRINTF (stderr, " %d", *bottom); 964 YYFPRINTF (stderr, "\n"); 965} 966 967# define YY_STACK_PRINT(Bottom, Top) \ 968do { \ 969 if (yydebug) \ 970 yy_stack_print ((Bottom), (Top)); \ 971} while (0) 972 973 974/*------------------------------------------------. 975| Report that the YYRULE is going to be reduced. | 976`------------------------------------------------*/ 977 978#if defined (__STDC__) || defined (__cplusplus) 979static void 980yy_reduce_print (int yyrule) 981#else 982static void 983yy_reduce_print (yyrule) 984 int yyrule; 985#endif 986{ 987 int yyi; 988 unsigned int yylineno = yyrline[yyrule]; 989 YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ", 990 yyrule - 1, yylineno); 991 /* Print the symbols being reduced, and their result. */ 992 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) 993 YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]); 994 YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]); 995} 996 997# define YY_REDUCE_PRINT(Rule) \ 998do { \ 999 if (yydebug) \ 1000 yy_reduce_print (Rule); \ 1001} while (0) 1002 1003/* Nonzero means print parse trace. It is left uninitialized so that 1004 multiple parsers can coexist. */ 1005int yydebug; 1006#else /* !YYDEBUG */ 1007# define YYDPRINTF(Args) 1008# define YYDSYMPRINT(Args) 1009# define YYDSYMPRINTF(Title, Token, Value, Location) 1010# define YY_STACK_PRINT(Bottom, Top) 1011# define YY_REDUCE_PRINT(Rule) 1012#endif /* !YYDEBUG */ 1013 1014 1015/* YYINITDEPTH -- initial size of the parser's stacks. */ 1016#ifndef YYINITDEPTH 1017# define YYINITDEPTH 200 1018#endif 1019 1020/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 1021 if the built-in stack extension method is used). 1022 1023 Do not make this value too large; the results are undefined if 1024 SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) 1025 evaluated with infinite-precision integer arithmetic. */ 1026 1027#if YYMAXDEPTH == 0 1028# undef YYMAXDEPTH 1029#endif 1030 1031#ifndef YYMAXDEPTH 1032# define YYMAXDEPTH 10000 1033#endif 1034 1035 1036 1037#if YYERROR_VERBOSE 1038 1039# ifndef yystrlen 1040# if defined (__GLIBC__) && defined (_STRING_H) 1041# define yystrlen strlen 1042# else 1043/* Return the length of YYSTR. */ 1044static YYSIZE_T 1045# if defined (__STDC__) || defined (__cplusplus) 1046yystrlen (const char *yystr) 1047# else 1048yystrlen (yystr) 1049 const char *yystr; 1050# endif 1051{ 1052 register const char *yys = yystr; 1053 1054 while (*yys++ != '\0') 1055 continue; 1056 1057 return yys - yystr - 1; 1058} 1059# endif 1060# endif 1061 1062# ifndef yystpcpy 1063# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) 1064# define yystpcpy stpcpy 1065# else 1066/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 1067 YYDEST. */ 1068static char * 1069# if defined (__STDC__) || defined (__cplusplus) 1070yystpcpy (char *yydest, const char *yysrc) 1071# else 1072yystpcpy (yydest, yysrc) 1073 char *yydest; 1074 const char *yysrc; 1075# endif 1076{ 1077 register char *yyd = yydest; 1078 register const char *yys = yysrc; 1079 1080 while ((*yyd++ = *yys++) != '\0') 1081 continue; 1082 1083 return yyd - 1; 1084} 1085# endif 1086# endif 1087 1088#endif /* !YYERROR_VERBOSE */ 1089 1090 1091 1092#if YYDEBUG 1093/*--------------------------------. 1094| Print this symbol on YYOUTPUT. | 1095`--------------------------------*/ 1096 1097#if defined (__STDC__) || defined (__cplusplus) 1098static void 1099yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep) 1100#else 1101static void 1102yysymprint (yyoutput, yytype, yyvaluep) 1103 FILE *yyoutput; 1104 int yytype; 1105 YYSTYPE *yyvaluep; 1106#endif 1107{ 1108 /* Pacify ``unused variable'' warnings. */ 1109 (void) yyvaluep; 1110 1111 if (yytype < YYNTOKENS) 1112 { 1113 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 1114# ifdef YYPRINT 1115 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 1116# endif 1117 } 1118 else 1119 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 1120 1121 switch (yytype) 1122 { 1123 default: 1124 break; 1125 } 1126 YYFPRINTF (yyoutput, ")"); 1127} 1128 1129#endif /* ! YYDEBUG */ 1130/*-----------------------------------------------. 1131| Release the memory associated to this symbol. | 1132`-----------------------------------------------*/ 1133 1134#if defined (__STDC__) || defined (__cplusplus) 1135static void 1136yydestruct (int yytype, YYSTYPE *yyvaluep) 1137#else 1138static void 1139yydestruct (yytype, yyvaluep) 1140 int yytype; 1141 YYSTYPE *yyvaluep; 1142#endif 1143{ 1144 /* Pacify ``unused variable'' warnings. */ 1145 (void) yyvaluep; 1146 1147 switch (yytype) 1148 { 1149 1150 default: 1151 break; 1152 } 1153} 1154 1155 1156/* Prevent warnings from -Wmissing-prototypes. */ 1157 1158#ifdef YYPARSE_PARAM 1159# if defined (__STDC__) || defined (__cplusplus) 1160int yyparse (void *YYPARSE_PARAM); 1161# else 1162int yyparse (); 1163# endif 1164#else /* ! YYPARSE_PARAM */ 1165#if defined (__STDC__) || defined (__cplusplus) 1166int yyparse (void); 1167#else 1168int yyparse (); 1169#endif 1170#endif /* ! YYPARSE_PARAM */ 1171 1172 1173 1174/* The lookahead symbol. */ 1175int yychar; 1176 1177/* The semantic value of the lookahead symbol. */ 1178YYSTYPE yylval; 1179 1180/* Number of syntax errors so far. */ 1181int yynerrs; 1182 1183 1184 1185/*----------. 1186| yyparse. | 1187`----------*/ 1188 1189#ifdef YYPARSE_PARAM 1190# if defined (__STDC__) || defined (__cplusplus) 1191int yyparse (void *YYPARSE_PARAM) 1192# else 1193int yyparse (YYPARSE_PARAM) 1194 void *YYPARSE_PARAM; 1195# endif 1196#else /* ! YYPARSE_PARAM */ 1197#if defined (__STDC__) || defined (__cplusplus) 1198int 1199yyparse (void) 1200#else 1201int 1202yyparse () 1203 1204#endif 1205#endif 1206{ 1207 1208 register int yystate; 1209 register int yyn; 1210 int yyresult; 1211 /* Number of tokens to shift before error messages enabled. */ 1212 int yyerrstatus; 1213 /* Lookahead token as an internal (translated) token number. */ 1214 int yytoken = 0; 1215 1216 /* Three stacks and their tools: 1217 `yyss': related to states, 1218 `yyvs': related to semantic values, 1219 `yyls': related to locations. 1220 1221 Refer to the stacks thru separate pointers, to allow yyoverflow 1222 to xreallocate them elsewhere. */ 1223 1224 /* The state stack. */ 1225 short yyssa[YYINITDEPTH]; 1226 short *yyss = yyssa; 1227 register short *yyssp; 1228 1229 /* The semantic value stack. */ 1230 YYSTYPE yyvsa[YYINITDEPTH]; 1231 YYSTYPE *yyvs = yyvsa; 1232 register YYSTYPE *yyvsp; 1233 1234 1235 1236#define YYPOPSTACK (yyvsp--, yyssp--) 1237 1238 YYSIZE_T yystacksize = YYINITDEPTH; 1239 1240 /* The variables used to return semantic value and location from the 1241 action routines. */ 1242 YYSTYPE yyval; 1243 1244 1245 /* When reducing, the number of symbols on the RHS of the reduced 1246 rule. */ 1247 int yylen; 1248 1249 YYDPRINTF ((stderr, "Starting parse\n")); 1250 1251 yystate = 0; 1252 yyerrstatus = 0; 1253 yynerrs = 0; 1254 yychar = YYEMPTY; /* Cause a token to be read. */ 1255 1256 /* Initialize stack pointers. 1257 Waste one element of value and location stack 1258 so that they stay on the same level as the state stack. 1259 The wasted elements are never initialized. */ 1260 1261 yyssp = yyss; 1262 yyvsp = yyvs; 1263 1264 goto yysetstate; 1265 1266/*------------------------------------------------------------. 1267| yynewstate -- Push a new state, which is found in yystate. | 1268`------------------------------------------------------------*/ 1269 yynewstate: 1270 /* In all cases, when you get here, the value and location stacks 1271 have just been pushed. so pushing a state here evens the stacks. 1272 */ 1273 yyssp++; 1274 1275 yysetstate: 1276 *yyssp = yystate; 1277 1278 if (yyss + yystacksize - 1 <= yyssp) 1279 { 1280 /* Get the current used size of the three stacks, in elements. */ 1281 YYSIZE_T yysize = yyssp - yyss + 1; 1282 1283#ifdef yyoverflow 1284 { 1285 /* Give user a chance to xreallocate the stack. Use copies of 1286 these so that the &'s don't force the real ones into 1287 memory. */ 1288 YYSTYPE *yyvs1 = yyvs; 1289 short *yyss1 = yyss; 1290 1291 1292 /* Each stack pointer address is followed by the size of the 1293 data in use in that stack, in bytes. This used to be a 1294 conditional around just the two extra args, but that might 1295 be undefined if yyoverflow is a macro. */ 1296 yyoverflow ("parser stack overflow", 1297 &yyss1, yysize * sizeof (*yyssp), 1298 &yyvs1, yysize * sizeof (*yyvsp), 1299 1300 &yystacksize); 1301 1302 yyss = yyss1; 1303 yyvs = yyvs1; 1304 } 1305#else /* no yyoverflow */ 1306# ifndef YYSTACK_RELOCATE 1307 goto yyoverflowlab; 1308# else 1309 /* Extend the stack our own way. */ 1310 if (YYMAXDEPTH <= yystacksize) 1311 goto yyoverflowlab; 1312 yystacksize *= 2; 1313 if (YYMAXDEPTH < yystacksize) 1314 yystacksize = YYMAXDEPTH; 1315 1316 { 1317 short *yyss1 = yyss; 1318 union yyalloc *yyptr = 1319 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1320 if (! yyptr) 1321 goto yyoverflowlab; 1322 YYSTACK_RELOCATE (yyss); 1323 YYSTACK_RELOCATE (yyvs); 1324 1325# undef YYSTACK_RELOCATE 1326 if (yyss1 != yyssa) 1327 YYSTACK_FREE (yyss1); 1328 } 1329# endif 1330#endif /* no yyoverflow */ 1331 1332 yyssp = yyss + yysize - 1; 1333 yyvsp = yyvs + yysize - 1; 1334 1335 1336 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1337 (unsigned long int) yystacksize)); 1338 1339 if (yyss + yystacksize - 1 <= yyssp) 1340 YYABORT; 1341 } 1342 1343 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1344 1345 goto yybackup; 1346 1347/*-----------. 1348| yybackup. | 1349`-----------*/ 1350yybackup: 1351 1352/* Do appropriate processing given the current state. */ 1353/* Read a lookahead token if we need one and don't already have one. */ 1354/* yyresume: */ 1355 1356 /* First try to decide what to do without reference to lookahead token. */ 1357 1358 yyn = yypact[yystate]; 1359 if (yyn == YYPACT_NINF) 1360 goto yydefault; 1361 1362 /* Not known => get a lookahead token if don't already have one. */ 1363 1364 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 1365 if (yychar == YYEMPTY) 1366 { 1367 YYDPRINTF ((stderr, "Reading a token: ")); 1368 yychar = YYLEX; 1369 } 1370 1371 if (yychar <= YYEOF) 1372 { 1373 yychar = yytoken = YYEOF; 1374 YYDPRINTF ((stderr, "Now at end of input.\n")); 1375 } 1376 else 1377 { 1378 yytoken = YYTRANSLATE (yychar); 1379 YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc); 1380 } 1381 1382 /* If the proper action on seeing token YYTOKEN is to reduce or to 1383 detect an error, take that action. */ 1384 yyn += yytoken; 1385 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1386 goto yydefault; 1387 yyn = yytable[yyn]; 1388 if (yyn <= 0) 1389 { 1390 if (yyn == 0 || yyn == YYTABLE_NINF) 1391 goto yyerrlab; 1392 yyn = -yyn; 1393 goto yyreduce; 1394 } 1395 1396 if (yyn == YYFINAL) 1397 YYACCEPT; 1398 1399 /* Shift the lookahead token. */ 1400 YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken])); 1401 1402 /* Discard the token being shifted unless it is eof. */ 1403 if (yychar != YYEOF) 1404 yychar = YYEMPTY; 1405 1406 *++yyvsp = yylval; 1407 1408 1409 /* Count tokens shifted since error; after three, turn off error 1410 status. */ 1411 if (yyerrstatus) 1412 yyerrstatus--; 1413 1414 yystate = yyn; 1415 goto yynewstate; 1416 1417 1418/*-----------------------------------------------------------. 1419| yydefault -- do the default action for the current state. | 1420`-----------------------------------------------------------*/ 1421yydefault: 1422 yyn = yydefact[yystate]; 1423 if (yyn == 0) 1424 goto yyerrlab; 1425 goto yyreduce; 1426 1427 1428/*-----------------------------. 1429| yyreduce -- Do a reduction. | 1430`-----------------------------*/ 1431yyreduce: 1432 /* yyn is the number of a rule to reduce with. */ 1433 yylen = yyr2[yyn]; 1434 1435 /* If YYLEN is nonzero, implement the default value of the action: 1436 `$$ = $1'. 1437 1438 Otherwise, the following line sets YYVAL to garbage. 1439 This behavior is undocumented and Bison 1440 users should not rely upon it. Assigning to YYVAL 1441 unconditionally makes the parser a bit smaller, and it avoids a 1442 GCC warning that YYVAL may be used uninitialized. */ 1443 yyval = yyvsp[1-yylen]; 1444 1445 1446 YY_REDUCE_PRINT (yyn); 1447 switch (yyn) 1448 { 1449 case 4: 1450#line 210 "m2-exp.y" 1451 { write_exp_elt_opcode(OP_TYPE); 1452 write_exp_elt_type(yyvsp[0].tval); 1453 write_exp_elt_opcode(OP_TYPE); 1454 } 1455 break; 1456 1457 case 5: 1458#line 219 "m2-exp.y" 1459 { write_exp_elt_opcode (UNOP_IND); } 1460 break; 1461 1462 case 6: 1463#line 223 "m2-exp.y" 1464 { number_sign = -1; } 1465 break; 1466 1467 case 7: 1468#line 225 "m2-exp.y" 1469 { number_sign = 1; 1470 write_exp_elt_opcode (UNOP_NEG); } 1471 break; 1472 1473 case 8: 1474#line 230 "m2-exp.y" 1475 { write_exp_elt_opcode(UNOP_PLUS); } 1476 break; 1477 1478 case 9: 1479#line 234 "m2-exp.y" 1480 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); } 1481 break; 1482 1483 case 12: 1484#line 242 "m2-exp.y" 1485 { write_exp_elt_opcode (UNOP_CAP); } 1486 break; 1487 1488 case 13: 1489#line 246 "m2-exp.y" 1490 { write_exp_elt_opcode (UNOP_ORD); } 1491 break; 1492 1493 case 14: 1494#line 250 "m2-exp.y" 1495 { write_exp_elt_opcode (UNOP_ABS); } 1496 break; 1497 1498 case 15: 1499#line 254 "m2-exp.y" 1500 { write_exp_elt_opcode (UNOP_HIGH); } 1501 break; 1502 1503 case 16: 1504#line 258 "m2-exp.y" 1505 { write_exp_elt_opcode (UNOP_MIN); 1506 write_exp_elt_type (yyvsp[-1].tval); 1507 write_exp_elt_opcode (UNOP_MIN); } 1508 break; 1509 1510 case 17: 1511#line 264 "m2-exp.y" 1512 { write_exp_elt_opcode (UNOP_MAX); 1513 write_exp_elt_type (yyvsp[-1].tval); 1514 write_exp_elt_opcode (UNOP_MIN); } 1515 break; 1516 1517 case 18: 1518#line 270 "m2-exp.y" 1519 { write_exp_elt_opcode (UNOP_FLOAT); } 1520 break; 1521 1522 case 19: 1523#line 274 "m2-exp.y" 1524 { write_exp_elt_opcode (BINOP_VAL); 1525 write_exp_elt_type (yyvsp[-3].tval); 1526 write_exp_elt_opcode (BINOP_VAL); } 1527 break; 1528 1529 case 20: 1530#line 280 "m2-exp.y" 1531 { write_exp_elt_opcode (UNOP_CHR); } 1532 break; 1533 1534 case 21: 1535#line 284 "m2-exp.y" 1536 { write_exp_elt_opcode (UNOP_ODD); } 1537 break; 1538 1539 case 22: 1540#line 288 "m2-exp.y" 1541 { write_exp_elt_opcode (UNOP_TRUNC); } 1542 break; 1543 1544 case 23: 1545#line 292 "m2-exp.y" 1546 { write_exp_elt_opcode (UNOP_SIZEOF); } 1547 break; 1548 1549 case 24: 1550#line 297 "m2-exp.y" 1551 { write_exp_elt_opcode(UNOP_PREINCREMENT); } 1552 break; 1553 1554 case 25: 1555#line 301 "m2-exp.y" 1556 { write_exp_elt_opcode(BINOP_ASSIGN_MODIFY); 1557 write_exp_elt_opcode(BINOP_ADD); 1558 write_exp_elt_opcode(BINOP_ASSIGN_MODIFY); } 1559 break; 1560 1561 case 26: 1562#line 307 "m2-exp.y" 1563 { write_exp_elt_opcode(UNOP_PREDECREMENT);} 1564 break; 1565 1566 case 27: 1567#line 311 "m2-exp.y" 1568 { write_exp_elt_opcode(BINOP_ASSIGN_MODIFY); 1569 write_exp_elt_opcode(BINOP_SUB); 1570 write_exp_elt_opcode(BINOP_ASSIGN_MODIFY); } 1571 break; 1572 1573 case 28: 1574#line 317 "m2-exp.y" 1575 { write_exp_elt_opcode (STRUCTOP_STRUCT); 1576 write_exp_string (yyvsp[0].sval); 1577 write_exp_elt_opcode (STRUCTOP_STRUCT); } 1578 break; 1579 1580 case 30: 1581#line 326 "m2-exp.y" 1582 { error("Sets are not implemented.");} 1583 break; 1584 1585 case 31: 1586#line 330 "m2-exp.y" 1587 { error("Sets are not implemented.");} 1588 break; 1589 1590 case 32: 1591#line 334 "m2-exp.y" 1592 { error("Sets are not implemented.");} 1593 break; 1594 1595 case 33: 1596#line 338 "m2-exp.y" 1597 { error("Sets are not implemented.");} 1598 break; 1599 1600 case 34: 1601#line 340 "m2-exp.y" 1602 { error("Sets are not implemented.");} 1603 break; 1604 1605 case 35: 1606#line 349 "m2-exp.y" 1607 { start_arglist(); } 1608 break; 1609 1610 case 36: 1611#line 351 "m2-exp.y" 1612 { write_exp_elt_opcode (MULTI_SUBSCRIPT); 1613 write_exp_elt_longcst ((LONGEST) end_arglist()); 1614 write_exp_elt_opcode (MULTI_SUBSCRIPT); } 1615 break; 1616 1617 case 37: 1618#line 359 "m2-exp.y" 1619 { start_arglist (); } 1620 break; 1621 1622 case 38: 1623#line 361 "m2-exp.y" 1624 { write_exp_elt_opcode (OP_FUNCALL); 1625 write_exp_elt_longcst ((LONGEST) end_arglist ()); 1626 write_exp_elt_opcode (OP_FUNCALL); } 1627 break; 1628 1629 case 40: 1630#line 370 "m2-exp.y" 1631 { arglist_len = 1; } 1632 break; 1633 1634 case 41: 1635#line 374 "m2-exp.y" 1636 { arglist_len++; } 1637 break; 1638 1639 case 42: 1640#line 379 "m2-exp.y" 1641 { arglist_len = 1; } 1642 break; 1643 1644 case 43: 1645#line 384 "m2-exp.y" 1646 { arglist_len++; } 1647 break; 1648 1649 case 44: 1650#line 389 "m2-exp.y" 1651 { write_exp_elt_opcode (UNOP_MEMVAL); 1652 write_exp_elt_type (yyvsp[-2].tval); 1653 write_exp_elt_opcode (UNOP_MEMVAL); } 1654 break; 1655 1656 case 45: 1657#line 395 "m2-exp.y" 1658 { write_exp_elt_opcode (UNOP_CAST); 1659 write_exp_elt_type (yyvsp[-3].tval); 1660 write_exp_elt_opcode (UNOP_CAST); } 1661 break; 1662 1663 case 46: 1664#line 401 "m2-exp.y" 1665 { } 1666 break; 1667 1668 case 47: 1669#line 409 "m2-exp.y" 1670 { write_exp_elt_opcode (BINOP_REPEAT); } 1671 break; 1672 1673 case 48: 1674#line 413 "m2-exp.y" 1675 { write_exp_elt_opcode (BINOP_MUL); } 1676 break; 1677 1678 case 49: 1679#line 417 "m2-exp.y" 1680 { write_exp_elt_opcode (BINOP_DIV); } 1681 break; 1682 1683 case 50: 1684#line 421 "m2-exp.y" 1685 { write_exp_elt_opcode (BINOP_INTDIV); } 1686 break; 1687 1688 case 51: 1689#line 425 "m2-exp.y" 1690 { write_exp_elt_opcode (BINOP_REM); } 1691 break; 1692 1693 case 52: 1694#line 429 "m2-exp.y" 1695 { write_exp_elt_opcode (BINOP_ADD); } 1696 break; 1697 1698 case 53: 1699#line 433 "m2-exp.y" 1700 { write_exp_elt_opcode (BINOP_SUB); } 1701 break; 1702 1703 case 54: 1704#line 437 "m2-exp.y" 1705 { write_exp_elt_opcode (BINOP_EQUAL); } 1706 break; 1707 1708 case 55: 1709#line 441 "m2-exp.y" 1710 { write_exp_elt_opcode (BINOP_NOTEQUAL); } 1711 break; 1712 1713 case 56: 1714#line 443 "m2-exp.y" 1715 { write_exp_elt_opcode (BINOP_NOTEQUAL); } 1716 break; 1717 1718 case 57: 1719#line 447 "m2-exp.y" 1720 { write_exp_elt_opcode (BINOP_LEQ); } 1721 break; 1722 1723 case 58: 1724#line 451 "m2-exp.y" 1725 { write_exp_elt_opcode (BINOP_GEQ); } 1726 break; 1727 1728 case 59: 1729#line 455 "m2-exp.y" 1730 { write_exp_elt_opcode (BINOP_LESS); } 1731 break; 1732 1733 case 60: 1734#line 459 "m2-exp.y" 1735 { write_exp_elt_opcode (BINOP_GTR); } 1736 break; 1737 1738 case 61: 1739#line 463 "m2-exp.y" 1740 { write_exp_elt_opcode (BINOP_LOGICAL_AND); } 1741 break; 1742 1743 case 62: 1744#line 467 "m2-exp.y" 1745 { write_exp_elt_opcode (BINOP_LOGICAL_OR); } 1746 break; 1747 1748 case 63: 1749#line 471 "m2-exp.y" 1750 { write_exp_elt_opcode (BINOP_ASSIGN); } 1751 break; 1752 1753 case 64: 1754#line 478 "m2-exp.y" 1755 { write_exp_elt_opcode (OP_BOOL); 1756 write_exp_elt_longcst ((LONGEST) yyvsp[0].ulval); 1757 write_exp_elt_opcode (OP_BOOL); } 1758 break; 1759 1760 case 65: 1761#line 484 "m2-exp.y" 1762 { write_exp_elt_opcode (OP_BOOL); 1763 write_exp_elt_longcst ((LONGEST) yyvsp[0].ulval); 1764 write_exp_elt_opcode (OP_BOOL); } 1765 break; 1766 1767 case 66: 1768#line 490 "m2-exp.y" 1769 { write_exp_elt_opcode (OP_LONG); 1770 write_exp_elt_type (builtin_type_m2_int); 1771 write_exp_elt_longcst ((LONGEST) yyvsp[0].lval); 1772 write_exp_elt_opcode (OP_LONG); } 1773 break; 1774 1775 case 67: 1776#line 497 "m2-exp.y" 1777 { 1778 write_exp_elt_opcode (OP_LONG); 1779 write_exp_elt_type (builtin_type_m2_card); 1780 write_exp_elt_longcst ((LONGEST) yyvsp[0].ulval); 1781 write_exp_elt_opcode (OP_LONG); 1782 } 1783 break; 1784 1785 case 68: 1786#line 506 "m2-exp.y" 1787 { write_exp_elt_opcode (OP_LONG); 1788 write_exp_elt_type (builtin_type_m2_char); 1789 write_exp_elt_longcst ((LONGEST) yyvsp[0].ulval); 1790 write_exp_elt_opcode (OP_LONG); } 1791 break; 1792 1793 case 69: 1794#line 514 "m2-exp.y" 1795 { write_exp_elt_opcode (OP_DOUBLE); 1796 write_exp_elt_type (builtin_type_m2_real); 1797 write_exp_elt_dblcst (yyvsp[0].dval); 1798 write_exp_elt_opcode (OP_DOUBLE); } 1799 break; 1800 1801 case 71: 1802#line 524 "m2-exp.y" 1803 { write_exp_elt_opcode (OP_LONG); 1804 write_exp_elt_type (builtin_type_int); 1805 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH (yyvsp[-1].tval)); 1806 write_exp_elt_opcode (OP_LONG); } 1807 break; 1808 1809 case 72: 1810#line 531 "m2-exp.y" 1811 { write_exp_elt_opcode (OP_M2_STRING); 1812 write_exp_string (yyvsp[0].sval); 1813 write_exp_elt_opcode (OP_M2_STRING); } 1814 break; 1815 1816 case 73: 1817#line 538 "m2-exp.y" 1818 { yyval.bval = SYMBOL_BLOCK_VALUE(yyvsp[0].sym); } 1819 break; 1820 1821 case 74: 1822#line 542 "m2-exp.y" 1823 { struct symbol *sym 1824 = lookup_symbol (copy_name (yyvsp[0].sval), expression_context_block, 1825 VAR_DOMAIN, 0, NULL); 1826 yyval.sym = sym;} 1827 break; 1828 1829 case 75: 1830#line 551 "m2-exp.y" 1831 { struct symbol *tem 1832 = lookup_symbol (copy_name (yyvsp[0].sval), yyvsp[-2].bval, 1833 VAR_DOMAIN, 0, NULL); 1834 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK) 1835 error ("No function \"%s\" in specified context.", 1836 copy_name (yyvsp[0].sval)); 1837 yyval.sym = tem; 1838 } 1839 break; 1840 1841 case 76: 1842#line 563 "m2-exp.y" 1843 { write_exp_elt_opcode(OP_VAR_VALUE); 1844 write_exp_elt_block (NULL); 1845 write_exp_elt_sym (yyvsp[0].sym); 1846 write_exp_elt_opcode (OP_VAR_VALUE); } 1847 break; 1848 1849 case 78: 1850#line 575 "m2-exp.y" 1851 { struct symbol *sym; 1852 sym = lookup_symbol (copy_name (yyvsp[0].sval), yyvsp[-2].bval, 1853 VAR_DOMAIN, 0, NULL); 1854 if (sym == 0) 1855 error ("No symbol \"%s\" in specified context.", 1856 copy_name (yyvsp[0].sval)); 1857 1858 write_exp_elt_opcode (OP_VAR_VALUE); 1859 /* block_found is set by lookup_symbol. */ 1860 write_exp_elt_block (block_found); 1861 write_exp_elt_sym (sym); 1862 write_exp_elt_opcode (OP_VAR_VALUE); } 1863 break; 1864 1865 case 79: 1866#line 591 "m2-exp.y" 1867 { struct symbol *sym; 1868 int is_a_field_of_this; 1869 1870 sym = lookup_symbol (copy_name (yyvsp[0].sval), 1871 expression_context_block, 1872 VAR_DOMAIN, 1873 &is_a_field_of_this, 1874 NULL); 1875 if (sym) 1876 { 1877 if (symbol_read_needs_frame (sym)) 1878 { 1879 if (innermost_block == 0 || 1880 contained_in (block_found, 1881 innermost_block)) 1882 innermost_block = block_found; 1883 } 1884 1885 write_exp_elt_opcode (OP_VAR_VALUE); 1886 /* We want to use the selected frame, not 1887 another more inner frame which happens to 1888 be in the same block. */ 1889 write_exp_elt_block (NULL); 1890 write_exp_elt_sym (sym); 1891 write_exp_elt_opcode (OP_VAR_VALUE); 1892 } 1893 else 1894 { 1895 struct minimal_symbol *msymbol; 1896 char *arg = copy_name (yyvsp[0].sval); 1897 1898 msymbol = 1899 lookup_minimal_symbol (arg, NULL, NULL); 1900 if (msymbol != NULL) 1901 { 1902 write_exp_msymbol 1903 (msymbol, 1904 lookup_function_type (builtin_type_int), 1905 builtin_type_int); 1906 } 1907 else if (!have_full_symbols () && !have_partial_symbols ()) 1908 error ("No symbol table is loaded. Use the \"symbol-file\" command."); 1909 else 1910 error ("No symbol \"%s\" in current context.", 1911 copy_name (yyvsp[0].sval)); 1912 } 1913 } 1914 break; 1915 1916 case 80: 1917#line 642 "m2-exp.y" 1918 { yyval.tval = lookup_typename (copy_name (yyvsp[0].sval), 1919 expression_context_block, 0); } 1920 break; 1921 1922 1923 } 1924 1925/* Line 991 of yacc.c. */ 1926 1927 yyvsp -= yylen; 1928 yyssp -= yylen; 1929 1930 1931 YY_STACK_PRINT (yyss, yyssp); 1932 1933 *++yyvsp = yyval; 1934 1935 1936 /* Now `shift' the result of the reduction. Determine what state 1937 that goes to, based on the state we popped back to and the rule 1938 number reduced by. */ 1939 1940 yyn = yyr1[yyn]; 1941 1942 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 1943 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 1944 yystate = yytable[yystate]; 1945 else 1946 yystate = yydefgoto[yyn - YYNTOKENS]; 1947 1948 goto yynewstate; 1949 1950 1951/*------------------------------------. 1952| yyerrlab -- here on detecting error | 1953`------------------------------------*/ 1954yyerrlab: 1955 /* If not already recovering from an error, report this error. */ 1956 if (!yyerrstatus) 1957 { 1958 ++yynerrs; 1959#if YYERROR_VERBOSE 1960 yyn = yypact[yystate]; 1961 1962 if (YYPACT_NINF < yyn && yyn < YYLAST) 1963 { 1964 YYSIZE_T yysize = 0; 1965 int yytype = YYTRANSLATE (yychar); 1966 char *yymsg; 1967 int yyx, yycount; 1968 1969 yycount = 0; 1970 /* Start YYX at -YYN if negative to avoid negative indexes in 1971 YYCHECK. */ 1972 for (yyx = yyn < 0 ? -yyn : 0; 1973 yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++) 1974 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 1975 yysize += yystrlen (yytname[yyx]) + 15, yycount++; 1976 yysize += yystrlen ("syntax error, unexpected ") + 1; 1977 yysize += yystrlen (yytname[yytype]); 1978 yymsg = (char *) YYSTACK_ALLOC (yysize); 1979 if (yymsg != 0) 1980 { 1981 char *yyp = yystpcpy (yymsg, "syntax error, unexpected "); 1982 yyp = yystpcpy (yyp, yytname[yytype]); 1983 1984 if (yycount < 5) 1985 { 1986 yycount = 0; 1987 for (yyx = yyn < 0 ? -yyn : 0; 1988 yyx < (int) (sizeof (yytname) / sizeof (char *)); 1989 yyx++) 1990 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 1991 { 1992 const char *yyq = ! yycount ? ", expecting " : " or "; 1993 yyp = yystpcpy (yyp, yyq); 1994 yyp = yystpcpy (yyp, yytname[yyx]); 1995 yycount++; 1996 } 1997 } 1998 yyerror (yymsg); 1999 YYSTACK_FREE (yymsg); 2000 } 2001 else 2002 yyerror ("syntax error; also virtual memory exhausted"); 2003 } 2004 else 2005#endif /* YYERROR_VERBOSE */ 2006 yyerror ("syntax error"); 2007 } 2008 2009 2010 2011 if (yyerrstatus == 3) 2012 { 2013 /* If just tried and failed to reuse lookahead token after an 2014 error, discard it. */ 2015 2016 /* Return failure if at end of input. */ 2017 if (yychar == YYEOF) 2018 { 2019 /* Pop the error token. */ 2020 YYPOPSTACK; 2021 /* Pop the rest of the stack. */ 2022 while (yyss < yyssp) 2023 { 2024 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); 2025 yydestruct (yystos[*yyssp], yyvsp); 2026 YYPOPSTACK; 2027 } 2028 YYABORT; 2029 } 2030 2031 YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc); 2032 yydestruct (yytoken, &yylval); 2033 yychar = YYEMPTY; 2034 2035 } 2036 2037 /* Else will try to reuse lookahead token after shifting the error 2038 token. */ 2039 goto yyerrlab2; 2040 2041 2042/*----------------------------------------------------. 2043| yyerrlab1 -- error raised explicitly by an action. | 2044`----------------------------------------------------*/ 2045yyerrlab1: 2046 2047 /* Suppress GCC warning that yyerrlab1 is unused when no action 2048 invokes YYERROR. Doesn't work in C++ */ 2049#ifndef __cplusplus 2050#if defined (__GNUC_MINOR__) && 2093 <= (__GNUC__ * 1000 + __GNUC_MINOR__) 2051 __attribute__ ((__unused__)) 2052#endif 2053#endif 2054 2055 2056 goto yyerrlab2; 2057 2058 2059/*---------------------------------------------------------------. 2060| yyerrlab2 -- pop states until the error token can be shifted. | 2061`---------------------------------------------------------------*/ 2062yyerrlab2: 2063 yyerrstatus = 3; /* Each real token shifted decrements this. */ 2064 2065 for (;;) 2066 { 2067 yyn = yypact[yystate]; 2068 if (yyn != YYPACT_NINF) 2069 { 2070 yyn += YYTERROR; 2071 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 2072 { 2073 yyn = yytable[yyn]; 2074 if (0 < yyn) 2075 break; 2076 } 2077 } 2078 2079 /* Pop the current state because it cannot handle the error token. */ 2080 if (yyssp == yyss) 2081 YYABORT; 2082 2083 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); 2084 yydestruct (yystos[yystate], yyvsp); 2085 yyvsp--; 2086 yystate = *--yyssp; 2087 2088 YY_STACK_PRINT (yyss, yyssp); 2089 } 2090 2091 if (yyn == YYFINAL) 2092 YYACCEPT; 2093 2094 YYDPRINTF ((stderr, "Shifting error token, ")); 2095 2096 *++yyvsp = yylval; 2097 2098 2099 yystate = yyn; 2100 goto yynewstate; 2101 2102 2103/*-------------------------------------. 2104| yyacceptlab -- YYACCEPT comes here. | 2105`-------------------------------------*/ 2106yyacceptlab: 2107 yyresult = 0; 2108 goto yyreturn; 2109 2110/*-----------------------------------. 2111| yyabortlab -- YYABORT comes here. | 2112`-----------------------------------*/ 2113yyabortlab: 2114 yyresult = 1; 2115 goto yyreturn; 2116 2117#ifndef yyoverflow 2118/*----------------------------------------------. 2119| yyoverflowlab -- parser overflow comes here. | 2120`----------------------------------------------*/ 2121yyoverflowlab: 2122 yyerror ("parser stack overflow"); 2123 yyresult = 2; 2124 /* Fall through. */ 2125#endif 2126 2127yyreturn: 2128#ifndef yyoverflow 2129 if (yyss != yyssa) 2130 YYSTACK_FREE (yyss); 2131#endif 2132 return yyresult; 2133} 2134 2135 2136#line 647 "m2-exp.y" 2137 2138 2139#if 0 /* FIXME! */ 2140int 2141overflow(a,b) 2142 long a,b; 2143{ 2144 return (MAX_OF_TYPE(builtin_type_m2_int) - b) < a; 2145} 2146 2147int 2148uoverflow(a,b) 2149 unsigned long a,b; 2150{ 2151 return (MAX_OF_TYPE(builtin_type_m2_card) - b) < a; 2152} 2153#endif /* FIXME */ 2154 2155/* Take care of parsing a number (anything that starts with a digit). 2156 Set yylval and return the token type; update lexptr. 2157 LEN is the number of characters in it. */ 2158 2159/*** Needs some error checking for the float case ***/ 2160 2161static int 2162parse_number (olen) 2163 int olen; 2164{ 2165 char *p = lexptr; 2166 LONGEST n = 0; 2167 LONGEST prevn = 0; 2168 int c,i,ischar=0; 2169 int base = input_radix; 2170 int len = olen; 2171 int unsigned_p = number_sign == 1 ? 1 : 0; 2172 2173 if(p[len-1] == 'H') 2174 { 2175 base = 16; 2176 len--; 2177 } 2178 else if(p[len-1] == 'C' || p[len-1] == 'B') 2179 { 2180 base = 8; 2181 ischar = p[len-1] == 'C'; 2182 len--; 2183 } 2184 2185 /* Scan the number */ 2186 for (c = 0; c < len; c++) 2187 { 2188 if (p[c] == '.' && base == 10) 2189 { 2190 /* It's a float since it contains a point. */ 2191 yylval.dval = atof (p); 2192 lexptr += len; 2193 return FLOAT; 2194 } 2195 if (p[c] == '.' && base != 10) 2196 error("Floating point numbers must be base 10."); 2197 if (base == 10 && (p[c] < '0' || p[c] > '9')) 2198 error("Invalid digit \'%c\' in number.",p[c]); 2199 } 2200 2201 while (len-- > 0) 2202 { 2203 c = *p++; 2204 n *= base; 2205 if( base == 8 && (c == '8' || c == '9')) 2206 error("Invalid digit \'%c\' in octal number.",c); 2207 if (c >= '0' && c <= '9') 2208 i = c - '0'; 2209 else 2210 { 2211 if (base == 16 && c >= 'A' && c <= 'F') 2212 i = c - 'A' + 10; 2213 else 2214 return ERROR; 2215 } 2216 n+=i; 2217 if(i >= base) 2218 return ERROR; 2219 if(!unsigned_p && number_sign == 1 && (prevn >= n)) 2220 unsigned_p=1; /* Try something unsigned */ 2221 /* Don't do the range check if n==i and i==0, since that special 2222 case will give an overflow error. */ 2223 if(RANGE_CHECK && n!=i && i) 2224 { 2225 if((unsigned_p && (unsigned)prevn >= (unsigned)n) || 2226 ((!unsigned_p && number_sign==-1) && -prevn <= -n)) 2227 range_error("Overflow on numeric constant."); 2228 } 2229 prevn=n; 2230 } 2231 2232 lexptr = p; 2233 if(*p == 'B' || *p == 'C' || *p == 'H') 2234 lexptr++; /* Advance past B,C or H */ 2235 2236 if (ischar) 2237 { 2238 yylval.ulval = n; 2239 return CHAR; 2240 } 2241 else if ( unsigned_p && number_sign == 1) 2242 { 2243 yylval.ulval = n; 2244 return UINT; 2245 } 2246 else if((unsigned_p && (n<0))) { 2247 range_error("Overflow on numeric constant -- number too large."); 2248 /* But, this can return if range_check == range_warn. */ 2249 } 2250 yylval.lval = n; 2251 return INT; 2252} 2253 2254 2255/* Some tokens */ 2256 2257static struct 2258{ 2259 char name[2]; 2260 int token; 2261} tokentab2[] = 2262{ 2263 { {'<', '>'}, NOTEQUAL }, 2264 { {':', '='}, ASSIGN }, 2265 { {'<', '='}, LEQ }, 2266 { {'>', '='}, GEQ }, 2267 { {':', ':'}, COLONCOLON }, 2268 2269}; 2270 2271/* Some specific keywords */ 2272 2273struct keyword { 2274 char keyw[10]; 2275 int token; 2276}; 2277 2278static struct keyword keytab[] = 2279{ 2280 {"OR" , OROR }, 2281 {"IN", IN },/* Note space after IN */ 2282 {"AND", LOGICAL_AND}, 2283 {"ABS", ABS }, 2284 {"CHR", CHR }, 2285 {"DEC", DEC }, 2286 {"NOT", NOT }, 2287 {"DIV", DIV }, 2288 {"INC", INC }, 2289 {"MAX", MAX_FUNC }, 2290 {"MIN", MIN_FUNC }, 2291 {"MOD", MOD }, 2292 {"ODD", ODD }, 2293 {"CAP", CAP }, 2294 {"ORD", ORD }, 2295 {"VAL", VAL }, 2296 {"EXCL", EXCL }, 2297 {"HIGH", HIGH }, 2298 {"INCL", INCL }, 2299 {"SIZE", SIZE }, 2300 {"FLOAT", FLOAT_FUNC }, 2301 {"TRUNC", TRUNC }, 2302}; 2303 2304 2305/* Read one token, getting characters through lexptr. */ 2306 2307/* This is where we will check to make sure that the language and the operators used are 2308 compatible */ 2309 2310static int 2311yylex () 2312{ 2313 int c; 2314 int namelen; 2315 int i; 2316 char *tokstart; 2317 char quote; 2318 2319 retry: 2320 2321 prev_lexptr = lexptr; 2322 2323 tokstart = lexptr; 2324 2325 2326 /* See if it is a special token of length 2 */ 2327 for( i = 0 ; i < (int) (sizeof tokentab2 / sizeof tokentab2[0]) ; i++) 2328 if(DEPRECATED_STREQN(tokentab2[i].name, tokstart, 2)) 2329 { 2330 lexptr += 2; 2331 return tokentab2[i].token; 2332 } 2333 2334 switch (c = *tokstart) 2335 { 2336 case 0: 2337 return 0; 2338 2339 case ' ': 2340 case '\t': 2341 case '\n': 2342 lexptr++; 2343 goto retry; 2344 2345 case '(': 2346 paren_depth++; 2347 lexptr++; 2348 return c; 2349 2350 case ')': 2351 if (paren_depth == 0) 2352 return 0; 2353 paren_depth--; 2354 lexptr++; 2355 return c; 2356 2357 case ',': 2358 if (comma_terminates && paren_depth == 0) 2359 return 0; 2360 lexptr++; 2361 return c; 2362 2363 case '.': 2364 /* Might be a floating point number. */ 2365 if (lexptr[1] >= '0' && lexptr[1] <= '9') 2366 break; /* Falls into number code. */ 2367 else 2368 { 2369 lexptr++; 2370 return DOT; 2371 } 2372 2373/* These are character tokens that appear as-is in the YACC grammar */ 2374 case '+': 2375 case '-': 2376 case '*': 2377 case '/': 2378 case '^': 2379 case '<': 2380 case '>': 2381 case '[': 2382 case ']': 2383 case '=': 2384 case '{': 2385 case '}': 2386 case '#': 2387 case '@': 2388 case '~': 2389 case '&': 2390 lexptr++; 2391 return c; 2392 2393 case '\'' : 2394 case '"': 2395 quote = c; 2396 for (namelen = 1; (c = tokstart[namelen]) != quote && c != '\0'; namelen++) 2397 if (c == '\\') 2398 { 2399 c = tokstart[++namelen]; 2400 if (c >= '0' && c <= '9') 2401 { 2402 c = tokstart[++namelen]; 2403 if (c >= '0' && c <= '9') 2404 c = tokstart[++namelen]; 2405 } 2406 } 2407 if(c != quote) 2408 error("Unterminated string or character constant."); 2409 yylval.sval.ptr = tokstart + 1; 2410 yylval.sval.length = namelen - 1; 2411 lexptr += namelen + 1; 2412 2413 if(namelen == 2) /* Single character */ 2414 { 2415 yylval.ulval = tokstart[1]; 2416 return CHAR; 2417 } 2418 else 2419 return STRING; 2420 } 2421 2422 /* Is it a number? */ 2423 /* Note: We have already dealt with the case of the token '.'. 2424 See case '.' above. */ 2425 if ((c >= '0' && c <= '9')) 2426 { 2427 /* It's a number. */ 2428 int got_dot = 0, got_e = 0; 2429 char *p = tokstart; 2430 int toktype; 2431 2432 for (++p ;; ++p) 2433 { 2434 if (!got_e && (*p == 'e' || *p == 'E')) 2435 got_dot = got_e = 1; 2436 else if (!got_dot && *p == '.') 2437 got_dot = 1; 2438 else if (got_e && (p[-1] == 'e' || p[-1] == 'E') 2439 && (*p == '-' || *p == '+')) 2440 /* This is the sign of the exponent, not the end of the 2441 number. */ 2442 continue; 2443 else if ((*p < '0' || *p > '9') && 2444 (*p < 'A' || *p > 'F') && 2445 (*p != 'H')) /* Modula-2 hexadecimal number */ 2446 break; 2447 } 2448 toktype = parse_number (p - tokstart); 2449 if (toktype == ERROR) 2450 { 2451 char *err_copy = (char *) alloca (p - tokstart + 1); 2452 2453 memcpy (err_copy, tokstart, p - tokstart); 2454 err_copy[p - tokstart] = 0; 2455 error ("Invalid number \"%s\".", err_copy); 2456 } 2457 lexptr = p; 2458 return toktype; 2459 } 2460 2461 if (!(c == '_' || c == '$' 2462 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))) 2463 /* We must have come across a bad character (e.g. ';'). */ 2464 error ("Invalid character '%c' in expression.", c); 2465 2466 /* It's a name. See how long it is. */ 2467 namelen = 0; 2468 for (c = tokstart[namelen]; 2469 (c == '_' || c == '$' || (c >= '0' && c <= '9') 2470 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')); 2471 c = tokstart[++namelen]) 2472 ; 2473 2474 /* The token "if" terminates the expression and is NOT 2475 removed from the input stream. */ 2476 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f') 2477 { 2478 return 0; 2479 } 2480 2481 lexptr += namelen; 2482 2483 /* Lookup special keywords */ 2484 for(i = 0 ; i < (int) (sizeof(keytab) / sizeof(keytab[0])) ; i++) 2485 if(namelen == strlen(keytab[i].keyw) && DEPRECATED_STREQN(tokstart,keytab[i].keyw,namelen)) 2486 return keytab[i].token; 2487 2488 yylval.sval.ptr = tokstart; 2489 yylval.sval.length = namelen; 2490 2491 if (*tokstart == '$') 2492 { 2493 write_dollar_variable (yylval.sval); 2494 return INTERNAL_VAR; 2495 } 2496 2497 /* Use token-type BLOCKNAME for symbols that happen to be defined as 2498 functions. If this is not so, then ... 2499 Use token-type TYPENAME for symbols that happen to be defined 2500 currently as names of types; NAME for other symbols. 2501 The caller is not constrained to care about the distinction. */ 2502 { 2503 2504 2505 char *tmp = copy_name (yylval.sval); 2506 struct symbol *sym; 2507 2508 if (lookup_partial_symtab (tmp)) 2509 return BLOCKNAME; 2510 sym = lookup_symbol (tmp, expression_context_block, 2511 VAR_DOMAIN, 0, NULL); 2512 if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK) 2513 return BLOCKNAME; 2514 if (lookup_typename (copy_name (yylval.sval), expression_context_block, 1)) 2515 return TYPENAME; 2516 2517 if(sym) 2518 { 2519 switch(sym->aclass) 2520 { 2521 case LOC_STATIC: 2522 case LOC_REGISTER: 2523 case LOC_ARG: 2524 case LOC_REF_ARG: 2525 case LOC_REGPARM: 2526 case LOC_REGPARM_ADDR: 2527 case LOC_LOCAL: 2528 case LOC_LOCAL_ARG: 2529 case LOC_BASEREG: 2530 case LOC_BASEREG_ARG: 2531 case LOC_CONST: 2532 case LOC_CONST_BYTES: 2533 case LOC_OPTIMIZED_OUT: 2534 case LOC_COMPUTED: 2535 case LOC_COMPUTED_ARG: 2536 return NAME; 2537 2538 case LOC_TYPEDEF: 2539 return TYPENAME; 2540 2541 case LOC_BLOCK: 2542 return BLOCKNAME; 2543 2544 case LOC_UNDEF: 2545 error("internal: Undefined class in m2lex()"); 2546 2547 case LOC_LABEL: 2548 case LOC_UNRESOLVED: 2549 error("internal: Unforseen case in m2lex()"); 2550 2551 default: 2552 error ("unhandled token in m2lex()"); 2553 break; 2554 } 2555 } 2556 else 2557 { 2558 /* Built-in BOOLEAN type. This is sort of a hack. */ 2559 if(DEPRECATED_STREQN(tokstart,"TRUE",4)) 2560 { 2561 yylval.ulval = 1; 2562 return M2_TRUE; 2563 } 2564 else if(DEPRECATED_STREQN(tokstart,"FALSE",5)) 2565 { 2566 yylval.ulval = 0; 2567 return M2_FALSE; 2568 } 2569 } 2570 2571 /* Must be another type of name... */ 2572 return NAME; 2573 } 2574} 2575 2576#if 0 /* Unused */ 2577static char * 2578make_qualname(mod,ident) 2579 char *mod, *ident; 2580{ 2581 char *new = xmalloc(strlen(mod)+strlen(ident)+2); 2582 2583 strcpy(new,mod); 2584 strcat(new,"."); 2585 strcat(new,ident); 2586 return new; 2587} 2588#endif /* 0 */ 2589 2590void 2591yyerror (msg) 2592 char *msg; 2593{ 2594 if (prev_lexptr) 2595 lexptr = prev_lexptr; 2596 2597 error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr); 2598} 2599 2600 2601