1/* A Bison parser, made by GNU Bison 1.875c. */ 2 3/* Skeleton parser for Yacc-like parsing with Bison, 4 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003 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 NULL_PTR = 259, 58 CHARLIT = 260, 59 FLOAT = 261, 60 COLONCOLON = 262, 61 STRING = 263, 62 NAME = 264, 63 DOT_ID = 265, 64 DOT_ALL = 266, 65 SPECIAL_VARIABLE = 267, 66 ASSIGN = 268, 67 ELSE = 269, 68 THEN = 270, 69 XOR = 271, 70 OR = 272, 71 _AND_ = 273, 72 DOTDOT = 274, 73 IN = 275, 74 GEQ = 276, 75 LEQ = 277, 76 NOTEQUAL = 278, 77 UNARY = 279, 78 REM = 280, 79 MOD = 281, 80 NOT = 282, 81 ABS = 283, 82 STARSTAR = 284, 83 VAR = 285, 84 ARROW = 286, 85 TICK_LENGTH = 287, 86 TICK_LAST = 288, 87 TICK_FIRST = 289, 88 TICK_ADDRESS = 290, 89 TICK_ACCESS = 291, 90 TICK_MODULUS = 292, 91 TICK_MIN = 293, 92 TICK_MAX = 294, 93 TICK_VAL = 295, 94 TICK_TAG = 296, 95 TICK_SIZE = 297, 96 TICK_RANGE = 298, 97 TICK_POS = 299, 98 NEW = 300, 99 OTHERS = 301 100 }; 101#endif 102#define INT 258 103#define NULL_PTR 259 104#define CHARLIT 260 105#define FLOAT 261 106#define COLONCOLON 262 107#define STRING 263 108#define NAME 264 109#define DOT_ID 265 110#define DOT_ALL 266 111#define SPECIAL_VARIABLE 267 112#define ASSIGN 268 113#define ELSE 269 114#define THEN 270 115#define XOR 271 116#define OR 272 117#define _AND_ 273 118#define DOTDOT 274 119#define IN 275 120#define GEQ 276 121#define LEQ 277 122#define NOTEQUAL 278 123#define UNARY 279 124#define REM 280 125#define MOD 281 126#define NOT 282 127#define ABS 283 128#define STARSTAR 284 129#define VAR 285 130#define ARROW 286 131#define TICK_LENGTH 287 132#define TICK_LAST 288 133#define TICK_FIRST 289 134#define TICK_ADDRESS 290 135#define TICK_ACCESS 291 136#define TICK_MODULUS 292 137#define TICK_MIN 293 138#define TICK_MAX 294 139#define TICK_VAL 295 140#define TICK_TAG 296 141#define TICK_SIZE 297 142#define TICK_RANGE 298 143#define TICK_POS 299 144#define NEW 300 145#define OTHERS 301 146 147 148 149 150/* Copy the first part of user declarations. */ 151#line 39 "ada-exp.y" 152 153 154#include "defs.h" 155#include "gdb_string.h" 156#include <ctype.h> 157#include "expression.h" 158#include "value.h" 159#include "parser-defs.h" 160#include "language.h" 161#include "ada-lang.h" 162#include "bfd.h" /* Required by objfiles.h. */ 163#include "symfile.h" /* Required by objfiles.h. */ 164#include "objfiles.h" /* For have_full_symbols and have_partial_symbols */ 165#include "frame.h" 166#include "block.h" 167 168/* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc), 169 as well as gratuitiously global symbol names, so we can have multiple 170 yacc generated parsers in gdb. These are only the variables 171 produced by yacc. If other parser generators (bison, byacc, etc) produce 172 additional global names that conflict at link time, then those parser 173 generators need to be fixed instead of adding those names to this list. */ 174 175/* NOTE: This is clumsy, especially since BISON and FLEX provide --prefix 176 options. I presume we are maintaining it to accommodate systems 177 without BISON? (PNH) */ 178 179#define yymaxdepth ada_maxdepth 180#define yyparse _ada_parse /* ada_parse calls this after initialization */ 181#define yylex ada_lex 182#define yyerror ada_error 183#define yylval ada_lval 184#define yychar ada_char 185#define yydebug ada_debug 186#define yypact ada_pact 187#define yyr1 ada_r1 188#define yyr2 ada_r2 189#define yydef ada_def 190#define yychk ada_chk 191#define yypgo ada_pgo 192#define yyact ada_act 193#define yyexca ada_exca 194#define yyerrflag ada_errflag 195#define yynerrs ada_nerrs 196#define yyps ada_ps 197#define yypv ada_pv 198#define yys ada_s 199#define yy_yys ada_yys 200#define yystate ada_state 201#define yytmp ada_tmp 202#define yyv ada_v 203#define yy_yyv ada_yyv 204#define yyval ada_val 205#define yylloc ada_lloc 206#define yyreds ada_reds /* With YYDEBUG defined */ 207#define yytoks ada_toks /* With YYDEBUG defined */ 208#define yyname ada_name /* With YYDEBUG defined */ 209#define yyrule ada_rule /* With YYDEBUG defined */ 210 211#ifndef YYDEBUG 212#define YYDEBUG 1 /* Default to yydebug support */ 213#endif 214 215#define YYFPRINTF parser_fprintf 216 217struct name_info { 218 struct symbol *sym; 219 struct minimal_symbol *msym; 220 struct block *block; 221 struct stoken stoken; 222}; 223 224static struct stoken empty_stoken = { "", 0 }; 225 226/* If expression is in the context of TYPE'(...), then TYPE, else 227 * NULL. */ 228static struct type *type_qualifier; 229 230int yyparse (void); 231 232static int yylex (void); 233 234void yyerror (char *); 235 236static struct stoken string_to_operator (struct stoken); 237 238static void write_int (LONGEST, struct type *); 239 240static void write_object_renaming (struct block *, struct symbol *, int); 241 242static struct type* write_var_or_type (struct block *, struct stoken); 243 244static void write_name_assoc (struct stoken); 245 246static void write_exp_op_with_string (enum exp_opcode, struct stoken); 247 248static struct block *block_lookup (struct block *, char *); 249 250static LONGEST convert_char_literal (struct type *, LONGEST); 251 252static void write_ambiguous_var (struct block *, char *, int); 253 254static struct type *type_int (void); 255 256static struct type *type_long (void); 257 258static struct type *type_long_long (void); 259 260static struct type *type_float (void); 261 262static struct type *type_double (void); 263 264static struct type *type_long_double (void); 265 266static struct type *type_char (void); 267 268static struct type *type_system_address (void); 269 270 271 272/* Enabling traces. */ 273#ifndef YYDEBUG 274# define YYDEBUG 0 275#endif 276 277/* Enabling verbose error messages. */ 278#ifdef YYERROR_VERBOSE 279# undef YYERROR_VERBOSE 280# define YYERROR_VERBOSE 1 281#else 282# define YYERROR_VERBOSE 0 283#endif 284 285#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) 286#line 160 "ada-exp.y" 287typedef union YYSTYPE { 288 LONGEST lval; 289 struct { 290 LONGEST val; 291 struct type *type; 292 } typed_val; 293 struct { 294 DOUBLEST dval; 295 struct type *type; 296 } typed_val_float; 297 struct type *tval; 298 struct stoken sval; 299 struct block *bval; 300 struct internalvar *ivar; 301 } YYSTYPE; 302/* Line 191 of yacc.c. */ 303#line 304 "ada-exp.c.tmp" 304# define yystype YYSTYPE /* obsolescent; will be withdrawn */ 305# define YYSTYPE_IS_DECLARED 1 306# define YYSTYPE_IS_TRIVIAL 1 307#endif 308 309 310 311/* Copy the second part of user declarations. */ 312 313 314/* Line 214 of yacc.c. */ 315#line 316 "ada-exp.c.tmp" 316 317#if ! defined (yyoverflow) || YYERROR_VERBOSE 318 319# ifndef YYFREE 320# define YYFREE free 321# endif 322# ifndef YYMALLOC 323# define YYMALLOC xmalloc 324# endif 325 326/* The parser invokes alloca or xmalloc; define the necessary symbols. */ 327 328# ifdef YYSTACK_USE_ALLOCA 329# if YYSTACK_USE_ALLOCA 330# define YYSTACK_ALLOC alloca 331# endif 332# else 333# if defined (alloca) || defined (_ALLOCA_H) 334# define YYSTACK_ALLOC alloca 335# else 336# ifdef __GNUC__ 337# define YYSTACK_ALLOC __builtin_alloca 338# endif 339# endif 340# endif 341 342# ifdef YYSTACK_ALLOC 343 /* Pacify GCC's `empty if-body' warning. */ 344# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) 345# else 346# if defined (__STDC__) || defined (__cplusplus) 347# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 348# define YYSIZE_T size_t 349# endif 350# define YYSTACK_ALLOC YYMALLOC 351# define YYSTACK_FREE YYFREE 352# endif 353#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ 354 355 356#if (! defined (yyoverflow) \ 357 && (! defined (__cplusplus) \ 358 || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL))) 359 360/* A type that is properly aligned for any stack member. */ 361union yyalloc 362{ 363 short yyss; 364 YYSTYPE yyvs; 365 }; 366 367/* The size of the maximum gap between one aligned stack and the next. */ 368# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 369 370/* The size of an array large to enough to hold all stacks, each with 371 N elements. */ 372# define YYSTACK_BYTES(N) \ 373 ((N) * (sizeof (short) + sizeof (YYSTYPE)) \ 374 + YYSTACK_GAP_MAXIMUM) 375 376/* Copy COUNT objects from FROM to TO. The source and destination do 377 not overlap. */ 378# ifndef YYCOPY 379# if defined (__GNUC__) && 1 < __GNUC__ 380# define YYCOPY(To, From, Count) \ 381 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 382# else 383# define YYCOPY(To, From, Count) \ 384 do \ 385 { \ 386 register YYSIZE_T yyi; \ 387 for (yyi = 0; yyi < (Count); yyi++) \ 388 (To)[yyi] = (From)[yyi]; \ 389 } \ 390 while (0) 391# endif 392# endif 393 394/* Relocate STACK from its old location to the new one. The 395 local variables YYSIZE and YYSTACKSIZE give the old and new number of 396 elements in the stack, and YYPTR gives the new location of the 397 stack. Advance YYPTR to a properly aligned location for the next 398 stack. */ 399# define YYSTACK_RELOCATE(Stack) \ 400 do \ 401 { \ 402 YYSIZE_T yynewbytes; \ 403 YYCOPY (&yyptr->Stack, Stack, yysize); \ 404 Stack = &yyptr->Stack; \ 405 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 406 yyptr += yynewbytes / sizeof (*yyptr); \ 407 } \ 408 while (0) 409 410#endif 411 412#if defined (__STDC__) || defined (__cplusplus) 413 typedef signed char yysigned_char; 414#else 415 typedef short yysigned_char; 416#endif 417 418/* YYFINAL -- State number of the termination state. */ 419#define YYFINAL 55 420/* YYLAST -- Last index in YYTABLE. */ 421#define YYLAST 705 422 423/* YYNTOKENS -- Number of terminals. */ 424#define YYNTOKENS 67 425/* YYNNTS -- Number of nonterminals. */ 426#define YYNNTS 31 427/* YYNRULES -- Number of rules. */ 428#define YYNRULES 120 429/* YYNRULES -- Number of states. */ 430#define YYNSTATES 231 431 432/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 433#define YYUNDEFTOK 2 434#define YYMAXUTOK 301 435 436#define YYTRANSLATE(YYX) \ 437 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 438 439/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 440static const unsigned char yytranslate[] = 441{ 442 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 443 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 444 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 445 2, 2, 2, 2, 2, 2, 2, 2, 30, 62, 446 56, 61, 32, 28, 63, 29, 55, 33, 2, 2, 447 2, 2, 2, 2, 2, 2, 2, 2, 2, 60, 448 20, 19, 21, 2, 27, 2, 2, 2, 2, 2, 449 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 450 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 451 2, 57, 2, 66, 2, 2, 2, 2, 2, 2, 452 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 453 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 454 2, 2, 2, 64, 40, 65, 2, 2, 2, 2, 455 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 456 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 457 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 458 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 459 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 460 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 461 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 462 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 463 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 464 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 465 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 466 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 467 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 468 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 469 15, 16, 17, 18, 22, 23, 24, 25, 26, 31, 470 34, 35, 36, 37, 38, 39, 41, 42, 43, 44, 471 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 472 58, 59 473}; 474 475#if YYDEBUG 476/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 477 YYRHS. */ 478static const unsigned short yyprhs[] = 479{ 480 0, 0, 3, 5, 7, 11, 15, 18, 21, 26, 481 31, 32, 40, 41, 48, 55, 59, 61, 63, 65, 482 67, 70, 73, 76, 79, 80, 82, 86, 90, 96, 483 101, 105, 109, 113, 117, 121, 125, 129, 133, 137, 484 139, 143, 147, 151, 157, 163, 167, 174, 181, 186, 485 190, 194, 198, 200, 202, 204, 206, 208, 210, 214, 486 218, 223, 228, 232, 236, 241, 246, 250, 254, 257, 487 260, 264, 268, 272, 275, 278, 286, 294, 300, 306, 488 309, 310, 314, 316, 318, 319, 321, 323, 325, 327, 489 329, 332, 334, 337, 340, 344, 347, 351, 355, 357, 490 360, 363, 366, 370, 372, 374, 378, 382, 384, 385, 491 390, 394, 395, 402, 403, 408, 412, 413, 420, 423, 492 426 493}; 494 495/* YYRHS -- A `-1'-separated list of the rules' RHS. */ 496static const yysigned_char yyrhs[] = 497{ 498 68, 0, -1, 69, -1, 76, -1, 69, 60, 76, 499 -1, 70, 13, 76, -1, 70, 11, -1, 70, 10, 500 -1, 70, 56, 74, 61, -1, 85, 56, 74, 61, 501 -1, -1, 85, 62, 72, 71, 56, 76, 61, -1, 502 -1, 70, 56, 73, 22, 73, 61, -1, 85, 56, 503 73, 22, 73, 61, -1, 56, 69, 61, -1, 85, 504 -1, 12, -1, 87, -1, 70, -1, 29, 73, -1, 505 28, 73, -1, 36, 73, -1, 37, 73, -1, -1, 506 76, -1, 9, 41, 76, -1, 74, 63, 76, -1, 507 74, 63, 9, 41, 76, -1, 64, 85, 65, 73, 508 -1, 73, 38, 73, -1, 73, 32, 73, -1, 73, 509 33, 73, -1, 73, 34, 73, -1, 73, 35, 73, 510 -1, 73, 27, 73, -1, 73, 28, 73, -1, 73, 511 30, 73, -1, 73, 29, 73, -1, 73, -1, 73, 512 19, 73, -1, 73, 26, 73, -1, 73, 25, 73, 513 -1, 73, 23, 73, 22, 73, -1, 73, 23, 70, 514 53, 82, -1, 73, 23, 85, -1, 73, 36, 23, 515 73, 22, 73, -1, 73, 36, 23, 70, 53, 82, 516 -1, 73, 36, 23, 85, -1, 73, 24, 73, -1, 517 73, 20, 73, -1, 73, 21, 73, -1, 75, -1, 518 77, -1, 78, -1, 79, -1, 80, -1, 81, -1, 519 75, 18, 75, -1, 77, 18, 75, -1, 75, 18, 520 15, 75, -1, 78, 18, 15, 75, -1, 75, 17, 521 75, -1, 79, 17, 75, -1, 75, 17, 14, 75, 522 -1, 80, 17, 14, 75, -1, 75, 16, 75, -1, 523 81, 16, 75, -1, 70, 46, -1, 70, 45, -1, 524 70, 44, 82, -1, 70, 43, 82, -1, 70, 42, 525 82, -1, 70, 52, -1, 70, 51, -1, 84, 48, 526 56, 76, 63, 76, 61, -1, 84, 49, 56, 76, 527 63, 76, 61, -1, 84, 54, 56, 76, 61, -1, 528 83, 50, 56, 76, 61, -1, 83, 47, -1, -1, 529 56, 3, 61, -1, 85, -1, 83, -1, -1, 3, 530 -1, 5, -1, 6, -1, 4, -1, 8, -1, 58, 531 9, -1, 9, -1, 86, 9, -1, 9, 46, -1, 532 86, 9, 46, -1, 9, 7, -1, 86, 9, 7, 533 -1, 56, 88, 61, -1, 90, -1, 89, 76, -1, 534 89, 90, -1, 76, 63, -1, 89, 76, 63, -1, 535 91, -1, 92, -1, 92, 63, 90, -1, 59, 41, 536 76, -1, 93, -1, -1, 9, 41, 94, 76, -1, 537 73, 41, 76, -1, -1, 73, 22, 73, 41, 95, 538 76, -1, -1, 9, 40, 96, 93, -1, 73, 40, 539 93, -1, -1, 73, 22, 73, 40, 97, 93, -1, 540 32, 70, -1, 30, 70, -1, 70, 57, 76, 66, 541 -1 542}; 543 544/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 545static const unsigned short yyrline[] = 546{ 547 0, 224, 224, 228, 229, 231, 236, 240, 244, 250, 548 269, 269, 281, 285, 287, 295, 306, 316, 320, 323, 549 326, 330, 334, 338, 342, 345, 347, 349, 351, 355, 550 368, 372, 376, 380, 384, 388, 392, 396, 400, 404, 551 407, 411, 415, 419, 421, 426, 434, 438, 444, 455, 552 459, 463, 467, 468, 469, 470, 471, 472, 476, 478, 553 483, 485, 490, 492, 497, 499, 503, 505, 517, 519, 554 525, 528, 531, 534, 536, 538, 540, 542, 544, 546, 555 550, 552, 557, 567, 569, 575, 579, 586, 594, 598, 556 604, 608, 610, 612, 620, 631, 633, 638, 647, 648, 557 654, 659, 665, 674, 675, 676, 680, 685, 700, 699, 558 702, 705, 704, 710, 709, 712, 715, 714, 722, 724, 559 726 560}; 561#endif 562 563#if YYDEBUG || YYERROR_VERBOSE 564/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 565 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 566static const char *const yytname[] = 567{ 568 "$end", "error", "$undefined", "INT", "NULL_PTR", "CHARLIT", "FLOAT", 569 "COLONCOLON", "STRING", "NAME", "DOT_ID", "DOT_ALL", "SPECIAL_VARIABLE", 570 "ASSIGN", "ELSE", "THEN", "XOR", "OR", "_AND_", "'='", "'<'", "'>'", 571 "DOTDOT", "IN", "GEQ", "LEQ", "NOTEQUAL", "'@'", "'+'", "'-'", "'&'", 572 "UNARY", "'*'", "'/'", "REM", "MOD", "NOT", "ABS", "STARSTAR", "VAR", 573 "'|'", "ARROW", "TICK_LENGTH", "TICK_LAST", "TICK_FIRST", "TICK_ADDRESS", 574 "TICK_ACCESS", "TICK_MODULUS", "TICK_MIN", "TICK_MAX", "TICK_VAL", 575 "TICK_TAG", "TICK_SIZE", "TICK_RANGE", "TICK_POS", "'.'", "'('", "'['", 576 "NEW", "OTHERS", "';'", "')'", "'''", "','", "'{'", "'}'", "']'", 577 "$accept", "start", "exp1", "primary", "@1", "save_qualifier", 578 "simple_exp", "arglist", "relation", "exp", "and_exp", "and_then_exp", 579 "or_exp", "or_else_exp", "xor_exp", "tick_arglist", "type_prefix", 580 "opt_type_prefix", "var_or_type", "block", "aggregate", 581 "aggregate_component_list", "positional_list", "component_groups", 582 "others", "component_group", "component_associations", "@2", "@3", "@4", 583 "@5", 0 584}; 585#endif 586 587# ifdef YYPRINT 588/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 589 token YYLEX-NUM. */ 590static const unsigned short yytoknum[] = 591{ 592 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 593 265, 266, 267, 268, 269, 270, 271, 272, 273, 61, 594 60, 62, 274, 275, 276, 277, 278, 64, 43, 45, 595 38, 279, 42, 47, 280, 281, 282, 283, 284, 285, 596 124, 286, 287, 288, 289, 290, 291, 292, 293, 294, 597 295, 296, 297, 298, 299, 46, 40, 91, 300, 301, 598 59, 41, 39, 44, 123, 125, 93 599}; 600# endif 601 602/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 603static const unsigned char yyr1[] = 604{ 605 0, 67, 68, 69, 69, 69, 70, 70, 70, 70, 606 71, 70, 72, 70, 70, 70, 70, 70, 70, 73, 607 73, 73, 73, 73, 74, 74, 74, 74, 74, 73, 608 73, 73, 73, 73, 73, 73, 73, 73, 73, 75, 609 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 610 75, 75, 76, 76, 76, 76, 76, 76, 77, 77, 611 78, 78, 79, 79, 80, 80, 81, 81, 70, 70, 612 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 613 82, 82, 83, 84, 84, 70, 70, 70, 70, 70, 614 70, 85, 85, 85, 85, 86, 86, 87, 88, 88, 615 88, 89, 89, 90, 90, 90, 91, 92, 94, 93, 616 93, 95, 93, 96, 93, 93, 97, 93, 70, 70, 617 70 618}; 619 620/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 621static const unsigned char yyr2[] = 622{ 623 0, 2, 1, 1, 3, 3, 2, 2, 4, 4, 624 0, 7, 0, 6, 6, 3, 1, 1, 1, 1, 625 2, 2, 2, 2, 0, 1, 3, 3, 5, 4, 626 3, 3, 3, 3, 3, 3, 3, 3, 3, 1, 627 3, 3, 3, 5, 5, 3, 6, 6, 4, 3, 628 3, 3, 1, 1, 1, 1, 1, 1, 3, 3, 629 4, 4, 3, 3, 4, 4, 3, 3, 2, 2, 630 3, 3, 3, 2, 2, 7, 7, 5, 5, 2, 631 0, 3, 1, 1, 0, 1, 1, 1, 1, 1, 632 2, 1, 2, 2, 3, 2, 3, 3, 1, 2, 633 2, 2, 3, 1, 1, 3, 3, 1, 0, 4, 634 3, 0, 6, 0, 4, 3, 0, 6, 2, 2, 635 4 636}; 637 638/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state 639 STATE-NUM when YYTABLE doesn't specify something else to do. Zero 640 means the default is an error. */ 641static const unsigned char yydefact[] = 642{ 643 84, 85, 88, 86, 87, 89, 91, 17, 84, 84, 644 84, 84, 84, 84, 84, 0, 0, 0, 2, 19, 645 39, 52, 3, 53, 54, 55, 56, 57, 83, 0, 646 16, 0, 18, 95, 93, 19, 21, 20, 119, 118, 647 22, 23, 91, 0, 0, 39, 3, 0, 84, 98, 648 103, 104, 107, 90, 0, 1, 84, 7, 6, 84, 649 80, 80, 80, 69, 68, 74, 73, 84, 84, 84, 650 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 651 84, 84, 84, 84, 0, 84, 84, 84, 84, 84, 652 0, 84, 0, 84, 79, 0, 0, 0, 0, 84, 653 12, 92, 113, 108, 84, 15, 84, 84, 84, 101, 654 97, 99, 100, 84, 84, 4, 5, 0, 72, 71, 655 70, 91, 39, 0, 25, 0, 40, 50, 51, 19, 656 0, 16, 49, 42, 41, 35, 36, 38, 37, 31, 657 32, 33, 34, 84, 30, 66, 84, 62, 84, 58, 658 59, 84, 63, 84, 67, 84, 84, 84, 84, 39, 659 0, 10, 96, 94, 84, 84, 106, 0, 0, 115, 660 110, 102, 105, 29, 0, 84, 84, 8, 84, 120, 661 80, 84, 19, 0, 16, 64, 60, 61, 65, 0, 662 0, 0, 0, 84, 9, 0, 114, 109, 116, 111, 663 81, 26, 0, 91, 27, 44, 43, 80, 84, 78, 664 84, 84, 77, 0, 84, 84, 84, 13, 84, 47, 665 46, 0, 0, 14, 0, 117, 112, 28, 75, 76, 666 11 667}; 668 669/* YYDEFGOTO[NTERM-NUM]. */ 670static const short yydefgoto[] = 671{ 672 -1, 17, 18, 35, 195, 161, 20, 123, 21, 124, 673 23, 24, 25, 26, 27, 118, 28, 29, 30, 31, 674 32, 47, 48, 49, 50, 51, 52, 165, 216, 164, 675 215 676}; 677 678/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 679 STATE-NUM. */ 680#define YYPACT_NINF -104 681static const short yypact[] = 682{ 683 396, -104, -104, -104, -104, -104, 16, -104, 396, 396, 684 121, 121, 396, 396, 282, 2, 6, 9, -28, 150, 685 629, 89, -104, 20, 24, 33, 41, 35, 43, 18, 686 275, 55, -104, -104, -104, 513, -7, -7, -3, -3, 687 -7, -7, 3, 28, -14, 566, 25, 31, 282, -104, 688 -104, 37, -104, -104, 44, -104, 396, -104, -104, 396, 689 42, 42, 42, -104, -104, -104, -104, 272, 396, 396, 690 396, 396, 396, 396, 396, 396, 396, 396, 396, 396, 691 396, 396, 396, 396, 79, 396, 396, 339, 351, 396, 692 50, 396, 99, 396, -104, 58, 59, 60, 63, 272, 693 -104, 17, -104, -104, 396, -104, 396, 408, 396, -104, 694 -104, 57, -104, 282, 396, -104, -104, 119, -104, -104, 695 -104, -1, 589, -41, -104, 65, 656, 656, 656, 476, 696 215, 173, 656, 656, 656, 667, -7, -7, -7, 85, 697 85, 85, 85, 396, 85, -104, 396, -104, 396, -104, 698 -104, 396, -104, 396, -104, 396, 396, 396, 396, 609, 699 34, -104, -104, -104, 408, 396, -104, 641, 466, -104, 700 -104, -104, -104, -104, 71, 396, 396, -104, 453, -104, 701 42, 396, 492, 441, 208, -104, -104, -104, -104, 73, 702 76, 81, 84, 396, -104, 93, -104, -104, -104, -104, 703 -104, -104, 108, 14, -104, -104, 656, 42, 396, -104, 704 396, 396, -104, 544, 396, 408, 396, -104, 396, -104, 705 656, 91, 98, -104, 103, -104, -104, -104, -104, -104, 706 -104 707}; 708 709/* YYPGOTO[NTERM-NUM]. */ 710static const short yypgoto[] = 711{ 712 -104, -104, 136, 19, -104, -104, 4, 67, -52, 0, 713 -104, -104, -104, -104, -104, -59, -104, -104, -15, -104, 714 -104, -104, -104, -43, -104, -104, -103, -104, -104, -104, 715 -104 716}; 717 718/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 719 positive, shift that token. If negative, reduce the rule which 720 number is the opposite. If zero, do what YYDEFACT says. 721 If YYTABLE_NINF, syntax error. */ 722#define YYTABLE_NINF -83 723static const short yytable[] = 724{ 725 22, 54, 119, 120, 169, 112, 33, 57, 58, 55, 726 33, 53, 36, 37, 46, 6, 40, 41, 45, 19, 727 177, 33, 178, 33, 162, 80, 81, 82, 83, 38, 728 39, 85, 56, 19, 145, 147, 149, 150, 89, 152, 729 175, 154, 90, 102, 103, 34, 56, 105, 111, 34, 730 91, 93, 45, 67, 68, 218, 115, 131, 92, 116, 731 34, 196, 34, 163, 101, 151, 96, 97, 125, 104, 732 172, 122, 98, 126, 127, 128, 130, 132, 133, 134, 733 135, 136, 137, 138, 139, 140, 141, 142, 109, 144, 734 94, 129, 110, 95, 185, 194, 186, 178, 117, 187, 735 113, 188, 143, 159, 166, 86, 87, 88, 170, 114, 736 167, 168, 225, 153, 155, 156, 157, 168, 173, 158, 737 171, 205, 174, 85, 1, 2, 3, 4, 184, 5, 738 6, 179, 200, 7, 209, 76, 77, 78, 79, 210, 739 80, 81, 82, 83, 211, 212, 85, 183, 219, 214, 740 44, 10, 228, 11, 0, 189, 190, 191, 192, 229, 741 57, 58, 182, 59, 230, 197, 160, 0, 168, 217, 742 0, 0, 0, -45, 0, 201, 0, 14, 204, 15, 743 202, 0, 0, 0, 0, 206, 0, 0, 0, -45, 744 -45, -45, 60, 61, 62, 63, 64, 213, 0, 0, 745 0, 65, 66, 0, 0, 0, 67, 68, -48, 0, 746 221, 222, 220, 0, 224, 0, 226, 0, 227, 168, 747 -82, -82, -82, -82, -48, -48, -48, -82, 0, 99, 748 0, 0, 0, -45, -45, 100, -45, 181, 0, -45, 749 0, 0, 76, 77, 78, 79, 0, 80, 81, 82, 750 83, 0, 0, 85, 0, -82, -82, -82, -82, 0, 751 0, 0, -82, 0, 99, 0, 0, 0, -48, -48, 752 100, -48, 0, 0, -48, 1, 2, 3, 4, 0, 753 5, 121, 0, 0, 7, 1, 2, 3, 4, 0, 754 5, 42, 0, 0, 7, 0, 0, 0, 0, 0, 755 8, 9, 10, 0, 11, 0, 0, 0, 12, 13, 756 8, 9, 10, 0, 11, 0, 0, 0, 12, 13, 757 0, 0, -82, -82, -82, -82, 0, 0, 14, -82, 758 15, 99, 0, -24, 0, -24, 16, 100, 14, 0, 759 15, 43, 1, 2, 3, 4, 16, 5, 6, 0, 760 0, 7, 0, 146, 1, 2, 3, 4, 0, 5, 761 6, 0, 0, 7, 0, 0, 148, 8, 9, 10, 762 0, 11, 0, 0, 0, 12, 13, 0, 0, 8, 763 9, 10, 0, 11, 0, 0, 0, 12, 13, 0, 764 0, 0, 0, 0, 0, 14, 0, 15, 0, 1, 765 2, 3, 4, 16, 5, 6, 0, 14, 7, 15, 766 0, 1, 2, 3, 4, 16, 5, 42, 0, 0, 767 7, 0, 0, 0, 8, 9, 10, 0, 11, 0, 768 0, 0, 12, 13, 0, 0, 8, 9, 10, 0, 769 11, 0, 0, 0, 12, 13, 0, 0, 0, 0, 770 0, 0, 14, 0, 15, 0, 1, 2, 3, 4, 771 16, 5, 203, 208, 14, 7, 15, 0, 76, 77, 772 78, 79, 16, 80, 81, 82, 83, 0, 0, 85, 773 0, 8, 9, 10, 0, 11, 57, 58, 106, 12, 774 13, 0, 0, 76, 77, 78, 79, 0, 80, 81, 775 82, 83, 57, 58, 85, 0, 107, 108, 0, 14, 776 0, 15, 0, 0, 0, 0, 0, 16, 60, 61, 777 62, 63, 64, 57, 58, 0, 0, 65, 66, 180, 778 0, 0, 67, 68, 60, 61, 62, 63, 64, 0, 779 0, 0, 0, 65, 66, 207, 0, 0, 67, 68, 780 0, 0, 0, 0, 0, 60, 61, 62, 63, 64, 781 0, 0, 0, 0, 65, 66, 0, 0, 0, 67, 782 68, 76, 77, 78, 79, 0, 80, 81, 82, 83, 783 0, 0, 85, 0, 0, 69, 70, 71, 106, 72, 784 73, 74, 75, 76, 77, 78, 79, 0, 80, 81, 785 82, 83, 84, 0, 85, 223, 107, 108, 69, 70, 786 71, 176, 72, 73, 74, 75, 76, 77, 78, 79, 787 0, 80, 81, 82, 83, 84, 0, 85, 69, 70, 788 71, 193, 72, 73, 74, 75, 76, 77, 78, 79, 789 0, 80, 81, 82, 83, 84, 0, 85, 69, 70, 790 71, 0, 72, 73, 74, 75, 76, 77, 78, 79, 791 0, 80, 81, 82, 83, 84, 0, 85, 76, 77, 792 78, 79, 0, 80, 81, 82, 83, 0, 0, 85, 793 0, 198, 199, 76, 77, 78, 79, 0, 80, 81, 794 82, 83, 0, 0, 85, 77, 78, 79, 0, 80, 795 81, 82, 83, 0, 0, 85 796}; 797 798static const short yycheck[] = 799{ 800 0, 16, 61, 62, 107, 48, 7, 10, 11, 0, 801 7, 9, 8, 9, 14, 9, 12, 13, 14, 0, 802 61, 7, 63, 7, 7, 32, 33, 34, 35, 10, 803 11, 38, 60, 14, 86, 87, 88, 89, 18, 91, 804 41, 93, 18, 40, 41, 46, 60, 61, 48, 46, 805 17, 16, 48, 56, 57, 41, 56, 72, 17, 59, 806 46, 164, 46, 46, 9, 15, 48, 49, 68, 41, 807 113, 67, 54, 69, 70, 71, 72, 73, 74, 75, 808 76, 77, 78, 79, 80, 81, 82, 83, 63, 85, 809 47, 72, 61, 50, 146, 61, 148, 63, 56, 151, 810 63, 153, 23, 99, 104, 16, 17, 18, 108, 65, 811 106, 107, 215, 14, 56, 56, 56, 113, 114, 56, 812 63, 180, 3, 38, 3, 4, 5, 6, 143, 8, 813 9, 66, 61, 12, 61, 27, 28, 29, 30, 63, 814 32, 33, 34, 35, 63, 61, 38, 143, 207, 56, 815 14, 30, 61, 32, -1, 155, 156, 157, 158, 61, 816 10, 11, 143, 13, 61, 165, 99, -1, 164, 61, 817 -1, -1, -1, 0, -1, 175, -1, 56, 178, 58, 818 176, -1, -1, -1, -1, 181, -1, -1, -1, 16, 819 17, 18, 42, 43, 44, 45, 46, 193, -1, -1, 820 -1, 51, 52, -1, -1, -1, 56, 57, 0, -1, 821 210, 211, 208, -1, 214, -1, 216, -1, 218, 215, 822 47, 48, 49, 50, 16, 17, 18, 54, -1, 56, 823 -1, -1, -1, 60, 61, 62, 63, 22, -1, 66, 824 -1, -1, 27, 28, 29, 30, -1, 32, 33, 34, 825 35, -1, -1, 38, -1, 47, 48, 49, 50, -1, 826 -1, -1, 54, -1, 56, -1, -1, -1, 60, 61, 827 62, 63, -1, -1, 66, 3, 4, 5, 6, -1, 828 8, 9, -1, -1, 12, 3, 4, 5, 6, -1, 829 8, 9, -1, -1, 12, -1, -1, -1, -1, -1, 830 28, 29, 30, -1, 32, -1, -1, -1, 36, 37, 831 28, 29, 30, -1, 32, -1, -1, -1, 36, 37, 832 -1, -1, 47, 48, 49, 50, -1, -1, 56, 54, 833 58, 56, -1, 61, -1, 63, 64, 62, 56, -1, 834 58, 59, 3, 4, 5, 6, 64, 8, 9, -1, 835 -1, 12, -1, 14, 3, 4, 5, 6, -1, 8, 836 9, -1, -1, 12, -1, -1, 15, 28, 29, 30, 837 -1, 32, -1, -1, -1, 36, 37, -1, -1, 28, 838 29, 30, -1, 32, -1, -1, -1, 36, 37, -1, 839 -1, -1, -1, -1, -1, 56, -1, 58, -1, 3, 840 4, 5, 6, 64, 8, 9, -1, 56, 12, 58, 841 -1, 3, 4, 5, 6, 64, 8, 9, -1, -1, 842 12, -1, -1, -1, 28, 29, 30, -1, 32, -1, 843 -1, -1, 36, 37, -1, -1, 28, 29, 30, -1, 844 32, -1, -1, -1, 36, 37, -1, -1, -1, -1, 845 -1, -1, 56, -1, 58, -1, 3, 4, 5, 6, 846 64, 8, 9, 22, 56, 12, 58, -1, 27, 28, 847 29, 30, 64, 32, 33, 34, 35, -1, -1, 38, 848 -1, 28, 29, 30, -1, 32, 10, 11, 22, 36, 849 37, -1, -1, 27, 28, 29, 30, -1, 32, 33, 850 34, 35, 10, 11, 38, -1, 40, 41, -1, 56, 851 -1, 58, -1, -1, -1, -1, -1, 64, 42, 43, 852 44, 45, 46, 10, 11, -1, -1, 51, 52, 53, 853 -1, -1, 56, 57, 42, 43, 44, 45, 46, -1, 854 -1, -1, -1, 51, 52, 53, -1, -1, 56, 57, 855 -1, -1, -1, -1, -1, 42, 43, 44, 45, 46, 856 -1, -1, -1, -1, 51, 52, -1, -1, -1, 56, 857 57, 27, 28, 29, 30, -1, 32, 33, 34, 35, 858 -1, -1, 38, -1, -1, 19, 20, 21, 22, 23, 859 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 860 34, 35, 36, -1, 38, 61, 40, 41, 19, 20, 861 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 862 -1, 32, 33, 34, 35, 36, -1, 38, 19, 20, 863 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 864 -1, 32, 33, 34, 35, 36, -1, 38, 19, 20, 865 21, -1, 23, 24, 25, 26, 27, 28, 29, 30, 866 -1, 32, 33, 34, 35, 36, -1, 38, 27, 28, 867 29, 30, -1, 32, 33, 34, 35, -1, -1, 38, 868 -1, 40, 41, 27, 28, 29, 30, -1, 32, 33, 869 34, 35, -1, -1, 38, 28, 29, 30, -1, 32, 870 33, 34, 35, -1, -1, 38 871}; 872 873/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 874 symbol of state STATE-NUM. */ 875static const unsigned char yystos[] = 876{ 877 0, 3, 4, 5, 6, 8, 9, 12, 28, 29, 878 30, 32, 36, 37, 56, 58, 64, 68, 69, 70, 879 73, 75, 76, 77, 78, 79, 80, 81, 83, 84, 880 85, 86, 87, 7, 46, 70, 73, 73, 70, 70, 881 73, 73, 9, 59, 69, 73, 76, 88, 89, 90, 882 91, 92, 93, 9, 85, 0, 60, 10, 11, 13, 883 42, 43, 44, 45, 46, 51, 52, 56, 57, 19, 884 20, 21, 23, 24, 25, 26, 27, 28, 29, 30, 885 32, 33, 34, 35, 36, 38, 16, 17, 18, 18, 886 18, 17, 17, 16, 47, 50, 48, 49, 54, 56, 887 62, 9, 40, 41, 41, 61, 22, 40, 41, 63, 888 61, 76, 90, 63, 65, 76, 76, 56, 82, 82, 889 82, 9, 73, 74, 76, 76, 73, 73, 73, 70, 890 73, 85, 73, 73, 73, 73, 73, 73, 73, 73, 891 73, 73, 73, 23, 73, 75, 14, 75, 15, 75, 892 75, 15, 75, 14, 75, 56, 56, 56, 56, 73, 893 74, 72, 7, 46, 96, 94, 76, 73, 73, 93, 894 76, 63, 90, 73, 3, 41, 22, 61, 63, 66, 895 53, 22, 70, 73, 85, 75, 75, 75, 75, 76, 896 76, 76, 76, 22, 61, 71, 93, 76, 40, 41, 897 61, 76, 73, 9, 76, 82, 73, 53, 22, 61, 898 63, 63, 61, 73, 56, 97, 95, 61, 41, 82, 899 73, 76, 76, 61, 76, 93, 76, 76, 61, 61, 900 61 901}; 902 903#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) 904# define YYSIZE_T __SIZE_TYPE__ 905#endif 906#if ! defined (YYSIZE_T) && defined (size_t) 907# define YYSIZE_T size_t 908#endif 909#if ! defined (YYSIZE_T) 910# if defined (__STDC__) || defined (__cplusplus) 911# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 912# define YYSIZE_T size_t 913# endif 914#endif 915#if ! defined (YYSIZE_T) 916# define YYSIZE_T unsigned int 917#endif 918 919#define yyerrok (yyerrstatus = 0) 920#define yyclearin (yychar = YYEMPTY) 921#define YYEMPTY (-2) 922#define YYEOF 0 923 924#define YYACCEPT goto yyacceptlab 925#define YYABORT goto yyabortlab 926#define YYERROR goto yyerrorlab 927 928 929/* Like YYERROR except do call yyerror. This remains here temporarily 930 to ease the transition to the new meaning of YYERROR, for GCC. 931 Once GCC version 2 has supplanted version 1, this can go. */ 932 933#define YYFAIL goto yyerrlab 934 935#define YYRECOVERING() (!!yyerrstatus) 936 937#define YYBACKUP(Token, Value) \ 938do \ 939 if (yychar == YYEMPTY && yylen == 1) \ 940 { \ 941 yychar = (Token); \ 942 yylval = (Value); \ 943 yytoken = YYTRANSLATE (yychar); \ 944 YYPOPSTACK; \ 945 goto yybackup; \ 946 } \ 947 else \ 948 { \ 949 yyerror ("syntax error: cannot back up");\ 950 YYERROR; \ 951 } \ 952while (0) 953 954#define YYTERROR 1 955#define YYERRCODE 256 956 957/* YYLLOC_DEFAULT -- Compute the default location (before the actions 958 are run). */ 959 960#ifndef YYLLOC_DEFAULT 961# define YYLLOC_DEFAULT(Current, Rhs, N) \ 962 ((Current).first_line = (Rhs)[1].first_line, \ 963 (Current).first_column = (Rhs)[1].first_column, \ 964 (Current).last_line = (Rhs)[N].last_line, \ 965 (Current).last_column = (Rhs)[N].last_column) 966#endif 967 968/* YYLEX -- calling `yylex' with the right arguments. */ 969 970#ifdef YYLEX_PARAM 971# define YYLEX yylex (YYLEX_PARAM) 972#else 973# define YYLEX yylex () 974#endif 975 976/* Enable debugging if requested. */ 977#if YYDEBUG 978 979# ifndef YYFPRINTF 980# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 981# define YYFPRINTF fprintf 982# endif 983 984# define YYDPRINTF(Args) \ 985do { \ 986 if (yydebug) \ 987 YYFPRINTF Args; \ 988} while (0) 989 990# define YYDSYMPRINT(Args) \ 991do { \ 992 if (yydebug) \ 993 yysymprint Args; \ 994} while (0) 995 996# define YYDSYMPRINTF(Title, Token, Value, Location) \ 997do { \ 998 if (yydebug) \ 999 { \ 1000 YYFPRINTF (stderr, "%s ", Title); \ 1001 yysymprint (stderr, \ 1002 Token, Value); \ 1003 YYFPRINTF (stderr, "\n"); \ 1004 } \ 1005} while (0) 1006 1007/*------------------------------------------------------------------. 1008| yy_stack_print -- Print the state stack from its BOTTOM up to its | 1009| TOP (included). | 1010`------------------------------------------------------------------*/ 1011 1012#if defined (__STDC__) || defined (__cplusplus) 1013static void 1014yy_stack_print (short *bottom, short *top) 1015#else 1016static void 1017yy_stack_print (bottom, top) 1018 short *bottom; 1019 short *top; 1020#endif 1021{ 1022 YYFPRINTF (stderr, "Stack now"); 1023 for (/* Nothing. */; bottom <= top; ++bottom) 1024 YYFPRINTF (stderr, " %d", *bottom); 1025 YYFPRINTF (stderr, "\n"); 1026} 1027 1028# define YY_STACK_PRINT(Bottom, Top) \ 1029do { \ 1030 if (yydebug) \ 1031 yy_stack_print ((Bottom), (Top)); \ 1032} while (0) 1033 1034 1035/*------------------------------------------------. 1036| Report that the YYRULE is going to be reduced. | 1037`------------------------------------------------*/ 1038 1039#if defined (__STDC__) || defined (__cplusplus) 1040static void 1041yy_reduce_print (int yyrule) 1042#else 1043static void 1044yy_reduce_print (yyrule) 1045 int yyrule; 1046#endif 1047{ 1048 int yyi; 1049 unsigned int yylno = yyrline[yyrule]; 1050 YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ", 1051 yyrule - 1, yylno); 1052 /* Print the symbols being reduced, and their result. */ 1053 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) 1054 YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]); 1055 YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]); 1056} 1057 1058# define YY_REDUCE_PRINT(Rule) \ 1059do { \ 1060 if (yydebug) \ 1061 yy_reduce_print (Rule); \ 1062} while (0) 1063 1064/* Nonzero means print parse trace. It is left uninitialized so that 1065 multiple parsers can coexist. */ 1066int yydebug; 1067#else /* !YYDEBUG */ 1068# define YYDPRINTF(Args) 1069# define YYDSYMPRINT(Args) 1070# define YYDSYMPRINTF(Title, Token, Value, Location) 1071# define YY_STACK_PRINT(Bottom, Top) 1072# define YY_REDUCE_PRINT(Rule) 1073#endif /* !YYDEBUG */ 1074 1075 1076/* YYINITDEPTH -- initial size of the parser's stacks. */ 1077#ifndef YYINITDEPTH 1078# define YYINITDEPTH 200 1079#endif 1080 1081/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 1082 if the built-in stack extension method is used). 1083 1084 Do not make this value too large; the results are undefined if 1085 SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) 1086 evaluated with infinite-precision integer arithmetic. */ 1087 1088#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0 1089# undef YYMAXDEPTH 1090#endif 1091 1092#ifndef YYMAXDEPTH 1093# define YYMAXDEPTH 10000 1094#endif 1095 1096 1097 1098#if YYERROR_VERBOSE 1099 1100# ifndef yystrlen 1101# if defined (__GLIBC__) && defined (_STRING_H) 1102# define yystrlen strlen 1103# else 1104/* Return the length of YYSTR. */ 1105static YYSIZE_T 1106# if defined (__STDC__) || defined (__cplusplus) 1107yystrlen (const char *yystr) 1108# else 1109yystrlen (yystr) 1110 const char *yystr; 1111# endif 1112{ 1113 register const char *yys = yystr; 1114 1115 while (*yys++ != '\0') 1116 continue; 1117 1118 return yys - yystr - 1; 1119} 1120# endif 1121# endif 1122 1123# ifndef yystpcpy 1124# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) 1125# define yystpcpy stpcpy 1126# else 1127/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 1128 YYDEST. */ 1129static char * 1130# if defined (__STDC__) || defined (__cplusplus) 1131yystpcpy (char *yydest, const char *yysrc) 1132# else 1133yystpcpy (yydest, yysrc) 1134 char *yydest; 1135 const char *yysrc; 1136# endif 1137{ 1138 register char *yyd = yydest; 1139 register const char *yys = yysrc; 1140 1141 while ((*yyd++ = *yys++) != '\0') 1142 continue; 1143 1144 return yyd - 1; 1145} 1146# endif 1147# endif 1148 1149#endif /* !YYERROR_VERBOSE */ 1150 1151 1152 1153#if YYDEBUG 1154/*--------------------------------. 1155| Print this symbol on YYOUTPUT. | 1156`--------------------------------*/ 1157 1158#if defined (__STDC__) || defined (__cplusplus) 1159static void 1160yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep) 1161#else 1162static void 1163yysymprint (yyoutput, yytype, yyvaluep) 1164 FILE *yyoutput; 1165 int yytype; 1166 YYSTYPE *yyvaluep; 1167#endif 1168{ 1169 /* Pacify ``unused variable'' warnings. */ 1170 (void) yyvaluep; 1171 1172 if (yytype < YYNTOKENS) 1173 { 1174 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 1175# ifdef YYPRINT 1176 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 1177# endif 1178 } 1179 else 1180 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 1181 1182 switch (yytype) 1183 { 1184 default: 1185 break; 1186 } 1187 YYFPRINTF (yyoutput, ")"); 1188} 1189 1190#endif /* ! YYDEBUG */ 1191/*-----------------------------------------------. 1192| Release the memory associated to this symbol. | 1193`-----------------------------------------------*/ 1194 1195#if defined (__STDC__) || defined (__cplusplus) 1196static void 1197yydestruct (int yytype, YYSTYPE *yyvaluep) 1198#else 1199static void 1200yydestruct (yytype, yyvaluep) 1201 int yytype; 1202 YYSTYPE *yyvaluep; 1203#endif 1204{ 1205 /* Pacify ``unused variable'' warnings. */ 1206 (void) yyvaluep; 1207 1208 switch (yytype) 1209 { 1210 1211 default: 1212 break; 1213 } 1214} 1215 1216 1217/* Prevent warnings from -Wmissing-prototypes. */ 1218 1219#ifdef YYPARSE_PARAM 1220# if defined (__STDC__) || defined (__cplusplus) 1221int yyparse (void *YYPARSE_PARAM); 1222# else 1223int yyparse (); 1224# endif 1225#else /* ! YYPARSE_PARAM */ 1226#if defined (__STDC__) || defined (__cplusplus) 1227int yyparse (void); 1228#else 1229int yyparse (); 1230#endif 1231#endif /* ! YYPARSE_PARAM */ 1232 1233 1234 1235/* The lookahead symbol. */ 1236int yychar; 1237 1238/* The semantic value of the lookahead symbol. */ 1239YYSTYPE yylval; 1240 1241/* Number of syntax errors so far. */ 1242int yynerrs; 1243 1244 1245 1246/*----------. 1247| yyparse. | 1248`----------*/ 1249 1250#ifdef YYPARSE_PARAM 1251# if defined (__STDC__) || defined (__cplusplus) 1252int yyparse (void *YYPARSE_PARAM) 1253# else 1254int yyparse (YYPARSE_PARAM) 1255 void *YYPARSE_PARAM; 1256# endif 1257#else /* ! YYPARSE_PARAM */ 1258#if defined (__STDC__) || defined (__cplusplus) 1259int 1260yyparse (void) 1261#else 1262int 1263yyparse () 1264 1265#endif 1266#endif 1267{ 1268 1269 register int yystate; 1270 register int yyn; 1271 int yyresult; 1272 /* Number of tokens to shift before error messages enabled. */ 1273 int yyerrstatus; 1274 /* Lookahead token as an internal (translated) token number. */ 1275 int yytoken = 0; 1276 1277 /* Three stacks and their tools: 1278 `yyss': related to states, 1279 `yyvs': related to semantic values, 1280 `yyls': related to locations. 1281 1282 Refer to the stacks thru separate pointers, to allow yyoverflow 1283 to xreallocate them elsewhere. */ 1284 1285 /* The state stack. */ 1286 short yyssa[YYINITDEPTH]; 1287 short *yyss = yyssa; 1288 register short *yyssp; 1289 1290 /* The semantic value stack. */ 1291 YYSTYPE yyvsa[YYINITDEPTH]; 1292 YYSTYPE *yyvs = yyvsa; 1293 register YYSTYPE *yyvsp; 1294 1295 1296 1297#define YYPOPSTACK (yyvsp--, yyssp--) 1298 1299 YYSIZE_T yystacksize = YYINITDEPTH; 1300 1301 /* The variables used to return semantic value and location from the 1302 action routines. */ 1303 YYSTYPE yyval; 1304 1305 1306 /* When reducing, the number of symbols on the RHS of the reduced 1307 rule. */ 1308 int yylen; 1309 1310 YYDPRINTF ((stderr, "Starting parse\n")); 1311 1312 yystate = 0; 1313 yyerrstatus = 0; 1314 yynerrs = 0; 1315 yychar = YYEMPTY; /* Cause a token to be read. */ 1316 1317 /* Initialize stack pointers. 1318 Waste one element of value and location stack 1319 so that they stay on the same level as the state stack. 1320 The wasted elements are never initialized. */ 1321 1322 yyssp = yyss; 1323 yyvsp = yyvs; 1324 1325 goto yysetstate; 1326 1327/*------------------------------------------------------------. 1328| yynewstate -- Push a new state, which is found in yystate. | 1329`------------------------------------------------------------*/ 1330 yynewstate: 1331 /* In all cases, when you get here, the value and location stacks 1332 have just been pushed. so pushing a state here evens the stacks. 1333 */ 1334 yyssp++; 1335 1336 yysetstate: 1337 *yyssp = yystate; 1338 1339 if (yyss + yystacksize - 1 <= yyssp) 1340 { 1341 /* Get the current used size of the three stacks, in elements. */ 1342 YYSIZE_T yysize = yyssp - yyss + 1; 1343 1344#ifdef yyoverflow 1345 { 1346 /* Give user a chance to xreallocate the stack. Use copies of 1347 these so that the &'s don't force the real ones into 1348 memory. */ 1349 YYSTYPE *yyvs1 = yyvs; 1350 short *yyss1 = yyss; 1351 1352 1353 /* Each stack pointer address is followed by the size of the 1354 data in use in that stack, in bytes. This used to be a 1355 conditional around just the two extra args, but that might 1356 be undefined if yyoverflow is a macro. */ 1357 yyoverflow ("parser stack overflow", 1358 &yyss1, yysize * sizeof (*yyssp), 1359 &yyvs1, yysize * sizeof (*yyvsp), 1360 1361 &yystacksize); 1362 1363 yyss = yyss1; 1364 yyvs = yyvs1; 1365 } 1366#else /* no yyoverflow */ 1367# ifndef YYSTACK_RELOCATE 1368 goto yyoverflowlab; 1369# else 1370 /* Extend the stack our own way. */ 1371 if (YYMAXDEPTH <= yystacksize) 1372 goto yyoverflowlab; 1373 yystacksize *= 2; 1374 if (YYMAXDEPTH < yystacksize) 1375 yystacksize = YYMAXDEPTH; 1376 1377 { 1378 short *yyss1 = yyss; 1379 union yyalloc *yyptr = 1380 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1381 if (! yyptr) 1382 goto yyoverflowlab; 1383 YYSTACK_RELOCATE (yyss); 1384 YYSTACK_RELOCATE (yyvs); 1385 1386# undef YYSTACK_RELOCATE 1387 if (yyss1 != yyssa) 1388 YYSTACK_FREE (yyss1); 1389 } 1390# endif 1391#endif /* no yyoverflow */ 1392 1393 yyssp = yyss + yysize - 1; 1394 yyvsp = yyvs + yysize - 1; 1395 1396 1397 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1398 (unsigned long int) yystacksize)); 1399 1400 if (yyss + yystacksize - 1 <= yyssp) 1401 YYABORT; 1402 } 1403 1404 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1405 1406 goto yybackup; 1407 1408/*-----------. 1409| yybackup. | 1410`-----------*/ 1411yybackup: 1412 1413/* Do appropriate processing given the current state. */ 1414/* Read a lookahead token if we need one and don't already have one. */ 1415/* yyresume: */ 1416 1417 /* First try to decide what to do without reference to lookahead token. */ 1418 1419 yyn = yypact[yystate]; 1420 if (yyn == YYPACT_NINF) 1421 goto yydefault; 1422 1423 /* Not known => get a lookahead token if don't already have one. */ 1424 1425 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 1426 if (yychar == YYEMPTY) 1427 { 1428 YYDPRINTF ((stderr, "Reading a token: ")); 1429 yychar = YYLEX; 1430 } 1431 1432 if (yychar <= YYEOF) 1433 { 1434 yychar = yytoken = YYEOF; 1435 YYDPRINTF ((stderr, "Now at end of input.\n")); 1436 } 1437 else 1438 { 1439 yytoken = YYTRANSLATE (yychar); 1440 YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc); 1441 } 1442 1443 /* If the proper action on seeing token YYTOKEN is to reduce or to 1444 detect an error, take that action. */ 1445 yyn += yytoken; 1446 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1447 goto yydefault; 1448 yyn = yytable[yyn]; 1449 if (yyn <= 0) 1450 { 1451 if (yyn == 0 || yyn == YYTABLE_NINF) 1452 goto yyerrlab; 1453 yyn = -yyn; 1454 goto yyreduce; 1455 } 1456 1457 if (yyn == YYFINAL) 1458 YYACCEPT; 1459 1460 /* Shift the lookahead token. */ 1461 YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken])); 1462 1463 /* Discard the token being shifted unless it is eof. */ 1464 if (yychar != YYEOF) 1465 yychar = YYEMPTY; 1466 1467 *++yyvsp = yylval; 1468 1469 1470 /* Count tokens shifted since error; after three, turn off error 1471 status. */ 1472 if (yyerrstatus) 1473 yyerrstatus--; 1474 1475 yystate = yyn; 1476 goto yynewstate; 1477 1478 1479/*-----------------------------------------------------------. 1480| yydefault -- do the default action for the current state. | 1481`-----------------------------------------------------------*/ 1482yydefault: 1483 yyn = yydefact[yystate]; 1484 if (yyn == 0) 1485 goto yyerrlab; 1486 goto yyreduce; 1487 1488 1489/*-----------------------------. 1490| yyreduce -- Do a reduction. | 1491`-----------------------------*/ 1492yyreduce: 1493 /* yyn is the number of a rule to reduce with. */ 1494 yylen = yyr2[yyn]; 1495 1496 /* If YYLEN is nonzero, implement the default value of the action: 1497 `$$ = $1'. 1498 1499 Otherwise, the following line sets YYVAL to garbage. 1500 This behavior is undocumented and Bison 1501 users should not rely upon it. Assigning to YYVAL 1502 unconditionally makes the parser a bit smaller, and it avoids a 1503 GCC warning that YYVAL may be used uninitialized. */ 1504 yyval = yyvsp[1-yylen]; 1505 1506 1507 YY_REDUCE_PRINT (yyn); 1508 switch (yyn) 1509 { 1510 case 4: 1511#line 230 "ada-exp.y" 1512 { write_exp_elt_opcode (BINOP_COMMA); } 1513 break; 1514 1515 case 5: 1516#line 232 "ada-exp.y" 1517 { write_exp_elt_opcode (BINOP_ASSIGN); } 1518 break; 1519 1520 case 6: 1521#line 237 "ada-exp.y" 1522 { write_exp_elt_opcode (UNOP_IND); } 1523 break; 1524 1525 case 7: 1526#line 241 "ada-exp.y" 1527 { write_exp_op_with_string (STRUCTOP_STRUCT, yyvsp[0].sval); } 1528 break; 1529 1530 case 8: 1531#line 245 "ada-exp.y" 1532 { 1533 write_exp_elt_opcode (OP_FUNCALL); 1534 write_exp_elt_longcst (yyvsp[-1].lval); 1535 write_exp_elt_opcode (OP_FUNCALL); 1536 } 1537 break; 1538 1539 case 9: 1540#line 251 "ada-exp.y" 1541 { 1542 if (yyvsp[-3].tval != NULL) 1543 { 1544 if (yyvsp[-1].lval != 1) 1545 error (_("Invalid conversion")); 1546 write_exp_elt_opcode (UNOP_CAST); 1547 write_exp_elt_type (yyvsp[-3].tval); 1548 write_exp_elt_opcode (UNOP_CAST); 1549 } 1550 else 1551 { 1552 write_exp_elt_opcode (OP_FUNCALL); 1553 write_exp_elt_longcst (yyvsp[-1].lval); 1554 write_exp_elt_opcode (OP_FUNCALL); 1555 } 1556 } 1557 break; 1558 1559 case 10: 1560#line 269 "ada-exp.y" 1561 { type_qualifier = yyvsp[-2].tval; } 1562 break; 1563 1564 case 11: 1565#line 271 "ada-exp.y" 1566 { 1567 if (yyvsp[-6].tval == NULL) 1568 error (_("Type required for qualification")); 1569 write_exp_elt_opcode (UNOP_QUAL); 1570 write_exp_elt_type (yyvsp[-6].tval); 1571 write_exp_elt_opcode (UNOP_QUAL); 1572 type_qualifier = yyvsp[-4].tval; 1573 } 1574 break; 1575 1576 case 12: 1577#line 281 "ada-exp.y" 1578 { yyval.tval = type_qualifier; } 1579 break; 1580 1581 case 13: 1582#line 286 "ada-exp.y" 1583 { write_exp_elt_opcode (TERNOP_SLICE); } 1584 break; 1585 1586 case 14: 1587#line 288 "ada-exp.y" 1588 { if (yyvsp[-5].tval == NULL) 1589 write_exp_elt_opcode (TERNOP_SLICE); 1590 else 1591 error (_("Cannot slice a type")); 1592 } 1593 break; 1594 1595 case 15: 1596#line 295 "ada-exp.y" 1597 { } 1598 break; 1599 1600 case 16: 1601#line 307 "ada-exp.y" 1602 { if (yyvsp[0].tval != NULL) 1603 { 1604 write_exp_elt_opcode (OP_TYPE); 1605 write_exp_elt_type (yyvsp[0].tval); 1606 write_exp_elt_opcode (OP_TYPE); 1607 } 1608 } 1609 break; 1610 1611 case 17: 1612#line 317 "ada-exp.y" 1613 { write_dollar_variable (yyvsp[0].sval); } 1614 break; 1615 1616 case 20: 1617#line 327 "ada-exp.y" 1618 { write_exp_elt_opcode (UNOP_NEG); } 1619 break; 1620 1621 case 21: 1622#line 331 "ada-exp.y" 1623 { write_exp_elt_opcode (UNOP_PLUS); } 1624 break; 1625 1626 case 22: 1627#line 335 "ada-exp.y" 1628 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); } 1629 break; 1630 1631 case 23: 1632#line 339 "ada-exp.y" 1633 { write_exp_elt_opcode (UNOP_ABS); } 1634 break; 1635 1636 case 24: 1637#line 342 "ada-exp.y" 1638 { yyval.lval = 0; } 1639 break; 1640 1641 case 25: 1642#line 346 "ada-exp.y" 1643 { yyval.lval = 1; } 1644 break; 1645 1646 case 26: 1647#line 348 "ada-exp.y" 1648 { yyval.lval = 1; } 1649 break; 1650 1651 case 27: 1652#line 350 "ada-exp.y" 1653 { yyval.lval = yyvsp[-2].lval + 1; } 1654 break; 1655 1656 case 28: 1657#line 352 "ada-exp.y" 1658 { yyval.lval = yyvsp[-4].lval + 1; } 1659 break; 1660 1661 case 29: 1662#line 357 "ada-exp.y" 1663 { 1664 if (yyvsp[-2].tval == NULL) 1665 error (_("Type required within braces in coercion")); 1666 write_exp_elt_opcode (UNOP_MEMVAL); 1667 write_exp_elt_type (yyvsp[-2].tval); 1668 write_exp_elt_opcode (UNOP_MEMVAL); 1669 } 1670 break; 1671 1672 case 30: 1673#line 369 "ada-exp.y" 1674 { write_exp_elt_opcode (BINOP_EXP); } 1675 break; 1676 1677 case 31: 1678#line 373 "ada-exp.y" 1679 { write_exp_elt_opcode (BINOP_MUL); } 1680 break; 1681 1682 case 32: 1683#line 377 "ada-exp.y" 1684 { write_exp_elt_opcode (BINOP_DIV); } 1685 break; 1686 1687 case 33: 1688#line 381 "ada-exp.y" 1689 { write_exp_elt_opcode (BINOP_REM); } 1690 break; 1691 1692 case 34: 1693#line 385 "ada-exp.y" 1694 { write_exp_elt_opcode (BINOP_MOD); } 1695 break; 1696 1697 case 35: 1698#line 389 "ada-exp.y" 1699 { write_exp_elt_opcode (BINOP_REPEAT); } 1700 break; 1701 1702 case 36: 1703#line 393 "ada-exp.y" 1704 { write_exp_elt_opcode (BINOP_ADD); } 1705 break; 1706 1707 case 37: 1708#line 397 "ada-exp.y" 1709 { write_exp_elt_opcode (BINOP_CONCAT); } 1710 break; 1711 1712 case 38: 1713#line 401 "ada-exp.y" 1714 { write_exp_elt_opcode (BINOP_SUB); } 1715 break; 1716 1717 case 40: 1718#line 408 "ada-exp.y" 1719 { write_exp_elt_opcode (BINOP_EQUAL); } 1720 break; 1721 1722 case 41: 1723#line 412 "ada-exp.y" 1724 { write_exp_elt_opcode (BINOP_NOTEQUAL); } 1725 break; 1726 1727 case 42: 1728#line 416 "ada-exp.y" 1729 { write_exp_elt_opcode (BINOP_LEQ); } 1730 break; 1731 1732 case 43: 1733#line 420 "ada-exp.y" 1734 { write_exp_elt_opcode (TERNOP_IN_RANGE); } 1735 break; 1736 1737 case 44: 1738#line 422 "ada-exp.y" 1739 { write_exp_elt_opcode (BINOP_IN_BOUNDS); 1740 write_exp_elt_longcst ((LONGEST) yyvsp[0].lval); 1741 write_exp_elt_opcode (BINOP_IN_BOUNDS); 1742 } 1743 break; 1744 1745 case 45: 1746#line 427 "ada-exp.y" 1747 { 1748 if (yyvsp[0].tval == NULL) 1749 error (_("Right operand of 'in' must be type")); 1750 write_exp_elt_opcode (UNOP_IN_RANGE); 1751 write_exp_elt_type (yyvsp[0].tval); 1752 write_exp_elt_opcode (UNOP_IN_RANGE); 1753 } 1754 break; 1755 1756 case 46: 1757#line 435 "ada-exp.y" 1758 { write_exp_elt_opcode (TERNOP_IN_RANGE); 1759 write_exp_elt_opcode (UNOP_LOGICAL_NOT); 1760 } 1761 break; 1762 1763 case 47: 1764#line 439 "ada-exp.y" 1765 { write_exp_elt_opcode (BINOP_IN_BOUNDS); 1766 write_exp_elt_longcst ((LONGEST) yyvsp[0].lval); 1767 write_exp_elt_opcode (BINOP_IN_BOUNDS); 1768 write_exp_elt_opcode (UNOP_LOGICAL_NOT); 1769 } 1770 break; 1771 1772 case 48: 1773#line 445 "ada-exp.y" 1774 { 1775 if (yyvsp[0].tval == NULL) 1776 error (_("Right operand of 'in' must be type")); 1777 write_exp_elt_opcode (UNOP_IN_RANGE); 1778 write_exp_elt_type (yyvsp[0].tval); 1779 write_exp_elt_opcode (UNOP_IN_RANGE); 1780 write_exp_elt_opcode (UNOP_LOGICAL_NOT); 1781 } 1782 break; 1783 1784 case 49: 1785#line 456 "ada-exp.y" 1786 { write_exp_elt_opcode (BINOP_GEQ); } 1787 break; 1788 1789 case 50: 1790#line 460 "ada-exp.y" 1791 { write_exp_elt_opcode (BINOP_LESS); } 1792 break; 1793 1794 case 51: 1795#line 464 "ada-exp.y" 1796 { write_exp_elt_opcode (BINOP_GTR); } 1797 break; 1798 1799 case 58: 1800#line 477 "ada-exp.y" 1801 { write_exp_elt_opcode (BINOP_BITWISE_AND); } 1802 break; 1803 1804 case 59: 1805#line 479 "ada-exp.y" 1806 { write_exp_elt_opcode (BINOP_BITWISE_AND); } 1807 break; 1808 1809 case 60: 1810#line 484 "ada-exp.y" 1811 { write_exp_elt_opcode (BINOP_LOGICAL_AND); } 1812 break; 1813 1814 case 61: 1815#line 486 "ada-exp.y" 1816 { write_exp_elt_opcode (BINOP_LOGICAL_AND); } 1817 break; 1818 1819 case 62: 1820#line 491 "ada-exp.y" 1821 { write_exp_elt_opcode (BINOP_BITWISE_IOR); } 1822 break; 1823 1824 case 63: 1825#line 493 "ada-exp.y" 1826 { write_exp_elt_opcode (BINOP_BITWISE_IOR); } 1827 break; 1828 1829 case 64: 1830#line 498 "ada-exp.y" 1831 { write_exp_elt_opcode (BINOP_LOGICAL_OR); } 1832 break; 1833 1834 case 65: 1835#line 500 "ada-exp.y" 1836 { write_exp_elt_opcode (BINOP_LOGICAL_OR); } 1837 break; 1838 1839 case 66: 1840#line 504 "ada-exp.y" 1841 { write_exp_elt_opcode (BINOP_BITWISE_XOR); } 1842 break; 1843 1844 case 67: 1845#line 506 "ada-exp.y" 1846 { write_exp_elt_opcode (BINOP_BITWISE_XOR); } 1847 break; 1848 1849 case 68: 1850#line 518 "ada-exp.y" 1851 { write_exp_elt_opcode (UNOP_ADDR); } 1852 break; 1853 1854 case 69: 1855#line 520 "ada-exp.y" 1856 { write_exp_elt_opcode (UNOP_ADDR); 1857 write_exp_elt_opcode (UNOP_CAST); 1858 write_exp_elt_type (type_system_address ()); 1859 write_exp_elt_opcode (UNOP_CAST); 1860 } 1861 break; 1862 1863 case 70: 1864#line 526 "ada-exp.y" 1865 { write_int (yyvsp[0].lval, type_int ()); 1866 write_exp_elt_opcode (OP_ATR_FIRST); } 1867 break; 1868 1869 case 71: 1870#line 529 "ada-exp.y" 1871 { write_int (yyvsp[0].lval, type_int ()); 1872 write_exp_elt_opcode (OP_ATR_LAST); } 1873 break; 1874 1875 case 72: 1876#line 532 "ada-exp.y" 1877 { write_int (yyvsp[0].lval, type_int ()); 1878 write_exp_elt_opcode (OP_ATR_LENGTH); } 1879 break; 1880 1881 case 73: 1882#line 535 "ada-exp.y" 1883 { write_exp_elt_opcode (OP_ATR_SIZE); } 1884 break; 1885 1886 case 74: 1887#line 537 "ada-exp.y" 1888 { write_exp_elt_opcode (OP_ATR_TAG); } 1889 break; 1890 1891 case 75: 1892#line 539 "ada-exp.y" 1893 { write_exp_elt_opcode (OP_ATR_MIN); } 1894 break; 1895 1896 case 76: 1897#line 541 "ada-exp.y" 1898 { write_exp_elt_opcode (OP_ATR_MAX); } 1899 break; 1900 1901 case 77: 1902#line 543 "ada-exp.y" 1903 { write_exp_elt_opcode (OP_ATR_POS); } 1904 break; 1905 1906 case 78: 1907#line 545 "ada-exp.y" 1908 { write_exp_elt_opcode (OP_ATR_VAL); } 1909 break; 1910 1911 case 79: 1912#line 547 "ada-exp.y" 1913 { write_exp_elt_opcode (OP_ATR_MODULUS); } 1914 break; 1915 1916 case 80: 1917#line 551 "ada-exp.y" 1918 { yyval.lval = 1; } 1919 break; 1920 1921 case 81: 1922#line 553 "ada-exp.y" 1923 { yyval.lval = yyvsp[-1].typed_val.val; } 1924 break; 1925 1926 case 82: 1927#line 558 "ada-exp.y" 1928 { 1929 if (yyvsp[0].tval == NULL) 1930 error (_("Prefix must be type")); 1931 write_exp_elt_opcode (OP_TYPE); 1932 write_exp_elt_type (yyvsp[0].tval); 1933 write_exp_elt_opcode (OP_TYPE); } 1934 break; 1935 1936 case 84: 1937#line 569 "ada-exp.y" 1938 { write_exp_elt_opcode (OP_TYPE); 1939 write_exp_elt_type (builtin_type_void); 1940 write_exp_elt_opcode (OP_TYPE); } 1941 break; 1942 1943 case 85: 1944#line 576 "ada-exp.y" 1945 { write_int ((LONGEST) yyvsp[0].typed_val.val, yyvsp[0].typed_val.type); } 1946 break; 1947 1948 case 86: 1949#line 580 "ada-exp.y" 1950 { write_int (convert_char_literal (type_qualifier, yyvsp[0].typed_val.val), 1951 (type_qualifier == NULL) 1952 ? yyvsp[0].typed_val.type : type_qualifier); 1953 } 1954 break; 1955 1956 case 87: 1957#line 587 "ada-exp.y" 1958 { write_exp_elt_opcode (OP_DOUBLE); 1959 write_exp_elt_type (yyvsp[0].typed_val_float.type); 1960 write_exp_elt_dblcst (yyvsp[0].typed_val_float.dval); 1961 write_exp_elt_opcode (OP_DOUBLE); 1962 } 1963 break; 1964 1965 case 88: 1966#line 595 "ada-exp.y" 1967 { write_int (0, type_int ()); } 1968 break; 1969 1970 case 89: 1971#line 599 "ada-exp.y" 1972 { 1973 write_exp_op_with_string (OP_STRING, yyvsp[0].sval); 1974 } 1975 break; 1976 1977 case 90: 1978#line 605 "ada-exp.y" 1979 { error (_("NEW not implemented.")); } 1980 break; 1981 1982 case 91: 1983#line 609 "ada-exp.y" 1984 { yyval.tval = write_var_or_type (NULL, yyvsp[0].sval); } 1985 break; 1986 1987 case 92: 1988#line 611 "ada-exp.y" 1989 { yyval.tval = write_var_or_type (yyvsp[-1].bval, yyvsp[0].sval); } 1990 break; 1991 1992 case 93: 1993#line 613 "ada-exp.y" 1994 { 1995 yyval.tval = write_var_or_type (NULL, yyvsp[-1].sval); 1996 if (yyval.tval == NULL) 1997 write_exp_elt_opcode (UNOP_ADDR); 1998 else 1999 yyval.tval = lookup_pointer_type (yyval.tval); 2000 } 2001 break; 2002 2003 case 94: 2004#line 621 "ada-exp.y" 2005 { 2006 yyval.tval = write_var_or_type (yyvsp[-2].bval, yyvsp[-1].sval); 2007 if (yyval.tval == NULL) 2008 write_exp_elt_opcode (UNOP_ADDR); 2009 else 2010 yyval.tval = lookup_pointer_type (yyval.tval); 2011 } 2012 break; 2013 2014 case 95: 2015#line 632 "ada-exp.y" 2016 { yyval.bval = block_lookup (NULL, yyvsp[-1].sval.ptr); } 2017 break; 2018 2019 case 96: 2020#line 634 "ada-exp.y" 2021 { yyval.bval = block_lookup (yyvsp[-2].bval, yyvsp[-1].sval.ptr); } 2022 break; 2023 2024 case 97: 2025#line 639 "ada-exp.y" 2026 { 2027 write_exp_elt_opcode (OP_AGGREGATE); 2028 write_exp_elt_longcst (yyvsp[-1].lval); 2029 write_exp_elt_opcode (OP_AGGREGATE); 2030 } 2031 break; 2032 2033 case 98: 2034#line 647 "ada-exp.y" 2035 { yyval.lval = yyvsp[0].lval; } 2036 break; 2037 2038 case 99: 2039#line 649 "ada-exp.y" 2040 { write_exp_elt_opcode (OP_POSITIONAL); 2041 write_exp_elt_longcst (yyvsp[-1].lval); 2042 write_exp_elt_opcode (OP_POSITIONAL); 2043 yyval.lval = yyvsp[-1].lval + 1; 2044 } 2045 break; 2046 2047 case 100: 2048#line 655 "ada-exp.y" 2049 { yyval.lval = yyvsp[-1].lval + yyvsp[0].lval; } 2050 break; 2051 2052 case 101: 2053#line 660 "ada-exp.y" 2054 { write_exp_elt_opcode (OP_POSITIONAL); 2055 write_exp_elt_longcst (0); 2056 write_exp_elt_opcode (OP_POSITIONAL); 2057 yyval.lval = 1; 2058 } 2059 break; 2060 2061 case 102: 2062#line 666 "ada-exp.y" 2063 { write_exp_elt_opcode (OP_POSITIONAL); 2064 write_exp_elt_longcst (yyvsp[-2].lval); 2065 write_exp_elt_opcode (OP_POSITIONAL); 2066 yyval.lval = yyvsp[-2].lval + 1; 2067 } 2068 break; 2069 2070 case 103: 2071#line 674 "ada-exp.y" 2072 { yyval.lval = 1; } 2073 break; 2074 2075 case 104: 2076#line 675 "ada-exp.y" 2077 { yyval.lval = 1; } 2078 break; 2079 2080 case 105: 2081#line 677 "ada-exp.y" 2082 { yyval.lval = yyvsp[0].lval + 1; } 2083 break; 2084 2085 case 106: 2086#line 681 "ada-exp.y" 2087 { write_exp_elt_opcode (OP_OTHERS); } 2088 break; 2089 2090 case 107: 2091#line 686 "ada-exp.y" 2092 { 2093 write_exp_elt_opcode (OP_CHOICES); 2094 write_exp_elt_longcst (yyvsp[0].lval); 2095 write_exp_elt_opcode (OP_CHOICES); 2096 } 2097 break; 2098 2099 case 108: 2100#line 700 "ada-exp.y" 2101 { write_name_assoc (yyvsp[-1].sval); } 2102 break; 2103 2104 case 109: 2105#line 701 "ada-exp.y" 2106 { yyval.lval = 1; } 2107 break; 2108 2109 case 110: 2110#line 703 "ada-exp.y" 2111 { yyval.lval = 1; } 2112 break; 2113 2114 case 111: 2115#line 705 "ada-exp.y" 2116 { write_exp_elt_opcode (OP_DISCRETE_RANGE); 2117 write_exp_op_with_string (OP_NAME, empty_stoken); 2118 } 2119 break; 2120 2121 case 112: 2122#line 708 "ada-exp.y" 2123 { yyval.lval = 1; } 2124 break; 2125 2126 case 113: 2127#line 710 "ada-exp.y" 2128 { write_name_assoc (yyvsp[-1].sval); } 2129 break; 2130 2131 case 114: 2132#line 711 "ada-exp.y" 2133 { yyval.lval = yyvsp[0].lval + 1; } 2134 break; 2135 2136 case 115: 2137#line 713 "ada-exp.y" 2138 { yyval.lval = yyvsp[0].lval + 1; } 2139 break; 2140 2141 case 116: 2142#line 715 "ada-exp.y" 2143 { write_exp_elt_opcode (OP_DISCRETE_RANGE); } 2144 break; 2145 2146 case 117: 2147#line 716 "ada-exp.y" 2148 { yyval.lval = yyvsp[0].lval + 1; } 2149 break; 2150 2151 case 118: 2152#line 723 "ada-exp.y" 2153 { write_exp_elt_opcode (UNOP_IND); } 2154 break; 2155 2156 case 119: 2157#line 725 "ada-exp.y" 2158 { write_exp_elt_opcode (UNOP_ADDR); } 2159 break; 2160 2161 case 120: 2162#line 727 "ada-exp.y" 2163 { write_exp_elt_opcode (BINOP_SUBSCRIPT); } 2164 break; 2165 2166 2167 } 2168 2169/* Line 1000 of yacc.c. */ 2170#line 2171 "ada-exp.c.tmp" 2171 2172 yyvsp -= yylen; 2173 yyssp -= yylen; 2174 2175 2176 YY_STACK_PRINT (yyss, yyssp); 2177 2178 *++yyvsp = yyval; 2179 2180 2181 /* Now `shift' the result of the reduction. Determine what state 2182 that goes to, based on the state we popped back to and the rule 2183 number reduced by. */ 2184 2185 yyn = yyr1[yyn]; 2186 2187 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 2188 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 2189 yystate = yytable[yystate]; 2190 else 2191 yystate = yydefgoto[yyn - YYNTOKENS]; 2192 2193 goto yynewstate; 2194 2195 2196/*------------------------------------. 2197| yyerrlab -- here on detecting error | 2198`------------------------------------*/ 2199yyerrlab: 2200 /* If not already recovering from an error, report this error. */ 2201 if (!yyerrstatus) 2202 { 2203 ++yynerrs; 2204#if YYERROR_VERBOSE 2205 yyn = yypact[yystate]; 2206 2207 if (YYPACT_NINF < yyn && yyn < YYLAST) 2208 { 2209 YYSIZE_T yysize = 0; 2210 int yytype = YYTRANSLATE (yychar); 2211 const char* yyprefix; 2212 char *yymsg; 2213 int yyx; 2214 2215 /* Start YYX at -YYN if negative to avoid negative indexes in 2216 YYCHECK. */ 2217 int yyxbegin = yyn < 0 ? -yyn : 0; 2218 2219 /* Stay within bounds of both yycheck and yytname. */ 2220 int yychecklim = YYLAST - yyn; 2221 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 2222 int yycount = 0; 2223 2224 yyprefix = ", expecting "; 2225 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 2226 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 2227 { 2228 yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]); 2229 yycount += 1; 2230 if (yycount == 5) 2231 { 2232 yysize = 0; 2233 break; 2234 } 2235 } 2236 yysize += (sizeof ("syntax error, unexpected ") 2237 + yystrlen (yytname[yytype])); 2238 yymsg = (char *) YYSTACK_ALLOC (yysize); 2239 if (yymsg != 0) 2240 { 2241 char *yyp = yystpcpy (yymsg, "syntax error, unexpected "); 2242 yyp = yystpcpy (yyp, yytname[yytype]); 2243 2244 if (yycount < 5) 2245 { 2246 yyprefix = ", expecting "; 2247 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 2248 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 2249 { 2250 yyp = yystpcpy (yyp, yyprefix); 2251 yyp = yystpcpy (yyp, yytname[yyx]); 2252 yyprefix = " or "; 2253 } 2254 } 2255 yyerror (yymsg); 2256 YYSTACK_FREE (yymsg); 2257 } 2258 else 2259 yyerror ("syntax error; also virtual memory exhausted"); 2260 } 2261 else 2262#endif /* YYERROR_VERBOSE */ 2263 yyerror ("syntax error"); 2264 } 2265 2266 2267 2268 if (yyerrstatus == 3) 2269 { 2270 /* If just tried and failed to reuse lookahead token after an 2271 error, discard it. */ 2272 2273 if (yychar <= YYEOF) 2274 { 2275 /* If at end of input, pop the error token, 2276 then the rest of the stack, then return failure. */ 2277 if (yychar == YYEOF) 2278 for (;;) 2279 { 2280 YYPOPSTACK; 2281 if (yyssp == yyss) 2282 YYABORT; 2283 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); 2284 yydestruct (yystos[*yyssp], yyvsp); 2285 } 2286 } 2287 else 2288 { 2289 YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc); 2290 yydestruct (yytoken, &yylval); 2291 yychar = YYEMPTY; 2292 2293 } 2294 } 2295 2296 /* Else will try to reuse lookahead token after shifting the error 2297 token. */ 2298 goto yyerrlab1; 2299 2300 2301/*---------------------------------------------------. 2302| yyerrorlab -- error raised explicitly by YYERROR. | 2303`---------------------------------------------------*/ 2304yyerrorlab: 2305 2306#ifdef __GNUC__ 2307 /* Pacify GCC when the user code never invokes YYERROR and the label 2308 yyerrorlab therefore never appears in user code. */ 2309 if (0) 2310 goto yyerrorlab; 2311#endif 2312 2313 yyvsp -= yylen; 2314 yyssp -= yylen; 2315 yystate = *yyssp; 2316 goto yyerrlab1; 2317 2318 2319/*-------------------------------------------------------------. 2320| yyerrlab1 -- common code for both syntax error and YYERROR. | 2321`-------------------------------------------------------------*/ 2322yyerrlab1: 2323 yyerrstatus = 3; /* Each real token shifted decrements this. */ 2324 2325 for (;;) 2326 { 2327 yyn = yypact[yystate]; 2328 if (yyn != YYPACT_NINF) 2329 { 2330 yyn += YYTERROR; 2331 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 2332 { 2333 yyn = yytable[yyn]; 2334 if (0 < yyn) 2335 break; 2336 } 2337 } 2338 2339 /* Pop the current state because it cannot handle the error token. */ 2340 if (yyssp == yyss) 2341 YYABORT; 2342 2343 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); 2344 yydestruct (yystos[yystate], yyvsp); 2345 YYPOPSTACK; 2346 yystate = *yyssp; 2347 YY_STACK_PRINT (yyss, yyssp); 2348 } 2349 2350 if (yyn == YYFINAL) 2351 YYACCEPT; 2352 2353 YYDPRINTF ((stderr, "Shifting error token, ")); 2354 2355 *++yyvsp = yylval; 2356 2357 2358 yystate = yyn; 2359 goto yynewstate; 2360 2361 2362/*-------------------------------------. 2363| yyacceptlab -- YYACCEPT comes here. | 2364`-------------------------------------*/ 2365yyacceptlab: 2366 yyresult = 0; 2367 goto yyreturn; 2368 2369/*-----------------------------------. 2370| yyabortlab -- YYABORT comes here. | 2371`-----------------------------------*/ 2372yyabortlab: 2373 yyresult = 1; 2374 goto yyreturn; 2375 2376#ifndef yyoverflow 2377/*----------------------------------------------. 2378| yyoverflowlab -- parser overflow comes here. | 2379`----------------------------------------------*/ 2380yyoverflowlab: 2381 yyerror ("parser stack overflow"); 2382 yyresult = 2; 2383 /* Fall through. */ 2384#endif 2385 2386yyreturn: 2387#ifndef yyoverflow 2388 if (yyss != yyssa) 2389 YYSTACK_FREE (yyss); 2390#endif 2391 return yyresult; 2392} 2393 2394 2395#line 730 "ada-exp.y" 2396 2397 2398/* yylex defined in ada-lex.c: Reads one token, getting characters */ 2399/* through lexptr. */ 2400 2401/* Remap normal flex interface names (yylex) as well as gratuitiously */ 2402/* global symbol names, so we can have multiple flex-generated parsers */ 2403/* in gdb. */ 2404 2405/* (See note above on previous definitions for YACC.) */ 2406 2407#define yy_create_buffer ada_yy_create_buffer 2408#define yy_delete_buffer ada_yy_delete_buffer 2409#define yy_init_buffer ada_yy_init_buffer 2410#define yy_load_buffer_state ada_yy_load_buffer_state 2411#define yy_switch_to_buffer ada_yy_switch_to_buffer 2412#define yyrestart ada_yyrestart 2413#define yytext ada_yytext 2414#define yywrap ada_yywrap 2415 2416static struct obstack temp_parse_space; 2417 2418/* The following kludge was found necessary to prevent conflicts between */ 2419/* defs.h and non-standard stdlib.h files. */ 2420#define qsort __qsort__dummy 2421#include "ada-lex.c" 2422 2423int 2424ada_parse (void) 2425{ 2426 lexer_init (yyin); /* (Re-)initialize lexer. */ 2427 type_qualifier = NULL; 2428 obstack_free (&temp_parse_space, NULL); 2429 obstack_init (&temp_parse_space); 2430 2431 return _ada_parse (); 2432} 2433 2434void 2435yyerror (char *msg) 2436{ 2437 error (_("Error in expression, near `%s'."), lexptr); 2438} 2439 2440/* The operator name corresponding to operator symbol STRING (adds 2441 quotes and maps to lower-case). Destroys the previous contents of 2442 the array pointed to by STRING.ptr. Error if STRING does not match 2443 a valid Ada operator. Assumes that STRING.ptr points to a 2444 null-terminated string and that, if STRING is a valid operator 2445 symbol, the array pointed to by STRING.ptr contains at least 2446 STRING.length+3 characters. */ 2447 2448static struct stoken 2449string_to_operator (struct stoken string) 2450{ 2451 int i; 2452 2453 for (i = 0; ada_opname_table[i].encoded != NULL; i += 1) 2454 { 2455 if (string.length == strlen (ada_opname_table[i].decoded)-2 2456 && strncasecmp (string.ptr, ada_opname_table[i].decoded+1, 2457 string.length) == 0) 2458 { 2459 strncpy (string.ptr, ada_opname_table[i].decoded, 2460 string.length+2); 2461 string.length += 2; 2462 return string; 2463 } 2464 } 2465 error (_("Invalid operator symbol `%s'"), string.ptr); 2466} 2467 2468/* Emit expression to access an instance of SYM, in block BLOCK (if 2469 * non-NULL), and with :: qualification ORIG_LEFT_CONTEXT. */ 2470static void 2471write_var_from_sym (struct block *orig_left_context, 2472 struct block *block, 2473 struct symbol *sym) 2474{ 2475 if (orig_left_context == NULL && symbol_read_needs_frame (sym)) 2476 { 2477 if (innermost_block == 0 2478 || contained_in (block, innermost_block)) 2479 innermost_block = block; 2480 } 2481 2482 write_exp_elt_opcode (OP_VAR_VALUE); 2483 write_exp_elt_block (block); 2484 write_exp_elt_sym (sym); 2485 write_exp_elt_opcode (OP_VAR_VALUE); 2486} 2487 2488/* Write integer constant ARG of type TYPE. */ 2489 2490static void 2491write_int (LONGEST arg, struct type *type) 2492{ 2493 write_exp_elt_opcode (OP_LONG); 2494 write_exp_elt_type (type); 2495 write_exp_elt_longcst (arg); 2496 write_exp_elt_opcode (OP_LONG); 2497} 2498 2499/* Write an OPCODE, string, OPCODE sequence to the current expression. */ 2500static void 2501write_exp_op_with_string (enum exp_opcode opcode, struct stoken token) 2502{ 2503 write_exp_elt_opcode (opcode); 2504 write_exp_string (token); 2505 write_exp_elt_opcode (opcode); 2506} 2507 2508/* Emit expression corresponding to the renamed object designated by 2509 * the type RENAMING, which must be the referent of an object renaming 2510 * type, in the context of ORIG_LEFT_CONTEXT. MAX_DEPTH is the maximum 2511 * number of cascaded renamings to allow. */ 2512static void 2513write_object_renaming (struct block *orig_left_context, 2514 struct symbol *renaming, int max_depth) 2515{ 2516 const char *qualification = SYMBOL_LINKAGE_NAME (renaming); 2517 const char *simple_tail; 2518 const char *expr = TYPE_FIELD_NAME (SYMBOL_TYPE (renaming), 0); 2519 const char *suffix; 2520 char *name; 2521 struct symbol *sym; 2522 enum { SIMPLE_INDEX, LOWER_BOUND, UPPER_BOUND } slice_state; 2523 2524 if (max_depth <= 0) 2525 error (_("Could not find renamed symbol")); 2526 2527 /* if orig_left_context is null, then use the currently selected 2528 block; otherwise we might fail our symbol lookup below. */ 2529 if (orig_left_context == NULL) 2530 orig_left_context = get_selected_block (NULL); 2531 2532 for (simple_tail = qualification + strlen (qualification); 2533 simple_tail != qualification; simple_tail -= 1) 2534 { 2535 if (*simple_tail == '.') 2536 { 2537 simple_tail += 1; 2538 break; 2539 } 2540 else if (strncmp (simple_tail, "__", 2) == 0) 2541 { 2542 simple_tail += 2; 2543 break; 2544 } 2545 } 2546 2547 suffix = strstr (expr, "___XE"); 2548 if (suffix == NULL) 2549 goto BadEncoding; 2550 2551 name = (char *) obstack_alloc (&temp_parse_space, suffix - expr + 1); 2552 strncpy (name, expr, suffix-expr); 2553 name[suffix-expr] = '\000'; 2554 sym = lookup_symbol (name, orig_left_context, VAR_DOMAIN, 0, NULL); 2555 if (sym == NULL) 2556 error (_("Could not find renamed variable: %s"), ada_decode (name)); 2557 if (ada_is_object_renaming (sym)) 2558 write_object_renaming (orig_left_context, sym, max_depth-1); 2559 else 2560 write_var_from_sym (orig_left_context, block_found, sym); 2561 2562 suffix += 5; 2563 slice_state = SIMPLE_INDEX; 2564 while (*suffix == 'X') 2565 { 2566 suffix += 1; 2567 2568 switch (*suffix) { 2569 case 'A': 2570 suffix += 1; 2571 write_exp_elt_opcode (UNOP_IND); 2572 break; 2573 case 'L': 2574 slice_state = LOWER_BOUND; 2575 case 'S': 2576 suffix += 1; 2577 if (isdigit (*suffix)) 2578 { 2579 char *next; 2580 long val = strtol (suffix, &next, 10); 2581 if (next == suffix) 2582 goto BadEncoding; 2583 suffix = next; 2584 write_exp_elt_opcode (OP_LONG); 2585 write_exp_elt_type (type_int ()); 2586 write_exp_elt_longcst ((LONGEST) val); 2587 write_exp_elt_opcode (OP_LONG); 2588 } 2589 else 2590 { 2591 const char *end; 2592 char *index_name; 2593 int index_len; 2594 struct symbol *index_sym; 2595 2596 end = strchr (suffix, 'X'); 2597 if (end == NULL) 2598 end = suffix + strlen (suffix); 2599 2600 index_len = simple_tail - qualification + 2 + (suffix - end) + 1; 2601 index_name 2602 = (char *) obstack_alloc (&temp_parse_space, index_len); 2603 memset (index_name, '\000', index_len); 2604 strncpy (index_name, qualification, simple_tail - qualification); 2605 index_name[simple_tail - qualification] = '\000'; 2606 strncat (index_name, suffix, suffix-end); 2607 suffix = end; 2608 2609 index_sym = 2610 lookup_symbol (index_name, NULL, VAR_DOMAIN, 0, NULL); 2611 if (index_sym == NULL) 2612 error (_("Could not find %s"), index_name); 2613 write_var_from_sym (NULL, block_found, sym); 2614 } 2615 if (slice_state == SIMPLE_INDEX) 2616 { 2617 write_exp_elt_opcode (OP_FUNCALL); 2618 write_exp_elt_longcst ((LONGEST) 1); 2619 write_exp_elt_opcode (OP_FUNCALL); 2620 } 2621 else if (slice_state == LOWER_BOUND) 2622 slice_state = UPPER_BOUND; 2623 else if (slice_state == UPPER_BOUND) 2624 { 2625 write_exp_elt_opcode (TERNOP_SLICE); 2626 slice_state = SIMPLE_INDEX; 2627 } 2628 break; 2629 2630 case 'R': 2631 { 2632 struct stoken field_name; 2633 const char *end; 2634 suffix += 1; 2635 2636 if (slice_state != SIMPLE_INDEX) 2637 goto BadEncoding; 2638 end = strchr (suffix, 'X'); 2639 if (end == NULL) 2640 end = suffix + strlen (suffix); 2641 field_name.length = end - suffix; 2642 field_name.ptr = xmalloc (end - suffix + 1); 2643 strncpy (field_name.ptr, suffix, end - suffix); 2644 field_name.ptr[end - suffix] = '\000'; 2645 suffix = end; 2646 write_exp_op_with_string (STRUCTOP_STRUCT, field_name); 2647 break; 2648 } 2649 2650 default: 2651 goto BadEncoding; 2652 } 2653 } 2654 if (slice_state == SIMPLE_INDEX) 2655 return; 2656 2657 BadEncoding: 2658 error (_("Internal error in encoding of renaming declaration: %s"), 2659 SYMBOL_LINKAGE_NAME (renaming)); 2660} 2661 2662static struct block* 2663block_lookup (struct block *context, char *raw_name) 2664{ 2665 char *name; 2666 struct ada_symbol_info *syms; 2667 int nsyms; 2668 struct symtab *symtab; 2669 2670 if (raw_name[0] == '\'') 2671 { 2672 raw_name += 1; 2673 name = raw_name; 2674 } 2675 else 2676 name = ada_encode (raw_name); 2677 2678 nsyms = ada_lookup_symbol_list (name, context, VAR_DOMAIN, &syms); 2679 if (context == NULL && 2680 (nsyms == 0 || SYMBOL_CLASS (syms[0].sym) != LOC_BLOCK)) 2681 symtab = lookup_symtab (name); 2682 else 2683 symtab = NULL; 2684 2685 if (symtab != NULL) 2686 return BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK); 2687 else if (nsyms == 0 || SYMBOL_CLASS (syms[0].sym) != LOC_BLOCK) 2688 { 2689 if (context == NULL) 2690 error (_("No file or function \"%s\"."), raw_name); 2691 else 2692 error (_("No function \"%s\" in specified context."), raw_name); 2693 } 2694 else 2695 { 2696 if (nsyms > 1) 2697 warning (_("Function name \"%s\" ambiguous here"), raw_name); 2698 return SYMBOL_BLOCK_VALUE (syms[0].sym); 2699 } 2700} 2701 2702static struct symbol* 2703select_possible_type_sym (struct ada_symbol_info *syms, int nsyms) 2704{ 2705 int i; 2706 int preferred_index; 2707 struct type *preferred_type; 2708 2709 preferred_index = -1; preferred_type = NULL; 2710 for (i = 0; i < nsyms; i += 1) 2711 switch (SYMBOL_CLASS (syms[i].sym)) 2712 { 2713 case LOC_TYPEDEF: 2714 if (ada_prefer_type (SYMBOL_TYPE (syms[i].sym), preferred_type)) 2715 { 2716 preferred_index = i; 2717 preferred_type = SYMBOL_TYPE (syms[i].sym); 2718 } 2719 break; 2720 case LOC_REGISTER: 2721 case LOC_ARG: 2722 case LOC_REF_ARG: 2723 case LOC_REGPARM: 2724 case LOC_REGPARM_ADDR: 2725 case LOC_LOCAL: 2726 case LOC_LOCAL_ARG: 2727 case LOC_BASEREG: 2728 case LOC_BASEREG_ARG: 2729 case LOC_COMPUTED: 2730 case LOC_COMPUTED_ARG: 2731 return NULL; 2732 default: 2733 break; 2734 } 2735 if (preferred_type == NULL) 2736 return NULL; 2737 return syms[preferred_index].sym; 2738} 2739 2740static struct type* 2741find_primitive_type (char *name) 2742{ 2743 struct type *type; 2744 type = language_lookup_primitive_type_by_name (current_language, 2745 current_gdbarch, 2746 name); 2747 if (type == NULL && strcmp ("system__address", name) == 0) 2748 type = type_system_address (); 2749 2750 if (type != NULL) 2751 { 2752 /* Check to see if we have a regular definition of this 2753 type that just didn't happen to have been read yet. */ 2754 int ntypes; 2755 struct symbol *sym; 2756 char *expanded_name = 2757 (char *) alloca (strlen (name) + sizeof ("standard__")); 2758 strcpy (expanded_name, "standard__"); 2759 strcat (expanded_name, name); 2760 sym = ada_lookup_symbol (expanded_name, NULL, VAR_DOMAIN, NULL, NULL); 2761 if (sym != NULL && SYMBOL_CLASS (sym) == LOC_TYPEDEF) 2762 type = SYMBOL_TYPE (sym); 2763 } 2764 2765 return type; 2766} 2767 2768static int 2769chop_selector (char *name, int end) 2770{ 2771 int i; 2772 for (i = end - 1; i > 0; i -= 1) 2773 if (name[i] == '.' || (name[i] == '_' && name[i+1] == '_')) 2774 return i; 2775 return -1; 2776} 2777 2778/* Given that SELS is a string of the form (<sep><identifier>)*, where 2779 <sep> is '__' or '.', write the indicated sequence of 2780 STRUCTOP_STRUCT expression operators. */ 2781static void 2782write_selectors (char *sels) 2783{ 2784 while (*sels != '\0') 2785 { 2786 struct stoken field_name; 2787 char *p; 2788 while (*sels == '_' || *sels == '.') 2789 sels += 1; 2790 p = sels; 2791 while (*sels != '\0' && *sels != '.' 2792 && (sels[0] != '_' || sels[1] != '_')) 2793 sels += 1; 2794 field_name.length = sels - p; 2795 field_name.ptr = p; 2796 write_exp_op_with_string (STRUCTOP_STRUCT, field_name); 2797 } 2798} 2799 2800/* Write a variable access (OP_VAR_VALUE) to ambiguous encoded name 2801 NAME[0..LEN-1], in block context BLOCK, to be resolved later. Writes 2802 a temporary symbol that is valid until the next call to ada_parse. 2803 */ 2804static void 2805write_ambiguous_var (struct block *block, char *name, int len) 2806{ 2807 struct symbol *sym = 2808 obstack_alloc (&temp_parse_space, sizeof (struct symbol)); 2809 memset (sym, 0, sizeof (struct symbol)); 2810 SYMBOL_DOMAIN (sym) = UNDEF_DOMAIN; 2811 SYMBOL_LINKAGE_NAME (sym) = obsavestring (name, len, &temp_parse_space); 2812 SYMBOL_LANGUAGE (sym) = language_ada; 2813 2814 write_exp_elt_opcode (OP_VAR_VALUE); 2815 write_exp_elt_block (block); 2816 write_exp_elt_sym (sym); 2817 write_exp_elt_opcode (OP_VAR_VALUE); 2818} 2819 2820 2821/* Look up NAME0 (an unencoded identifier or dotted name) in BLOCK (or 2822 expression_block_context if NULL). If it denotes a type, return 2823 that type. Otherwise, write expression code to evaluate it as an 2824 object and return NULL. In this second case, NAME0 will, in general, 2825 have the form <name>(.<selector_name>)*, where <name> is an object 2826 or renaming encoded in the debugging data. Calls error if no 2827 prefix <name> matches a name in the debugging data (i.e., matches 2828 either a complete name or, as a wild-card match, the final 2829 identifier). */ 2830 2831static struct type* 2832write_var_or_type (struct block *block, struct stoken name0) 2833{ 2834 int depth; 2835 char *encoded_name; 2836 int name_len; 2837 2838 if (block == NULL) 2839 block = expression_context_block; 2840 2841 encoded_name = ada_encode (name0.ptr); 2842 name_len = strlen (encoded_name); 2843 encoded_name = obsavestring (encoded_name, name_len, &temp_parse_space); 2844 for (depth = 0; depth < MAX_RENAMING_CHAIN_LENGTH; depth += 1) 2845 { 2846 int tail_index; 2847 2848 tail_index = name_len; 2849 while (tail_index > 0) 2850 { 2851 int nsyms; 2852 struct ada_symbol_info *syms; 2853 struct symbol *type_sym; 2854 int terminator = encoded_name[tail_index]; 2855 2856 encoded_name[tail_index] = '\0'; 2857 nsyms = ada_lookup_symbol_list (encoded_name, block, 2858 VAR_DOMAIN, &syms); 2859 encoded_name[tail_index] = terminator; 2860 2861 /* A single symbol may rename a package or object. */ 2862 2863 if (nsyms == 1 && !ada_is_object_renaming (syms[0].sym)) 2864 { 2865 struct symbol *renaming_sym = 2866 ada_find_renaming_symbol (SYMBOL_LINKAGE_NAME (syms[0].sym), 2867 syms[0].block); 2868 2869 if (renaming_sym != NULL) 2870 syms[0].sym = renaming_sym; 2871 } 2872 2873 type_sym = select_possible_type_sym (syms, nsyms); 2874 if (type_sym != NULL) 2875 { 2876 struct type *type = SYMBOL_TYPE (type_sym); 2877 2878 if (TYPE_CODE (type) == TYPE_CODE_VOID) 2879 error (_("`%s' matches only void type name(s)"), name0.ptr); 2880 else if (ada_is_object_renaming (type_sym)) 2881 { 2882 write_object_renaming (block, type_sym, 2883 MAX_RENAMING_CHAIN_LENGTH); 2884 write_selectors (encoded_name + tail_index); 2885 return NULL; 2886 } 2887 else if (ada_renaming_type (SYMBOL_TYPE (type_sym)) != NULL) 2888 { 2889 int result; 2890 char *renaming = ada_simple_renamed_entity (type_sym); 2891 int renaming_len = strlen (renaming); 2892 2893 char *new_name 2894 = obstack_alloc (&temp_parse_space, 2895 renaming_len + name_len - tail_index 2896 + 1); 2897 strcpy (new_name, renaming); 2898 xfree (renaming); 2899 strcpy (new_name + renaming_len, encoded_name + tail_index); 2900 encoded_name = new_name; 2901 name_len = renaming_len + name_len - tail_index; 2902 goto TryAfterRenaming; 2903 } 2904 else if (tail_index == name_len) 2905 return type; 2906 else 2907 error (_("Invalid attempt to select from type: \"%s\"."), name0.ptr); 2908 } 2909 else if (tail_index == name_len && nsyms == 0) 2910 { 2911 struct type *type = find_primitive_type (encoded_name); 2912 2913 if (type != NULL) 2914 return type; 2915 } 2916 2917 if (nsyms == 1) 2918 { 2919 write_var_from_sym (block, syms[0].block, syms[0].sym); 2920 write_selectors (encoded_name + tail_index); 2921 return NULL; 2922 } 2923 else if (nsyms == 0) 2924 { 2925 int i; 2926 struct minimal_symbol *msym 2927 = ada_lookup_simple_minsym (encoded_name); 2928 if (msym != NULL) 2929 { 2930 write_exp_msymbol (msym, lookup_function_type (type_int ()), 2931 type_int ()); 2932 /* Maybe cause error here rather than later? FIXME? */ 2933 write_selectors (encoded_name + tail_index); 2934 return NULL; 2935 } 2936 2937 if (tail_index == name_len 2938 && strncmp (encoded_name, "standard__", 2939 sizeof ("standard__") - 1) == 0) 2940 error (_("No definition of \"%s\" found."), name0.ptr); 2941 2942 tail_index = chop_selector (encoded_name, tail_index); 2943 } 2944 else 2945 { 2946 write_ambiguous_var (block, encoded_name, tail_index); 2947 write_selectors (encoded_name + tail_index); 2948 return NULL; 2949 } 2950 } 2951 2952 if (!have_full_symbols () && !have_partial_symbols () && block == NULL) 2953 error (_("No symbol table is loaded. Use the \"file\" command.")); 2954 if (block == expression_context_block) 2955 error (_("No definition of \"%s\" in current context."), name0.ptr); 2956 else 2957 error (_("No definition of \"%s\" in specified context."), name0.ptr); 2958 2959 TryAfterRenaming: ; 2960 } 2961 2962 error (_("Could not find renamed symbol \"%s\""), name0.ptr); 2963 2964} 2965 2966/* Write a left side of a component association (e.g., NAME in NAME => 2967 exp). If NAME has the form of a selected component, write it as an 2968 ordinary expression. If it is a simple variable that unambiguously 2969 corresponds to exactly one symbol that does not denote a type or an 2970 object renaming, also write it normally as an OP_VAR_VALUE. 2971 Otherwise, write it as an OP_NAME. 2972 2973 Unfortunately, we don't know at this point whether NAME is supposed 2974 to denote a record component name or the value of an array index. 2975 Therefore, it is not appropriate to disambiguate an ambiguous name 2976 as we normally would, nor to replace a renaming with its referent. 2977 As a result, in the (one hopes) rare case that one writes an 2978 aggregate such as (R => 42) where R renames an object or is an 2979 ambiguous name, one must write instead ((R) => 42). */ 2980 2981static void 2982write_name_assoc (struct stoken name) 2983{ 2984 if (strchr (name.ptr, '.') == NULL) 2985 { 2986 struct ada_symbol_info *syms; 2987 int nsyms = ada_lookup_symbol_list (name.ptr, expression_context_block, 2988 VAR_DOMAIN, &syms); 2989 if (nsyms != 1 || SYMBOL_CLASS (syms[0].sym) == LOC_TYPEDEF) 2990 write_exp_op_with_string (OP_NAME, name); 2991 else 2992 write_var_from_sym (NULL, syms[0].block, syms[0].sym); 2993 } 2994 else 2995 if (write_var_or_type (NULL, name) != NULL) 2996 error (_("Invalid use of type.")); 2997} 2998 2999/* Convert the character literal whose ASCII value would be VAL to the 3000 appropriate value of type TYPE, if there is a translation. 3001 Otherwise return VAL. Hence, in an enumeration type ('A', 'B'), 3002 the literal 'A' (VAL == 65), returns 0. */ 3003 3004static LONGEST 3005convert_char_literal (struct type *type, LONGEST val) 3006{ 3007 char name[7]; 3008 int f; 3009 3010 if (type == NULL || TYPE_CODE (type) != TYPE_CODE_ENUM) 3011 return val; 3012 sprintf (name, "QU%02x", (int) val); 3013 for (f = 0; f < TYPE_NFIELDS (type); f += 1) 3014 { 3015 if (strcmp (name, TYPE_FIELD_NAME (type, f)) == 0) 3016 return TYPE_FIELD_BITPOS (type, f); 3017 } 3018 return val; 3019} 3020 3021static struct type * 3022type_int (void) 3023{ 3024 return builtin_type (current_gdbarch)->builtin_int; 3025} 3026 3027static struct type * 3028type_long (void) 3029{ 3030 return builtin_type (current_gdbarch)->builtin_long; 3031} 3032 3033static struct type * 3034type_long_long (void) 3035{ 3036 return builtin_type (current_gdbarch)->builtin_long_long; 3037} 3038 3039static struct type * 3040type_float (void) 3041{ 3042 return builtin_type (current_gdbarch)->builtin_float; 3043} 3044 3045static struct type * 3046type_double (void) 3047{ 3048 return builtin_type (current_gdbarch)->builtin_double; 3049} 3050 3051static struct type * 3052type_long_double (void) 3053{ 3054 return builtin_type (current_gdbarch)->builtin_long_double; 3055} 3056 3057static struct type * 3058type_char (void) 3059{ 3060 return language_string_char_type (current_language, current_gdbarch); 3061} 3062 3063static struct type * 3064type_system_address (void) 3065{ 3066 struct type *type 3067 = language_lookup_primitive_type_by_name (current_language, 3068 current_gdbarch, 3069 "system__address"); 3070 return type != NULL ? type : lookup_pointer_type (builtin_type_void); 3071} 3072 3073void 3074_initialize_ada_exp (void) 3075{ 3076 obstack_init (&temp_parse_space); 3077} 3078 3079/* FIXME: hilfingr/2004-10-05: Hack to remove warning. The function 3080 string_to_operator is supposed to be used for cases where one 3081 calls an operator function with prefix notation, as in 3082 "+" (a, b), but at some point, this code seems to have gone 3083 missing. */ 3084 3085struct stoken (*dummy_string_to_ada_operator) (struct stoken) 3086 = string_to_operator; 3087 3088 3089