contrib/gdb-7/gdb/ada-exp.c

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