contrib/gdb/gdb/ada-exp.c

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