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