contrib/gdb/gdb/jv-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      INTEGER_LITERAL = 258,
  57      FLOATING_POINT_LITERAL = 259,
  58      IDENTIFIER = 260,
  59      STRING_LITERAL = 261,
  60      BOOLEAN_LITERAL = 262,
  61      TYPENAME = 263,
  62      NAME_OR_INT = 264,
  63      ERROR = 265,
  64      LONG = 266,
  65      SHORT = 267,
  66      BYTE = 268,
  67      INT = 269,
  68      CHAR = 270,
  69      BOOLEAN = 271,
  70      DOUBLE = 272,
  71      FLOAT = 273,
  72      VARIABLE = 274,
  73      ASSIGN_MODIFY = 275,
  74      SUPER = 276,
  75      NEW = 277,
  76      OROR = 278,
  77      ANDAND = 279,
  78      NOTEQUAL = 280,
  79      EQUAL = 281,
  80      GEQ = 282,
  81      LEQ = 283,
  82      RSH = 284,
  83      LSH = 285,
  84      DECREMENT = 286,
  85      INCREMENT = 287
  86    };
  87 #endif
  88 #define INTEGER_LITERAL 258
  89 #define FLOATING_POINT_LITERAL 259
  90 #define IDENTIFIER 260
  91 #define STRING_LITERAL 261
  92 #define BOOLEAN_LITERAL 262
  93 #define TYPENAME 263
  94 #define NAME_OR_INT 264
  95 #define ERROR 265
  96 #define LONG 266
  97 #define SHORT 267
  98 #define BYTE 268
  99 #define INT 269
 100 #define CHAR 270
 101 #define BOOLEAN 271
 102 #define DOUBLE 272
 103 #define FLOAT 273
 104 #define VARIABLE 274
 105 #define ASSIGN_MODIFY 275
 106 #define SUPER 276
 107 #define NEW 277
 108 #define OROR 278
 109 #define ANDAND 279
 110 #define NOTEQUAL 280
 111 #define EQUAL 281
 112 #define GEQ 282
 113 #define LEQ 283
 114 #define RSH 284
 115 #define LSH 285
 116 #define DECREMENT 286
 117 #define INCREMENT 287
 118
 119
 120
 121
 122 /* Copy the first part of user declarations.  */
 123 #line 38 "jv-exp.y"
 124
 125
 126 #include "defs.h"
 127 #include "gdb_string.h"
 128 #include <ctype.h>
 129 #include "expression.h"
 130 #include "value.h"
 131 #include "parser-defs.h"
 132 #include "language.h"
 133 #include "jv-lang.h"
 134 #include "bfd.h" /* Required by objfiles.h.  */
 135 #include "symfile.h" /* Required by objfiles.h.  */
 136 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
 137 #include "block.h"
 138
 139 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
 140    as well as gratuitiously global symbol names, so we can have multiple
 141    yacc generated parsers in gdb.  Note that these are only the variables
 142    produced by yacc.  If other parser generators (bison, byacc, etc) produce
 143    additional global names that conflict at link time, then those parser
 144    generators need to be fixed instead of adding those names to this list. */
 145
 146 #define yymaxdepth java_maxdepth
 147 #define yyparse java_parse
 148 #define yylex   java_lex
 149 #define yyerror java_error
 150 #define yylval  java_lval
 151 #define yychar  java_char
 152 #define yydebug java_debug
 153 #define yypact  java_pact
 154 #define yyr1    java_r1
 155 #define yyr2    java_r2
 156 #define yydef   java_def
 157 #define yychk   java_chk
 158 #define yypgo   java_pgo
 159 #define yyact   java_act
 160 #define yyexca  java_exca
 161 #define yyerrflag java_errflag
 162 #define yynerrs java_nerrs
 163 #define yyps    java_ps
 164 #define yypv    java_pv
 165 #define yys     java_s
 166 #define yy_yys  java_yys
 167 #define yystate java_state
 168 #define yytmp   java_tmp
 169 #define yyv     java_v
 170 #define yy_yyv  java_yyv
 171 #define yyval   java_val
 172 #define yylloc  java_lloc
 173 #define yyreds  java_reds               /* With YYDEBUG defined */
 174 #define yytoks  java_toks               /* With YYDEBUG defined */
 175 #define yyname  java_name               /* With YYDEBUG defined */
 176 #define yyrule  java_rule               /* With YYDEBUG defined */
 177 #define yylhs   java_yylhs
 178 #define yylen   java_yylen
 179 #define yydefred java_yydefred
 180 #define yydgoto java_yydgoto
 181 #define yysindex java_yysindex
 182 #define yyrindex java_yyrindex
 183 #define yygindex java_yygindex
 184 #define yytable  java_yytable
 185 #define yycheck  java_yycheck
 186
 187 #ifndef YYDEBUG
 188 #define YYDEBUG 1               /* Default to yydebug support */
 189 #endif
 190
 191 #define YYFPRINTF parser_fprintf
 192
 193 int yyparse (void);
 194
 195 static int yylex (void);
 196
 197 void yyerror (char *);
 198
 199 static struct type *java_type_from_name (struct stoken);
 200 static void push_expression_name (struct stoken);
 201 static void push_fieldnames (struct stoken);
 202
 203 static struct expression *copy_exp (struct expression *, int);
 204 static void insert_exp (int, struct expression *);
 205
 206
 207
 208 /* Enabling traces.  */
 209 #ifndef YYDEBUG
 210 # define YYDEBUG 0
 211 #endif
 212
 213 /* Enabling verbose error messages.  */
 214 #ifdef YYERROR_VERBOSE
 215 # undef YYERROR_VERBOSE
 216 # define YYERROR_VERBOSE 1
 217 #else
 218 # define YYERROR_VERBOSE 0
 219 #endif
 220
 221 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
 222 #line 127 "jv-exp.y"
 223 typedef union YYSTYPE {
 224     LONGEST lval;
 225     struct {
 226       LONGEST val;
 227       struct type *type;
 228     } typed_val_int;
 229     struct {
 230       DOUBLEST dval;
 231       struct type *type;
 232     } typed_val_float;
 233     struct symbol *sym;
 234     struct type *tval;
 235     struct stoken sval;
 236     struct ttype tsym;
 237     struct symtoken ssym;
 238     struct block *bval;
 239     enum exp_opcode opcode;
 240     struct internalvar *ivar;
 241     int *ivec;
 242   } YYSTYPE;
 243 /* Line 191 of yacc.c.  */
 244 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 245 # define YYSTYPE_IS_DECLARED 1
 246 # define YYSTYPE_IS_TRIVIAL 1
 247 #endif
 248
 249
 250
 251 /* Copy the second part of user declarations.  */
 252 #line 148 "jv-exp.y"
 253
 254 /* YYSTYPE gets defined by %union */
 255 static int parse_number (char *, int, int, YYSTYPE *);
 256
 257
 258 /* Line 214 of yacc.c.  */
 259
 260 #if ! defined (yyoverflow) || YYERROR_VERBOSE
 261
 262 /* The parser invokes alloca or xmalloc; define the necessary symbols.  */
 263
 264 # if YYSTACK_USE_ALLOCA
 265 #  define YYSTACK_ALLOC alloca
 266 # else
 267 #  ifndef YYSTACK_USE_ALLOCA
 268 #   if defined (alloca) || defined (_ALLOCA_H)
 269 #    define YYSTACK_ALLOC alloca
 270 #   else
 271 #    ifdef __GNUC__
 272 #     define YYSTACK_ALLOC __builtin_alloca
 273 #    endif
 274 #   endif
 275 #  endif
 276 # endif
 277
 278 # ifdef YYSTACK_ALLOC
 279    /* Pacify GCC's `empty if-body' warning. */
 280 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
 281 # else
 282 #  if defined (__STDC__) || defined (__cplusplus)
 283 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 284 #   define YYSIZE_T size_t
 285 #  endif
 286 #  define YYSTACK_ALLOC xmalloc
 287 #  define YYSTACK_FREE free
 288 # endif
 289 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
 290
 291
 292 #if (! defined (yyoverflow) \
 293      && (! defined (__cplusplus) \
 294          || (YYSTYPE_IS_TRIVIAL)))
 295
 296 /* A type that is properly aligned for any stack member.  */
 297 union yyalloc
 298 {
 299   short yyss;
 300   YYSTYPE yyvs;
 301   };
 302
 303 /* The size of the maximum gap between one aligned stack and the next.  */
 304 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
 305
 306 /* The size of an array large to enough to hold all stacks, each with
 307    N elements.  */
 308 # define YYSTACK_BYTES(N) \
 309      ((N) * (sizeof (short) + sizeof (YYSTYPE))                         \
 310       + YYSTACK_GAP_MAXIMUM)
 311
 312 /* Copy COUNT objects from FROM to TO.  The source and destination do
 313    not overlap.  */
 314 # ifndef YYCOPY
 315 #  if 1 < __GNUC__
 316 #   define YYCOPY(To, From, Count) \
 317       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 318 #  else
 319 #   define YYCOPY(To, From, Count)              \
 320       do                                        \
 321         {                                       \
 322           register YYSIZE_T yyi;                \
 323           for (yyi = 0; yyi < (Count); yyi++)   \
 324             (To)[yyi] = (From)[yyi];            \
 325         }                                       \
 326       while (0)
 327 #  endif
 328 # endif
 329
 330 /* Relocate STACK from its old location to the new one.  The
 331    local variables YYSIZE and YYSTACKSIZE give the old and new number of
 332    elements in the stack, and YYPTR gives the new location of the
 333    stack.  Advance YYPTR to a properly aligned location for the next
 334    stack.  */
 335 # define YYSTACK_RELOCATE(Stack)                                        \
 336     do                                                                  \
 337       {                                                                 \
 338         YYSIZE_T yynewbytes;                                            \
 339         YYCOPY (&yyptr->Stack, Stack, yysize);                          \
 340         Stack = &yyptr->Stack;                                          \
 341         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
 342         yyptr += yynewbytes / sizeof (*yyptr);                          \
 343       }                                                                 \
 344     while (0)
 345
 346 #endif
 347
 348 #if defined (__STDC__) || defined (__cplusplus)
 349    typedef signed char yysigned_char;
 350 #else
 351    typedef short yysigned_char;
 352 #endif
 353
 354 /* YYFINAL -- State number of the termination state. */
 355 #define YYFINAL  97
 356 /* YYLAST -- Last index in YYTABLE.  */
 357 #define YYLAST   421
 358
 359 /* YYNTOKENS -- Number of terminals. */
 360 #define YYNTOKENS  56
 361 /* YYNNTS -- Number of nonterminals. */
 362 #define YYNNTS  56
 363 /* YYNRULES -- Number of rules. */
 364 #define YYNRULES  130
 365 /* YYNRULES -- Number of states. */
 366 #define YYNSTATES  207
 367
 368 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 369 #define YYUNDEFTOK  2
 370 #define YYMAXUTOK   287
 371
 372 #define YYTRANSLATE(YYX)                                                \
 373   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 374
 375 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
 376 static const unsigned char yytranslate[] =
 377 {
 378        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 379        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 380        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 381        2,     2,     2,    54,     2,     2,     2,    43,    30,     2,
 382       48,    49,    41,    39,    23,    40,    46,    42,     2,     2,
 383        2,     2,     2,     2,     2,     2,     2,     2,    55,     2,
 384       33,    24,    34,    25,     2,     2,     2,     2,     2,     2,
 385        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 386        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 387        2,    47,     2,    52,    29,     2,     2,     2,     2,     2,
 388        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 389        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 390        2,     2,     2,    50,    28,    51,    53,     2,     2,     2,
 391        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 392        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 393        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 394        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 395        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 396        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 397        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 398        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 399        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 400        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 401        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 402        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 403        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
 404        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
 405       15,    16,    17,    18,    19,    20,    21,    22,    26,    27,
 406       31,    32,    35,    36,    37,    38,    44,    45
 407 };
 408
 409 #if YYDEBUG
 410 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
 411    YYRHS.  */
 412 static const unsigned short yyprhs[] =
 413 {
 414        0,     0,     3,     5,     7,     9,    11,    13,    15,    17,
 415       19,    21,    23,    25,    27,    29,    31,    33,    35,    37,
 416       39,    41,    43,    45,    47,    49,    51,    54,    57,    59,
 417       61,    63,    65,    67,    69,    73,    75,    79,    81,    83,
 418       85,    89,    91,    93,    95,    97,   101,   103,   105,   111,
 419      113,   117,   118,   120,   125,   130,   132,   135,   139,   142,
 420      146,   148,   149,   153,   157,   162,   169,   176,   181,   186,
 421      191,   193,   195,   197,   199,   201,   204,   207,   209,   211,
 422      214,   217,   220,   222,   225,   228,   230,   233,   236,   238,
 423      244,   249,   255,   257,   261,   265,   269,   271,   275,   279,
 424      281,   285,   289,   291,   295,   299,   303,   307,   309,   313,
 425      317,   319,   323,   325,   329,   331,   335,   337,   341,   343,
 426      347,   349,   355,   357,   359,   363,   367,   369,   371,   373,
 427      375
 428 };
 429
 430 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
 431 static const yysigned_char yyrhs[] =
 432 {
 433       57,     0,    -1,    73,    -1,    58,    -1,    59,    -1,    62,
 434       -1,    68,    -1,     6,    -1,     3,    -1,     9,    -1,     4,
 435       -1,     7,    -1,    60,    -1,    63,    -1,    16,    -1,    64,
 436       -1,    65,    -1,    13,    -1,    12,    -1,    14,    -1,    11,
 437       -1,    15,    -1,    18,    -1,    17,    -1,    69,    -1,    66,
 438       -1,    62,    84,    -1,    69,    84,    -1,     5,    -1,    72,
 439       -1,    71,    -1,    72,    -1,     5,    -1,     9,    -1,    69,
 440       46,    71,    -1,   111,    -1,    73,    23,   111,    -1,    75,
 441       -1,    81,    -1,    61,    -1,    48,   111,    49,    -1,    78,
 442       -1,    86,    -1,    87,    -1,    88,    -1,    76,    79,    77,
 443       -1,    50,    -1,    51,    -1,    22,    67,    48,    80,    49,
 444       -1,   111,    -1,    79,    23,   111,    -1,    -1,    79,    -1,
 445       22,    62,    82,    85,    -1,    22,    66,    82,    85,    -1,
 446       83,    -1,    82,    83,    -1,    47,   111,    52,    -1,    47,
 447       52,    -1,    84,    47,    52,    -1,    84,    -1,    -1,    74,
 448       46,    71,    -1,    19,    46,    71,    -1,    69,    48,    80,
 449       49,    -1,    74,    46,    71,    48,    80,    49,    -1,    21,
 450       46,    71,    48,    80,    49,    -1,    69,    47,   111,    52,
 451       -1,    19,    47,   111,    52,    -1,    75,    47,   111,    52,
 452       -1,    74,    -1,    69,    -1,    19,    -1,    90,    -1,    91,
 453       -1,    89,    45,    -1,    89,    44,    -1,    93,    -1,    94,
 454       -1,    39,    92,    -1,    40,    92,    -1,    41,    92,    -1,
 455       95,    -1,    45,    92,    -1,    44,    92,    -1,    89,    -1,
 456       53,    92,    -1,    54,    92,    -1,    96,    -1,    48,    62,
 457       85,    49,    92,    -1,    48,   111,    49,    95,    -1,    48,
 458       69,    84,    49,    95,    -1,    92,    -1,    97,    41,    92,
 459       -1,    97,    42,    92,    -1,    97,    43,    92,    -1,    97,
 460       -1,    98,    39,    97,    -1,    98,    40,    97,    -1,    98,
 461       -1,    99,    38,    98,    -1,    99,    37,    98,    -1,    99,
 462       -1,   100,    33,    99,    -1,   100,    34,    99,    -1,   100,
 463       36,    99,    -1,   100,    35,    99,    -1,   100,    -1,   101,
 464       32,   100,    -1,   101,    31,   100,    -1,   101,    -1,   102,
 465       30,   101,    -1,   102,    -1,   103,    29,   102,    -1,   103,
 466       -1,   104,    28,   103,    -1,   104,    -1,   105,    27,   104,
 467       -1,   105,    -1,   106,    26,   105,    -1,   106,    -1,   106,
 468       25,   111,    55,   107,    -1,   107,    -1,   109,    -1,   110,
 469       24,   107,    -1,   110,    20,   107,    -1,    70,    -1,    19,
 470       -1,    86,    -1,    88,    -1,   108,    -1
 471 };
 472
 473 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 474 static const unsigned short yyrline[] =
 475 {
 476        0,   204,   204,   205,   208,   217,   218,   222,   231,   236,
 477      244,   249,   254,   265,   266,   271,   272,   276,   278,   280,
 478      282,   284,   289,   291,   303,   308,   312,   314,   319,   320,
 479      324,   325,   329,   330,   334,   357,   358,   363,   364,   368,
 480      369,   370,   371,   372,   373,   374,   382,   387,   392,   398,
 481      400,   406,   407,   411,   414,   420,   421,   425,   429,   431,
 482      436,   438,   442,   444,   450,   452,   454,   459,   476,   478,
 483      483,   484,   486,   488,   489,   493,   498,   503,   504,   505,
 484      506,   508,   510,   514,   519,   524,   525,   527,   529,   533,
 485      537,   558,   566,   567,   569,   571,   576,   577,   579,   584,
 486      585,   587,   593,   594,   596,   598,   600,   606,   607,   609,
 487      614,   615,   620,   621,   625,   626,   631,   632,   637,   638,
 488      643,   644,   649,   650,   654,   656,   663,   665,   667,   668,
 489      673
 490 };
 491 #endif
 492
 493 #if YYDEBUG || YYERROR_VERBOSE
 494 /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 495    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
 496 static const char *const yytname[] =
 497 {
 498   "$end", "error", "$undefined", "INTEGER_LITERAL",
 499   "FLOATING_POINT_LITERAL", "IDENTIFIER", "STRING_LITERAL",
 500   "BOOLEAN_LITERAL", "TYPENAME", "NAME_OR_INT", "ERROR", "LONG", "SHORT",
 501   "BYTE", "INT", "CHAR", "BOOLEAN", "DOUBLE", "FLOAT", "VARIABLE",
 502   "ASSIGN_MODIFY", "SUPER", "NEW", "','", "'='", "'?'", "OROR", "ANDAND",
 503   "'|'", "'^'", "'&'", "NOTEQUAL", "EQUAL", "'<'", "'>'", "GEQ", "LEQ",
 504   "RSH", "LSH", "'+'", "'-'", "'*'", "'/'", "'%'", "DECREMENT",
 505   "INCREMENT", "'.'", "'['", "'('", "')'", "'{'", "'}'", "']'", "'~'",
 506   "'!'", "':'", "$accept", "start", "type_exp", "PrimitiveOrArrayType",
 507   "StringLiteral", "Literal", "PrimitiveType", "NumericType",
 508   "IntegralType", "FloatingPointType", "ClassOrInterfaceType",
 509   "ClassType", "ArrayType", "Name", "ForcedName", "SimpleName",
 510   "QualifiedName", "exp1", "Primary", "PrimaryNoNewArray", "lcurly",
 511   "rcurly", "ClassInstanceCreationExpression", "ArgumentList",
 512   "ArgumentList_opt", "ArrayCreationExpression", "DimExprs", "DimExpr",
 513   "Dims", "Dims_opt", "FieldAccess", "MethodInvocation", "ArrayAccess",
 514   "PostfixExpression", "PostIncrementExpression",
 515   "PostDecrementExpression", "UnaryExpression", "PreIncrementExpression",
 516   "PreDecrementExpression", "UnaryExpressionNotPlusMinus",
 517   "CastExpression", "MultiplicativeExpression", "AdditiveExpression",
 518   "ShiftExpression", "RelationalExpression", "EqualityExpression",
 519   "AndExpression", "ExclusiveOrExpression", "InclusiveOrExpression",
 520   "ConditionalAndExpression", "ConditionalOrExpression",
 521   "ConditionalExpression", "AssignmentExpression", "Assignment",
 522   "LeftHandSide", "Expression", 0
 523 };
 524 #endif
 525
 526 # ifdef YYPRINT
 527 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
 528    token YYLEX-NUM.  */
 529 static const unsigned short yytoknum[] =
 530 {
 531        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
 532      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
 533      275,   276,   277,    44,    61,    63,   278,   279,   124,    94,
 534       38,   280,   281,    60,    62,   282,   283,   284,   285,    43,
 535       45,    42,    47,    37,   286,   287,    46,    91,    40,    41,
 536      123,   125,    93,   126,    33,    58
 537 };
 538 # endif
 539
 540 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 541 static const unsigned char yyr1[] =
 542 {
 543        0,    56,    57,    57,    58,    59,    59,    60,    61,    61,
 544       61,    61,    61,    62,    62,    63,    63,    64,    64,    64,
 545       64,    64,    65,    65,    66,    67,    68,    68,    69,    69,
 546       70,    70,    71,    71,    72,    73,    73,    74,    74,    75,
 547       75,    75,    75,    75,    75,    75,    76,    77,    78,    79,
 548       79,    80,    80,    81,    81,    82,    82,    83,    84,    84,
 549       85,    85,    86,    86,    87,    87,    87,    88,    88,    88,
 550       89,    89,    89,    89,    89,    90,    91,    92,    92,    92,
 551       92,    92,    92,    93,    94,    95,    95,    95,    95,    96,
 552       96,    96,    97,    97,    97,    97,    98,    98,    98,    99,
 553       99,    99,   100,   100,   100,   100,   100,   101,   101,   101,
 554      102,   102,   103,   103,   104,   104,   105,   105,   106,   106,
 555      107,   107,   108,   108,   109,   109,   110,   110,   110,   110,
 556      111
 557 };
 558
 559 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 560 static const unsigned char yyr2[] =
 561 {
 562        0,     2,     1,     1,     1,     1,     1,     1,     1,     1,
 563        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
 564        1,     1,     1,     1,     1,     1,     2,     2,     1,     1,
 565        1,     1,     1,     1,     3,     1,     3,     1,     1,     1,
 566        3,     1,     1,     1,     1,     3,     1,     1,     5,     1,
 567        3,     0,     1,     4,     4,     1,     2,     3,     2,     3,
 568        1,     0,     3,     3,     4,     6,     6,     4,     4,     4,
 569        1,     1,     1,     1,     1,     2,     2,     1,     1,     2,
 570        2,     2,     1,     2,     2,     1,     2,     2,     1,     5,
 571        4,     5,     1,     3,     3,     3,     1,     3,     3,     1,
 572        3,     3,     1,     3,     3,     3,     3,     1,     3,     3,
 573        1,     3,     1,     3,     1,     3,     1,     3,     1,     3,
 574        1,     5,     1,     1,     3,     3,     1,     1,     1,     1,
 575        1
 576 };
 577
 578 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
 579    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
 580    means the default is an error.  */
 581 static const unsigned char yydefact[] =
 582 {
 583        0,     8,    10,    28,     7,    11,     9,    20,    18,    17,
 584       19,    21,    14,    23,    22,    72,     0,     0,     0,     0,
 585        0,     0,     0,     0,    46,     0,     0,     0,     3,     4,
 586       12,    39,     5,    13,    15,    16,     6,    71,   126,    30,
 587       29,     2,    70,    37,     0,    41,    38,    42,    43,    44,
 588       85,    73,    74,    92,    77,    78,    82,    88,    96,    99,
 589      102,   107,   110,   112,   114,   116,   118,   120,   122,   130,
 590      123,     0,    35,     0,     0,     0,    28,     0,    25,     0,
 591       24,    29,     9,    72,    71,    42,    44,    79,    80,    81,
 592       84,    83,    61,    71,     0,    86,    87,     1,     0,    26,
 593        0,     0,    51,    27,     0,     0,     0,     0,    49,    76,
 594       75,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 595        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 596        0,     0,    32,    33,    63,     0,     0,     0,    61,    55,
 597       61,    51,     0,    60,     0,     0,    40,    58,     0,    34,
 598        0,    52,     0,    36,    62,     0,     0,    47,    45,    93,
 599       94,    95,    97,    98,   101,   100,   103,   104,   106,   105,
 600      109,   108,   111,   113,   115,   117,     0,   119,   125,   124,
 601       68,    51,     0,     0,    56,    53,    54,     0,     0,     0,
 602       90,    59,    67,    64,    51,    69,    50,     0,     0,    57,
 603       48,    89,    91,     0,   121,    66,    65
 604 };
 605
 606 /* YYDEFGOTO[NTERM-NUM]. */
 607 static const short yydefgoto[] =
 608 {
 609       -1,    27,    28,    29,    30,    31,    32,    33,    34,    35,
 610       78,    79,    36,    84,    38,    39,    81,    41,    42,    43,
 611       44,   158,    45,   151,   152,    46,   138,   139,   143,   144,
 612       85,    48,    86,    50,    51,    52,    53,    54,    55,    56,
 613       57,    58,    59,    60,    61,    62,    63,    64,    65,    66,
 614       67,    68,    69,    70,    71,   108
 615 };
 616
 617 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 618    STATE-NUM.  */
 619 #define YYPACT_NINF -135
 620 static const short yypact[] =
 621 {
 622      204,  -135,  -135,     8,  -135,  -135,    14,  -135,  -135,  -135,
 623     -135,  -135,  -135,  -135,  -135,    -4,     5,    50,   308,   308,
 624      308,   308,   308,   204,  -135,   308,   308,    40,  -135,  -135,
 625     -135,  -135,    -1,  -135,  -135,  -135,  -135,    37,  -135,  -135,
 626       28,    36,    45,    46,   360,  -135,  -135,    33,  -135,    49,
 627      -19,  -135,  -135,  -135,  -135,  -135,  -135,  -135,    84,    31,
 628       95,    54,    89,    75,    74,    81,    88,   110,  -135,  -135,
 629     -135,    52,  -135,    73,   360,    73,  -135,    64,    64,    69,
 630       77,  -135,  -135,    92,    83,  -135,  -135,  -135,  -135,  -135,
 631     -135,  -135,    -1,    37,   103,  -135,  -135,  -135,   107,   114,
 632       73,   256,   360,   114,   360,    73,   360,    -6,  -135,  -135,
 633     -135,   308,   308,   308,   308,   308,   308,   308,   308,   308,
 634      308,   308,   308,   308,   308,   308,   308,   308,   360,   308,
 635      308,   308,  -135,  -135,  -135,   111,   116,   360,   118,  -135,
 636      118,   360,   360,   114,   117,   -16,   367,  -135,   115,  -135,
 637      120,   146,   121,  -135,   125,   123,   360,  -135,  -135,  -135,
 638     -135,  -135,    84,    84,    31,    31,    95,    95,    95,    95,
 639       54,    54,    89,    75,    74,    81,   122,    88,  -135,  -135,
 640     -135,   360,   124,   256,  -135,  -135,  -135,   129,   308,   367,
 641     -135,  -135,  -135,  -135,   360,  -135,  -135,   308,   130,  -135,
 642     -135,  -135,  -135,   131,  -135,  -135,  -135
 643 };
 644
 645 /* YYPGOTO[NTERM-NUM].  */
 646 static const short yypgoto[] =
 647 {
 648     -135,  -135,  -135,  -135,  -135,  -135,     4,  -135,  -135,  -135,
 649     -135,  -135,  -135,    13,  -135,   -51,     0,  -135,  -135,  -135,
 650     -135,  -135,  -135,   138,  -134,  -135,   106,  -101,   -18,   -59,
 651        6,  -135,    12,  -135,  -135,  -135,   -17,  -135,  -135,  -131,
 652     -135,    30,    34,   -21,    35,    61,    63,    60,    65,    62,
 653     -135,  -120,  -135,  -135,  -135,    18
 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 -130
 661 static const short yytable[] =
 662 {
 663       40,    87,    88,    89,    90,    91,    47,   187,    95,    96,
 664      178,   179,    49,    37,    99,   190,  -127,   156,    72,   103,
 665     -127,    77,   134,    40,   136,   109,   110,    92,   -32,    47,
 666       80,   148,   -32,   189,   -33,    49,    93,   184,   -33,   184,
 667       97,    94,    73,    74,    40,   157,    98,   198,   -31,   149,
 668       47,    75,   -31,  -128,   154,    76,    49,  -128,   202,   104,
 669      203,     7,     8,     9,    10,    11,    12,    13,    14,  -129,
 670      114,   115,   130,  -129,    40,   145,   131,   204,   132,   185,
 671       47,   186,   133,   100,   101,   102,    49,   118,   119,   120,
 672      121,   105,   135,   106,   159,   160,   161,   166,   167,   168,
 673      169,    40,    40,   125,    40,   124,    40,    47,    47,   126,
 674       47,   137,    47,    49,    49,   127,    49,   141,    49,   150,
 675      122,   123,   153,   100,   155,   111,   112,   113,    40,   100,
 676      142,   102,   116,   117,    47,   128,   129,    40,    73,    74,
 677       49,    40,    40,    47,   162,   163,   176,    47,    47,    49,
 678      164,   165,   146,    49,    49,   182,    40,   170,   171,   147,
 679      150,   148,    47,   180,   181,   183,   188,   191,    49,   156,
 680      193,   201,   192,   194,   196,   195,   199,   197,   200,   205,
 681      206,    40,   107,    40,   140,   172,   174,    47,   173,    47,
 682        0,   177,   175,    49,    40,    49,     0,     0,     0,     0,
 683       47,   182,     0,     0,     0,     0,    49,     1,     2,     3,
 684        4,     5,     0,     6,     0,     7,     8,     9,    10,    11,
 685       12,    13,    14,    15,     0,    16,    17,     0,     0,     0,
 686        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 687        0,     0,     0,    18,    19,    20,     0,     0,    21,    22,
 688        0,     0,    23,     0,    24,     0,     0,    25,    26,     1,
 689        2,     3,     4,     5,     0,     6,     0,     0,     0,     0,
 690        0,     0,     0,     0,     0,    15,     0,    16,    17,     0,
 691        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 692        0,     0,     0,     0,     0,    18,    19,    20,     0,     0,
 693       21,    22,     0,     0,    23,     0,    24,     0,   147,    25,
 694       26,     1,     2,    76,     4,     5,     0,    82,     0,     0,
 695        0,     0,     0,     0,     0,     0,     0,    83,     0,    16,
 696       17,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 697        0,     0,     0,     0,     0,     0,     0,    18,    19,    20,
 698        0,     0,    21,    22,     0,     0,    23,     0,    24,     0,
 699        0,    25,    26,     1,     2,     3,     4,     5,     0,     6,
 700        1,     2,    76,     4,     5,     0,    82,     0,     0,    15,
 701        0,    16,    17,     0,     0,     0,    83,     0,    16,    17,
 702        0,     0,     0,     0,     0,     0,     0,     0,     0,    18,
 703       19,    20,     0,     0,    21,    22,     0,     0,    23,     0,
 704       24,     0,     0,    25,    26,    23,     0,    24,     0,     0,
 705       25,    26
 706 };
 707
 708 static const short yycheck[] =
 709 {
 710        0,    18,    19,    20,    21,    22,     0,   141,    25,    26,
 711      130,   131,     0,     0,    32,   146,    20,    23,     0,    37,
 712       24,    17,    73,    23,    75,    44,    45,    23,    20,    23,
 713       17,    47,    24,    49,    20,    23,    23,   138,    24,   140,
 714        0,    23,    46,    47,    44,    51,    47,   181,    20,   100,
 715       44,    46,    24,    20,   105,     5,    44,    24,   189,    23,
 716      194,    11,    12,    13,    14,    15,    16,    17,    18,    20,
 717       39,    40,    20,    24,    74,    93,    24,   197,     5,   138,
 718       74,   140,     9,    46,    47,    48,    74,    33,    34,    35,
 719       36,    46,    74,    47,   111,   112,   113,   118,   119,   120,
 720      121,   101,   102,    29,   104,    30,   106,   101,   102,    28,
 721      104,    47,   106,   101,   102,    27,   104,    48,   106,   101,
 722       31,    32,   104,    46,   106,    41,    42,    43,   128,    46,
 723       47,    48,    37,    38,   128,    25,    26,   137,    46,    47,
 724      128,   141,   142,   137,   114,   115,   128,   141,   142,   137,
 725      116,   117,    49,   141,   142,   137,   156,   122,   123,    52,
 726      142,    47,   156,    52,    48,    47,    49,    52,   156,    23,
 727       49,   188,    52,    48,   156,    52,    52,    55,    49,    49,
 728       49,   181,    44,   183,    78,   124,   126,   181,   125,   183,
 729       -1,   129,   127,   181,   194,   183,    -1,    -1,    -1,    -1,
 730      194,   183,    -1,    -1,    -1,    -1,   194,     3,     4,     5,
 731        6,     7,    -1,     9,    -1,    11,    12,    13,    14,    15,
 732       16,    17,    18,    19,    -1,    21,    22,    -1,    -1,    -1,
 733       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
 734       -1,    -1,    -1,    39,    40,    41,    -1,    -1,    44,    45,
 735       -1,    -1,    48,    -1,    50,    -1,    -1,    53,    54,     3,
 736        4,     5,     6,     7,    -1,     9,    -1,    -1,    -1,    -1,
 737       -1,    -1,    -1,    -1,    -1,    19,    -1,    21,    22,    -1,
 738       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
 739       -1,    -1,    -1,    -1,    -1,    39,    40,    41,    -1,    -1,
 740       44,    45,    -1,    -1,    48,    -1,    50,    -1,    52,    53,
 741       54,     3,     4,     5,     6,     7,    -1,     9,    -1,    -1,
 742       -1,    -1,    -1,    -1,    -1,    -1,    -1,    19,    -1,    21,
 743       22,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
 744       -1,    -1,    -1,    -1,    -1,    -1,    -1,    39,    40,    41,
 745       -1,    -1,    44,    45,    -1,    -1,    48,    -1,    50,    -1,
 746       -1,    53,    54,     3,     4,     5,     6,     7,    -1,     9,
 747        3,     4,     5,     6,     7,    -1,     9,    -1,    -1,    19,
 748       -1,    21,    22,    -1,    -1,    -1,    19,    -1,    21,    22,
 749       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    39,
 750       40,    41,    -1,    -1,    44,    45,    -1,    -1,    48,    -1,
 751       50,    -1,    -1,    53,    54,    48,    -1,    50,    -1,    -1,
 752       53,    54
 753 };
 754
 755 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
 756    symbol of state STATE-NUM.  */
 757 static const unsigned char yystos[] =
 758 {
 759        0,     3,     4,     5,     6,     7,     9,    11,    12,    13,
 760       14,    15,    16,    17,    18,    19,    21,    22,    39,    40,
 761       41,    44,    45,    48,    50,    53,    54,    57,    58,    59,
 762       60,    61,    62,    63,    64,    65,    68,    69,    70,    71,
 763       72,    73,    74,    75,    76,    78,    81,    86,    87,    88,
 764       89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
 765       99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
 766      109,   110,   111,    46,    47,    46,     5,    62,    66,    67,
 767       69,    72,     9,    19,    69,    86,    88,    92,    92,    92,
 768       92,    92,    62,    69,   111,    92,    92,     0,    47,    84,
 769       46,    47,    48,    84,    23,    46,    47,    79,   111,    44,
 770       45,    41,    42,    43,    39,    40,    37,    38,    33,    34,
 771       35,    36,    31,    32,    30,    29,    28,    27,    25,    26,
 772       20,    24,     5,     9,    71,   111,    71,    47,    82,    83,
 773       82,    48,    47,    84,    85,    84,    49,    52,    47,    71,
 774      111,    79,    80,   111,    71,   111,    23,    51,    77,    92,
 775       92,    92,    97,    97,    98,    98,    99,    99,    99,    99,
 776      100,   100,   101,   102,   103,   104,   111,   105,   107,   107,
 777       52,    48,   111,    47,    83,    85,    85,    80,    49,    49,
 778       95,    52,    52,    49,    48,    52,   111,    55,    80,    52,
 779       49,    92,    95,    80,   107,    49,    49
 780 };
 781
 782 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
 783 # define YYSIZE_T __SIZE_TYPE__
 784 #endif
 785 #if ! defined (YYSIZE_T) && defined (size_t)
 786 # define YYSIZE_T size_t
 787 #endif
 788 #if ! defined (YYSIZE_T)
 789 # if defined (__STDC__) || defined (__cplusplus)
 790 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 791 #  define YYSIZE_T size_t
 792 # endif
 793 #endif
 794 #if ! defined (YYSIZE_T)
 795 # define YYSIZE_T unsigned int
 796 #endif
 797
 798 #define yyerrok         (yyerrstatus = 0)
 799 #define yyclearin       (yychar = YYEMPTY)
 800 #define YYEMPTY         (-2)
 801 #define YYEOF           0
 802
 803 #define YYACCEPT        goto yyacceptlab
 804 #define YYABORT         goto yyabortlab
 805 #define YYERROR         goto yyerrlab1
 806
 807 /* Like YYERROR except do call yyerror.  This remains here temporarily
 808    to ease the transition to the new meaning of YYERROR, for GCC.
 809    Once GCC version 2 has supplanted version 1, this can go.  */
 810
 811 #define YYFAIL          goto yyerrlab
 812
 813 #define YYRECOVERING()  (!!yyerrstatus)
 814
 815 #define YYBACKUP(Token, Value)                                  \
 816 do                                                              \
 817   if (yychar == YYEMPTY && yylen == 1)                          \
 818     {                                                           \
 819       yychar = (Token);                                         \
 820       yylval = (Value);                                         \
 821       yytoken = YYTRANSLATE (yychar);                           \
 822       YYPOPSTACK;                                               \
 823       goto yybackup;                                            \
 824     }                                                           \
 825   else                                                          \
 826     {                                                           \
 827       yyerror ("syntax error: cannot back up");\
 828       YYERROR;                                                  \
 829     }                                                           \
 830 while (0)
 831
 832 #define YYTERROR        1
 833 #define YYERRCODE       256
 834
 835 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
 836    are run).  */
 837
 838 #ifndef YYLLOC_DEFAULT
 839 # define YYLLOC_DEFAULT(Current, Rhs, N)         \
 840   Current.first_line   = Rhs[1].first_line;      \
 841   Current.first_column = Rhs[1].first_column;    \
 842   Current.last_line    = Rhs[N].last_line;       \
 843   Current.last_column  = Rhs[N].last_column;
 844 #endif
 845
 846 /* YYLEX -- calling `yylex' with the right arguments.  */
 847
 848 #ifdef YYLEX_PARAM
 849 # define YYLEX yylex (YYLEX_PARAM)
 850 #else
 851 # define YYLEX yylex ()
 852 #endif
 853
 854 /* Enable debugging if requested.  */
 855 #if YYDEBUG
 856
 857 # ifndef YYFPRINTF
 858 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
 859 #  define YYFPRINTF fprintf
 860 # endif
 861
 862 # define YYDPRINTF(Args)                        \
 863 do {                                            \
 864   if (yydebug)                                  \
 865     YYFPRINTF Args;                             \
 866 } while (0)
 867
 868 # define YYDSYMPRINT(Args)                      \
 869 do {                                            \
 870   if (yydebug)                                  \
 871     yysymprint Args;                            \
 872 } while (0)
 873
 874 # define YYDSYMPRINTF(Title, Token, Value, Location)            \
 875 do {                                                            \
 876   if (yydebug)                                                  \
 877     {                                                           \
 878       YYFPRINTF (stderr, "%s ", Title);                         \
 879       yysymprint (stderr,                                       \
 880                   Token, Value);        \
 881       YYFPRINTF (stderr, "\n");                                 \
 882     }                                                           \
 883 } while (0)
 884
 885 /*------------------------------------------------------------------.
 886 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
 887 | TOP (cinluded).                                                   |
 888 `------------------------------------------------------------------*/
 889
 890 #if defined (__STDC__) || defined (__cplusplus)
 891 static void
 892 yy_stack_print (short *bottom, short *top)
 893 #else
 894 static void
 895 yy_stack_print (bottom, top)
 896     short *bottom;
 897     short *top;
 898 #endif
 899 {
 900   YYFPRINTF (stderr, "Stack now");
 901   for (/* Nothing. */; bottom <= top; ++bottom)
 902     YYFPRINTF (stderr, " %d", *bottom);
 903   YYFPRINTF (stderr, "\n");
 904 }
 905
 906 # define YY_STACK_PRINT(Bottom, Top)                            \
 907 do {                                                            \
 908   if (yydebug)                                                  \
 909     yy_stack_print ((Bottom), (Top));                           \
 910 } while (0)
 911
 912
 913 /*------------------------------------------------.
 914 | Report that the YYRULE is going to be reduced.  |
 915 `------------------------------------------------*/
 916
 917 #if defined (__STDC__) || defined (__cplusplus)
 918 static void
 919 yy_reduce_print (int yyrule)
 920 #else
 921 static void
 922 yy_reduce_print (yyrule)
 923     int yyrule;
 924 #endif
 925 {
 926   int yyi;
 927   unsigned int yylineno = yyrline[yyrule];
 928   YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
 929              yyrule - 1, yylineno);
 930   /* Print the symbols being reduced, and their result.  */
 931   for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
 932     YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
 933   YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
 934 }
 935
 936 # define YY_REDUCE_PRINT(Rule)          \
 937 do {                                    \
 938   if (yydebug)                          \
 939     yy_reduce_print (Rule);             \
 940 } while (0)
 941
 942 /* Nonzero means print parse trace.  It is left uninitialized so that
 943    multiple parsers can coexist.  */
 944 int yydebug;
 945 #else /* !YYDEBUG */
 946 # define YYDPRINTF(Args)
 947 # define YYDSYMPRINT(Args)
 948 # define YYDSYMPRINTF(Title, Token, Value, Location)
 949 # define YY_STACK_PRINT(Bottom, Top)
 950 # define YY_REDUCE_PRINT(Rule)
 951 #endif /* !YYDEBUG */
 952
 953
 954 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 955 #ifndef YYINITDEPTH
 956 # define YYINITDEPTH 200
 957 #endif
 958
 959 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
 960    if the built-in stack extension method is used).
 961
 962    Do not make this value too large; the results are undefined if
 963    SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
 964    evaluated with infinite-precision integer arithmetic.  */
 965
 966 #if YYMAXDEPTH == 0
 967 # undef YYMAXDEPTH
 968 #endif
 969
 970 #ifndef YYMAXDEPTH
 971 # define YYMAXDEPTH 10000
 972 #endif
 973
 974 \f
 975
 976 #if YYERROR_VERBOSE
 977
 978 # ifndef yystrlen
 979 #  if defined (__GLIBC__) && defined (_STRING_H)
 980 #   define yystrlen strlen
 981 #  else
 982 /* Return the length of YYSTR.  */
 983 static YYSIZE_T
 984 #   if defined (__STDC__) || defined (__cplusplus)
 985 yystrlen (const char *yystr)
 986 #   else
 987 yystrlen (yystr)
 988      const char *yystr;
 989 #   endif
 990 {
 991   register const char *yys = yystr;
 992
 993   while (*yys++ != '\0')
 994     continue;
 995
 996   return yys - yystr - 1;
 997 }
 998 #  endif
 999 # endif
1000
1001 # ifndef yystpcpy
1002 #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
1003 #   define yystpcpy stpcpy
1004 #  else
1005 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1006    YYDEST.  */
1007 static char *
1008 #   if defined (__STDC__) || defined (__cplusplus)
1009 yystpcpy (char *yydest, const char *yysrc)
1010 #   else
1011 yystpcpy (yydest, yysrc)
1012      char *yydest;
1013      const char *yysrc;
1014 #   endif
1015 {
1016   register char *yyd = yydest;
1017   register const char *yys = yysrc;
1018
1019   while ((*yyd++ = *yys++) != '\0')
1020     continue;
1021
1022   return yyd - 1;
1023 }
1024 #  endif
1025 # endif
1026
1027 #endif /* !YYERROR_VERBOSE */
1028
1029 \f
1030
1031 #if YYDEBUG
1032 /*--------------------------------.
1033 | Print this symbol on YYOUTPUT.  |
1034 `--------------------------------*/
1035
1036 #if defined (__STDC__) || defined (__cplusplus)
1037 static void
1038 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
1039 #else
1040 static void
1041 yysymprint (yyoutput, yytype, yyvaluep)
1042     FILE *yyoutput;
1043     int yytype;
1044     YYSTYPE *yyvaluep;
1045 #endif
1046 {
1047   /* Pacify ``unused variable'' warnings.  */
1048   (void) yyvaluep;
1049
1050   if (yytype < YYNTOKENS)
1051     {
1052       YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1053 # ifdef YYPRINT
1054       YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1055 # endif
1056     }
1057   else
1058     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1059
1060   switch (yytype)
1061     {
1062       default:
1063         break;
1064     }
1065   YYFPRINTF (yyoutput, ")");
1066 }
1067
1068 #endif /* ! YYDEBUG */
1069 /*-----------------------------------------------.
1070 | Release the memory associated to this symbol.  |
1071 `-----------------------------------------------*/
1072
1073 #if defined (__STDC__) || defined (__cplusplus)
1074 static void
1075 yydestruct (int yytype, YYSTYPE *yyvaluep)
1076 #else
1077 static void
1078 yydestruct (yytype, yyvaluep)
1079     int yytype;
1080     YYSTYPE *yyvaluep;
1081 #endif
1082 {
1083   /* Pacify ``unused variable'' warnings.  */
1084   (void) yyvaluep;
1085
1086   switch (yytype)
1087     {
1088
1089       default:
1090         break;
1091     }
1092 }
1093 \f
1094
1095 /* Prevent warnings from -Wmissing-prototypes.  */
1096
1097 #ifdef YYPARSE_PARAM
1098 # if defined (__STDC__) || defined (__cplusplus)
1099 int yyparse (void *YYPARSE_PARAM);
1100 # else
1101 int yyparse ();
1102 # endif
1103 #else /* ! YYPARSE_PARAM */
1104 #if defined (__STDC__) || defined (__cplusplus)
1105 int yyparse (void);
1106 #else
1107 int yyparse ();
1108 #endif
1109 #endif /* ! YYPARSE_PARAM */
1110
1111
1112
1113 /* The lookahead symbol.  */
1114 int yychar;
1115
1116 /* The semantic value of the lookahead symbol.  */
1117 YYSTYPE yylval;
1118
1119 /* Number of syntax errors so far.  */
1120 int yynerrs;
1121
1122
1123
1124 /*----------.
1125 | yyparse.  |
1126 `----------*/
1127
1128 #ifdef YYPARSE_PARAM
1129 # if defined (__STDC__) || defined (__cplusplus)
1130 int yyparse (void *YYPARSE_PARAM)
1131 # else
1132 int yyparse (YYPARSE_PARAM)
1133   void *YYPARSE_PARAM;
1134 # endif
1135 #else /* ! YYPARSE_PARAM */
1136 #if defined (__STDC__) || defined (__cplusplus)
1137 int
1138 yyparse (void)
1139 #else
1140 int
1141 yyparse ()
1142
1143 #endif
1144 #endif
1145 {
1146
1147   register int yystate;
1148   register int yyn;
1149   int yyresult;
1150   /* Number of tokens to shift before error messages enabled.  */
1151   int yyerrstatus;
1152   /* Lookahead token as an internal (translated) token number.  */
1153   int yytoken = 0;
1154
1155   /* Three stacks and their tools:
1156      `yyss': related to states,
1157      `yyvs': related to semantic values,
1158      `yyls': related to locations.
1159
1160      Refer to the stacks thru separate pointers, to allow yyoverflow
1161      to xreallocate them elsewhere.  */
1162
1163   /* The state stack.  */
1164   short yyssa[YYINITDEPTH];
1165   short *yyss = yyssa;
1166   register short *yyssp;
1167
1168   /* The semantic value stack.  */
1169   YYSTYPE yyvsa[YYINITDEPTH];
1170   YYSTYPE *yyvs = yyvsa;
1171   register YYSTYPE *yyvsp;
1172
1173
1174
1175 #define YYPOPSTACK   (yyvsp--, yyssp--)
1176
1177   YYSIZE_T yystacksize = YYINITDEPTH;
1178
1179   /* The variables used to return semantic value and location from the
1180      action routines.  */
1181   YYSTYPE yyval;
1182
1183
1184   /* When reducing, the number of symbols on the RHS of the reduced
1185      rule.  */
1186   int yylen;
1187
1188   YYDPRINTF ((stderr, "Starting parse\n"));
1189
1190   yystate = 0;
1191   yyerrstatus = 0;
1192   yynerrs = 0;
1193   yychar = YYEMPTY;             /* Cause a token to be read.  */
1194
1195   /* Initialize stack pointers.
1196      Waste one element of value and location stack
1197      so that they stay on the same level as the state stack.
1198      The wasted elements are never initialized.  */
1199
1200   yyssp = yyss;
1201   yyvsp = yyvs;
1202
1203   goto yysetstate;
1204
1205 /*------------------------------------------------------------.
1206 | yynewstate -- Push a new state, which is found in yystate.  |
1207 `------------------------------------------------------------*/
1208  yynewstate:
1209   /* In all cases, when you get here, the value and location stacks
1210      have just been pushed. so pushing a state here evens the stacks.
1211      */
1212   yyssp++;
1213
1214  yysetstate:
1215   *yyssp = yystate;
1216
1217   if (yyss + yystacksize - 1 <= yyssp)
1218     {
1219       /* Get the current used size of the three stacks, in elements.  */
1220       YYSIZE_T yysize = yyssp - yyss + 1;
1221
1222 #ifdef yyoverflow
1223       {
1224         /* Give user a chance to xreallocate the stack. Use copies of
1225            these so that the &'s don't force the real ones into
1226            memory.  */
1227         YYSTYPE *yyvs1 = yyvs;
1228         short *yyss1 = yyss;
1229
1230
1231         /* Each stack pointer address is followed by the size of the
1232            data in use in that stack, in bytes.  This used to be a
1233            conditional around just the two extra args, but that might
1234            be undefined if yyoverflow is a macro.  */
1235         yyoverflow ("parser stack overflow",
1236                     &yyss1, yysize * sizeof (*yyssp),
1237                     &yyvs1, yysize * sizeof (*yyvsp),
1238
1239                     &yystacksize);
1240
1241         yyss = yyss1;
1242         yyvs = yyvs1;
1243       }
1244 #else /* no yyoverflow */
1245 # ifndef YYSTACK_RELOCATE
1246       goto yyoverflowlab;
1247 # else
1248       /* Extend the stack our own way.  */
1249       if (YYMAXDEPTH <= yystacksize)
1250         goto yyoverflowlab;
1251       yystacksize *= 2;
1252       if (YYMAXDEPTH < yystacksize)
1253         yystacksize = YYMAXDEPTH;
1254
1255       {
1256         short *yyss1 = yyss;
1257         union yyalloc *yyptr =
1258           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1259         if (! yyptr)
1260           goto yyoverflowlab;
1261         YYSTACK_RELOCATE (yyss);
1262         YYSTACK_RELOCATE (yyvs);
1263
1264 #  undef YYSTACK_RELOCATE
1265         if (yyss1 != yyssa)
1266           YYSTACK_FREE (yyss1);
1267       }
1268 # endif
1269 #endif /* no yyoverflow */
1270
1271       yyssp = yyss + yysize - 1;
1272       yyvsp = yyvs + yysize - 1;
1273
1274
1275       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1276                   (unsigned long int) yystacksize));
1277
1278       if (yyss + yystacksize - 1 <= yyssp)
1279         YYABORT;
1280     }
1281
1282   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1283
1284   goto yybackup;
1285
1286 /*-----------.
1287 | yybackup.  |
1288 `-----------*/
1289 yybackup:
1290
1291 /* Do appropriate processing given the current state.  */
1292 /* Read a lookahead token if we need one and don't already have one.  */
1293 /* yyresume: */
1294
1295   /* First try to decide what to do without reference to lookahead token.  */
1296
1297   yyn = yypact[yystate];
1298   if (yyn == YYPACT_NINF)
1299     goto yydefault;
1300
1301   /* Not known => get a lookahead token if don't already have one.  */
1302
1303   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
1304   if (yychar == YYEMPTY)
1305     {
1306       YYDPRINTF ((stderr, "Reading a token: "));
1307       yychar = YYLEX;
1308     }
1309
1310   if (yychar <= YYEOF)
1311     {
1312       yychar = yytoken = YYEOF;
1313       YYDPRINTF ((stderr, "Now at end of input.\n"));
1314     }
1315   else
1316     {
1317       yytoken = YYTRANSLATE (yychar);
1318       YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
1319     }
1320
1321   /* If the proper action on seeing token YYTOKEN is to reduce or to
1322      detect an error, take that action.  */
1323   yyn += yytoken;
1324   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1325     goto yydefault;
1326   yyn = yytable[yyn];
1327   if (yyn <= 0)
1328     {
1329       if (yyn == 0 || yyn == YYTABLE_NINF)
1330         goto yyerrlab;
1331       yyn = -yyn;
1332       goto yyreduce;
1333     }
1334
1335   if (yyn == YYFINAL)
1336     YYACCEPT;
1337
1338   /* Shift the lookahead token.  */
1339   YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
1340
1341   /* Discard the token being shifted unless it is eof.  */
1342   if (yychar != YYEOF)
1343     yychar = YYEMPTY;
1344
1345   *++yyvsp = yylval;
1346
1347
1348   /* Count tokens shifted since error; after three, turn off error
1349      status.  */
1350   if (yyerrstatus)
1351     yyerrstatus--;
1352
1353   yystate = yyn;
1354   goto yynewstate;
1355
1356
1357 /*-----------------------------------------------------------.
1358 | yydefault -- do the default action for the current state.  |
1359 `-----------------------------------------------------------*/
1360 yydefault:
1361   yyn = yydefact[yystate];
1362   if (yyn == 0)
1363     goto yyerrlab;
1364   goto yyreduce;
1365
1366
1367 /*-----------------------------.
1368 | yyreduce -- Do a reduction.  |
1369 `-----------------------------*/
1370 yyreduce:
1371   /* yyn is the number of a rule to reduce with.  */
1372   yylen = yyr2[yyn];
1373
1374   /* If YYLEN is nonzero, implement the default value of the action:
1375      `$$ = $1'.
1376
1377      Otherwise, the following line sets YYVAL to garbage.
1378      This behavior is undocumented and Bison
1379      users should not rely upon it.  Assigning to YYVAL
1380      unconditionally makes the parser a bit smaller, and it avoids a
1381      GCC warning that YYVAL may be used uninitialized.  */
1382   yyval = yyvsp[1-yylen];
1383
1384
1385   YY_REDUCE_PRINT (yyn);
1386   switch (yyn)
1387     {
1388         case 4:
1389 #line 209 "jv-exp.y"
1390     {
1391                   write_exp_elt_opcode(OP_TYPE);
1392                   write_exp_elt_type(yyvsp[0].tval);
1393                   write_exp_elt_opcode(OP_TYPE);
1394                 }
1395     break;
1396
1397   case 7:
1398 #line 223 "jv-exp.y"
1399     {
1400                   write_exp_elt_opcode (OP_STRING);
1401                   write_exp_string (yyvsp[0].sval);
1402                   write_exp_elt_opcode (OP_STRING);
1403                 }
1404     break;
1405
1406   case 8:
1407 #line 232 "jv-exp.y"
1408     { write_exp_elt_opcode (OP_LONG);
1409                   write_exp_elt_type (yyvsp[0].typed_val_int.type);
1410                   write_exp_elt_longcst ((LONGEST)(yyvsp[0].typed_val_int.val));
1411                   write_exp_elt_opcode (OP_LONG); }
1412     break;
1413
1414   case 9:
1415 #line 237 "jv-exp.y"
1416     { YYSTYPE val;
1417                   parse_number (yyvsp[0].sval.ptr, yyvsp[0].sval.length, 0, &val);
1418                   write_exp_elt_opcode (OP_LONG);
1419                   write_exp_elt_type (val.typed_val_int.type);
1420                   write_exp_elt_longcst ((LONGEST)val.typed_val_int.val);
1421                   write_exp_elt_opcode (OP_LONG);
1422                 }
1423     break;
1424
1425   case 10:
1426 #line 245 "jv-exp.y"
1427     { write_exp_elt_opcode (OP_DOUBLE);
1428                   write_exp_elt_type (yyvsp[0].typed_val_float.type);
1429                   write_exp_elt_dblcst (yyvsp[0].typed_val_float.dval);
1430                   write_exp_elt_opcode (OP_DOUBLE); }
1431     break;
1432
1433   case 11:
1434 #line 250 "jv-exp.y"
1435     { write_exp_elt_opcode (OP_LONG);
1436                   write_exp_elt_type (java_boolean_type);
1437                   write_exp_elt_longcst ((LONGEST)yyvsp[0].lval);
1438                   write_exp_elt_opcode (OP_LONG); }
1439     break;
1440
1441   case 14:
1442 #line 267 "jv-exp.y"
1443     { yyval.tval = java_boolean_type; }
1444     break;
1445
1446   case 17:
1447 #line 277 "jv-exp.y"
1448     { yyval.tval = java_byte_type; }
1449     break;
1450
1451   case 18:
1452 #line 279 "jv-exp.y"
1453     { yyval.tval = java_short_type; }
1454     break;
1455
1456   case 19:
1457 #line 281 "jv-exp.y"
1458     { yyval.tval = java_int_type; }
1459     break;
1460
1461   case 20:
1462 #line 283 "jv-exp.y"
1463     { yyval.tval = java_long_type; }
1464     break;
1465
1466   case 21:
1467 #line 285 "jv-exp.y"
1468     { yyval.tval = java_char_type; }
1469     break;
1470
1471   case 22:
1472 #line 290 "jv-exp.y"
1473     { yyval.tval = java_float_type; }
1474     break;
1475
1476   case 23:
1477 #line 292 "jv-exp.y"
1478     { yyval.tval = java_double_type; }
1479     break;
1480
1481   case 24:
1482 #line 304 "jv-exp.y"
1483     { yyval.tval = java_type_from_name (yyvsp[0].sval); }
1484     break;
1485
1486   case 26:
1487 #line 313 "jv-exp.y"
1488     { yyval.tval = java_array_type (yyvsp[-1].tval, yyvsp[0].lval); }
1489     break;
1490
1491   case 27:
1492 #line 315 "jv-exp.y"
1493     { yyval.tval = java_array_type (java_type_from_name (yyvsp[-1].sval), yyvsp[0].lval); }
1494     break;
1495
1496   case 34:
1497 #line 335 "jv-exp.y"
1498     { yyval.sval.length = yyvsp[-2].sval.length + yyvsp[0].sval.length + 1;
1499                   if (yyvsp[-2].sval.ptr + yyvsp[-2].sval.length + 1 == yyvsp[0].sval.ptr
1500                       && yyvsp[-2].sval.ptr[yyvsp[-2].sval.length] == '.')
1501                     yyval.sval.ptr = yyvsp[-2].sval.ptr;  /* Optimization. */
1502                   else
1503                     {
1504                       yyval.sval.ptr = (char *) xmalloc (yyval.sval.length + 1);
1505                       make_cleanup (free, yyval.sval.ptr);
1506                       sprintf (yyval.sval.ptr, "%.*s.%.*s",
1507                                yyvsp[-2].sval.length, yyvsp[-2].sval.ptr, yyvsp[0].sval.length, yyvsp[0].sval.ptr);
1508                 } }
1509     break;
1510
1511   case 36:
1512 #line 359 "jv-exp.y"
1513     { write_exp_elt_opcode (BINOP_COMMA); }
1514     break;
1515
1516   case 45:
1517 #line 375 "jv-exp.y"
1518     { write_exp_elt_opcode (OP_ARRAY);
1519                   write_exp_elt_longcst ((LONGEST) 0);
1520                   write_exp_elt_longcst ((LONGEST) yyvsp[0].lval);
1521                   write_exp_elt_opcode (OP_ARRAY); }
1522     break;
1523
1524   case 46:
1525 #line 383 "jv-exp.y"
1526     { start_arglist (); }
1527     break;
1528
1529   case 47:
1530 #line 388 "jv-exp.y"
1531     { yyval.lval = end_arglist () - 1; }
1532     break;
1533
1534   case 48:
1535 #line 393 "jv-exp.y"
1536     { internal_error (__FILE__, __LINE__,
1537                                   _("FIXME - ClassInstanceCreationExpression")); }
1538     break;
1539
1540   case 49:
1541 #line 399 "jv-exp.y"
1542     { arglist_len = 1; }
1543     break;
1544
1545   case 50:
1546 #line 401 "jv-exp.y"
1547     { arglist_len++; }
1548     break;
1549
1550   case 51:
1551 #line 406 "jv-exp.y"
1552     { arglist_len = 0; }
1553     break;
1554
1555   case 53:
1556 #line 412 "jv-exp.y"
1557     { internal_error (__FILE__, __LINE__,
1558                                   _("FIXME - ArrayCreationExpression")); }
1559     break;
1560
1561   case 54:
1562 #line 415 "jv-exp.y"
1563     { internal_error (__FILE__, __LINE__,
1564                                   _("FIXME - ArrayCreationExpression")); }
1565     break;
1566
1567   case 58:
1568 #line 430 "jv-exp.y"
1569     { yyval.lval = 1; }
1570     break;
1571
1572   case 59:
1573 #line 432 "jv-exp.y"
1574     { yyval.lval = yyvsp[-2].lval + 1; }
1575     break;
1576
1577   case 61:
1578 #line 438 "jv-exp.y"
1579     { yyval.lval = 0; }
1580     break;
1581
1582   case 62:
1583 #line 443 "jv-exp.y"
1584     { push_fieldnames (yyvsp[0].sval); }
1585     break;
1586
1587   case 63:
1588 #line 445 "jv-exp.y"
1589     { push_fieldnames (yyvsp[0].sval); }
1590     break;
1591
1592   case 64:
1593 #line 451 "jv-exp.y"
1594     { error (_("Method invocation not implemented")); }
1595     break;
1596
1597   case 65:
1598 #line 453 "jv-exp.y"
1599     { error (_("Method invocation not implemented")); }
1600     break;
1601
1602   case 66:
1603 #line 455 "jv-exp.y"
1604     { error (_("Method invocation not implemented")); }
1605     break;
1606
1607   case 67:
1608 #line 460 "jv-exp.y"
1609     {
1610                   /* Emit code for the Name now, then exchange it in the
1611                      expout array with the Expression's code.  We could
1612                      introduce a OP_SWAP code or a reversed version of
1613                      BINOP_SUBSCRIPT, but that makes the rest of GDB pay
1614                      for our parsing kludges.  */
1615                   struct expression *name_expr;
1616
1617                   push_expression_name (yyvsp[-3].sval);
1618                   name_expr = copy_exp (expout, expout_ptr);
1619                   expout_ptr -= name_expr->nelts;
1620                   insert_exp (expout_ptr-length_of_subexp (expout, expout_ptr),
1621                               name_expr);
1622                   free (name_expr);
1623                   write_exp_elt_opcode (BINOP_SUBSCRIPT);
1624                 }
1625     break;
1626
1627   case 68:
1628 #line 477 "jv-exp.y"
1629     { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
1630     break;
1631
1632   case 69:
1633 #line 479 "jv-exp.y"
1634     { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
1635     break;
1636
1637   case 71:
1638 #line 485 "jv-exp.y"
1639     { push_expression_name (yyvsp[0].sval); }
1640     break;
1641
1642   case 75:
1643 #line 494 "jv-exp.y"
1644     { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
1645     break;
1646
1647   case 76:
1648 #line 499 "jv-exp.y"
1649     { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
1650     break;
1651
1652   case 80:
1653 #line 507 "jv-exp.y"
1654     { write_exp_elt_opcode (UNOP_NEG); }
1655     break;
1656
1657   case 81:
1658 #line 509 "jv-exp.y"
1659     { write_exp_elt_opcode (UNOP_IND); }
1660     break;
1661
1662   case 83:
1663 #line 515 "jv-exp.y"
1664     { write_exp_elt_opcode (UNOP_PREINCREMENT); }
1665     break;
1666
1667   case 84:
1668 #line 520 "jv-exp.y"
1669     { write_exp_elt_opcode (UNOP_PREDECREMENT); }
1670     break;
1671
1672   case 86:
1673 #line 526 "jv-exp.y"
1674     { write_exp_elt_opcode (UNOP_COMPLEMENT); }
1675     break;
1676
1677   case 87:
1678 #line 528 "jv-exp.y"
1679     { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
1680     break;
1681
1682   case 89:
1683 #line 534 "jv-exp.y"
1684     { write_exp_elt_opcode (UNOP_CAST);
1685                   write_exp_elt_type (java_array_type (yyvsp[-3].tval, yyvsp[-2].lval));
1686                   write_exp_elt_opcode (UNOP_CAST); }
1687     break;
1688
1689   case 90:
1690 #line 538 "jv-exp.y"
1691     {
1692                   int exp_size = expout_ptr;
1693                   int last_exp_size = length_of_subexp(expout, expout_ptr);
1694                   struct type *type;
1695                   int i;
1696                   int base = expout_ptr - last_exp_size - 3;
1697                   if (base < 0 || expout->elts[base+2].opcode != OP_TYPE)
1698                     error (_("Invalid cast expression"));
1699                   type = expout->elts[base+1].type;
1700                   /* Remove the 'Expression' and slide the
1701                      UnaryExpressionNotPlusMinus down to replace it. */
1702                   for (i = 0;  i < last_exp_size;  i++)
1703                     expout->elts[base + i] = expout->elts[base + i + 3];
1704                   expout_ptr -= 3;
1705                   if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
1706                     type = lookup_pointer_type (type);
1707                   write_exp_elt_opcode (UNOP_CAST);
1708                   write_exp_elt_type (type);
1709                   write_exp_elt_opcode (UNOP_CAST);
1710                 }
1711     break;
1712
1713   case 91:
1714 #line 559 "jv-exp.y"
1715     { write_exp_elt_opcode (UNOP_CAST);
1716                   write_exp_elt_type (java_array_type (java_type_from_name (yyvsp[-3].sval), yyvsp[-2].lval));
1717                   write_exp_elt_opcode (UNOP_CAST); }
1718     break;
1719
1720   case 93:
1721 #line 568 "jv-exp.y"
1722     { write_exp_elt_opcode (BINOP_MUL); }
1723     break;
1724
1725   case 94:
1726 #line 570 "jv-exp.y"
1727     { write_exp_elt_opcode (BINOP_DIV); }
1728     break;
1729
1730   case 95:
1731 #line 572 "jv-exp.y"
1732     { write_exp_elt_opcode (BINOP_REM); }
1733     break;
1734
1735   case 97:
1736 #line 578 "jv-exp.y"
1737     { write_exp_elt_opcode (BINOP_ADD); }
1738     break;
1739
1740   case 98:
1741 #line 580 "jv-exp.y"
1742     { write_exp_elt_opcode (BINOP_SUB); }
1743     break;
1744
1745   case 100:
1746 #line 586 "jv-exp.y"
1747     { write_exp_elt_opcode (BINOP_LSH); }
1748     break;
1749
1750   case 101:
1751 #line 588 "jv-exp.y"
1752     { write_exp_elt_opcode (BINOP_RSH); }
1753     break;
1754
1755   case 103:
1756 #line 595 "jv-exp.y"
1757     { write_exp_elt_opcode (BINOP_LESS); }
1758     break;
1759
1760   case 104:
1761 #line 597 "jv-exp.y"
1762     { write_exp_elt_opcode (BINOP_GTR); }
1763     break;
1764
1765   case 105:
1766 #line 599 "jv-exp.y"
1767     { write_exp_elt_opcode (BINOP_LEQ); }
1768     break;
1769
1770   case 106:
1771 #line 601 "jv-exp.y"
1772     { write_exp_elt_opcode (BINOP_GEQ); }
1773     break;
1774
1775   case 108:
1776 #line 608 "jv-exp.y"
1777     { write_exp_elt_opcode (BINOP_EQUAL); }
1778     break;
1779
1780   case 109:
1781 #line 610 "jv-exp.y"
1782     { write_exp_elt_opcode (BINOP_NOTEQUAL); }
1783     break;
1784
1785   case 111:
1786 #line 616 "jv-exp.y"
1787     { write_exp_elt_opcode (BINOP_BITWISE_AND); }
1788     break;
1789
1790   case 113:
1791 #line 622 "jv-exp.y"
1792     { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
1793     break;
1794
1795   case 115:
1796 #line 627 "jv-exp.y"
1797     { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
1798     break;
1799
1800   case 117:
1801 #line 633 "jv-exp.y"
1802     { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
1803     break;
1804
1805   case 119:
1806 #line 639 "jv-exp.y"
1807     { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
1808     break;
1809
1810   case 121:
1811 #line 645 "jv-exp.y"
1812     { write_exp_elt_opcode (TERNOP_COND); }
1813     break;
1814
1815   case 124:
1816 #line 655 "jv-exp.y"
1817     { write_exp_elt_opcode (BINOP_ASSIGN); }
1818     break;
1819
1820   case 125:
1821 #line 657 "jv-exp.y"
1822     { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
1823                   write_exp_elt_opcode (yyvsp[-1].opcode);
1824                   write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
1825     break;
1826
1827   case 126:
1828 #line 664 "jv-exp.y"
1829     { push_expression_name (yyvsp[0].sval); }
1830     break;
1831
1832
1833     }
1834
1835 /* Line 991 of yacc.c.  */
1836 \f
1837   yyvsp -= yylen;
1838   yyssp -= yylen;
1839
1840
1841   YY_STACK_PRINT (yyss, yyssp);
1842
1843   *++yyvsp = yyval;
1844
1845
1846   /* Now `shift' the result of the reduction.  Determine what state
1847      that goes to, based on the state we popped back to and the rule
1848      number reduced by.  */
1849
1850   yyn = yyr1[yyn];
1851
1852   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1853   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1854     yystate = yytable[yystate];
1855   else
1856     yystate = yydefgoto[yyn - YYNTOKENS];
1857
1858   goto yynewstate;
1859
1860
1861 /*------------------------------------.
1862 | yyerrlab -- here on detecting error |
1863 `------------------------------------*/
1864 yyerrlab:
1865   /* If not already recovering from an error, report this error.  */
1866   if (!yyerrstatus)
1867     {
1868       ++yynerrs;
1869 #if YYERROR_VERBOSE
1870       yyn = yypact[yystate];
1871
1872       if (YYPACT_NINF < yyn && yyn < YYLAST)
1873         {
1874           YYSIZE_T yysize = 0;
1875           int yytype = YYTRANSLATE (yychar);
1876           char *yymsg;
1877           int yyx, yycount;
1878
1879           yycount = 0;
1880           /* Start YYX at -YYN if negative to avoid negative indexes in
1881              YYCHECK.  */
1882           for (yyx = yyn < 0 ? -yyn : 0;
1883                yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
1884             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1885               yysize += yystrlen (yytname[yyx]) + 15, yycount++;
1886           yysize += yystrlen ("syntax error, unexpected ") + 1;
1887           yysize += yystrlen (yytname[yytype]);
1888           yymsg = (char *) YYSTACK_ALLOC (yysize);
1889           if (yymsg != 0)
1890             {
1891               char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
1892               yyp = yystpcpy (yyp, yytname[yytype]);
1893
1894               if (yycount < 5)
1895                 {
1896                   yycount = 0;
1897                   for (yyx = yyn < 0 ? -yyn : 0;
1898                        yyx < (int) (sizeof (yytname) / sizeof (char *));
1899                        yyx++)
1900                     if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1901                       {
1902                         const char *yyq = ! yycount ? ", expecting " : " or ";
1903                         yyp = yystpcpy (yyp, yyq);
1904                         yyp = yystpcpy (yyp, yytname[yyx]);
1905                         yycount++;
1906                       }
1907                 }
1908               yyerror (yymsg);
1909               YYSTACK_FREE (yymsg);
1910             }
1911           else
1912             yyerror ("syntax error; also virtual memory exhausted");
1913         }
1914       else
1915 #endif /* YYERROR_VERBOSE */
1916         yyerror ("syntax error");
1917     }
1918
1919
1920
1921   if (yyerrstatus == 3)
1922     {
1923       /* If just tried and failed to reuse lookahead token after an
1924          error, discard it.  */
1925
1926       /* Return failure if at end of input.  */
1927       if (yychar == YYEOF)
1928         {
1929           /* Pop the error token.  */
1930           YYPOPSTACK;
1931           /* Pop the rest of the stack.  */
1932           while (yyss < yyssp)
1933             {
1934               YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
1935               yydestruct (yystos[*yyssp], yyvsp);
1936               YYPOPSTACK;
1937             }
1938           YYABORT;
1939         }
1940
1941       YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
1942       yydestruct (yytoken, &yylval);
1943       yychar = YYEMPTY;
1944
1945     }
1946
1947   /* Else will try to reuse lookahead token after shifting the error
1948      token.  */
1949   goto yyerrlab2;
1950
1951
1952 /*----------------------------------------------------.
1953 | yyerrlab1 -- error raised explicitly by an action.  |
1954 `----------------------------------------------------*/
1955 yyerrlab1:
1956
1957   /* Suppress GCC warning that yyerrlab1 is unused when no action
1958      invokes YYERROR.  Doesn't work in C++ */
1959 #ifndef __cplusplus
1960 #if defined (__GNUC_MINOR__) && 2093 <= (__GNUC__ * 1000 + __GNUC_MINOR__)
1961   __attribute__ ((__unused__))
1962 #endif
1963 #endif
1964
1965
1966   goto yyerrlab2;
1967
1968
1969 /*---------------------------------------------------------------.
1970 | yyerrlab2 -- pop states until the error token can be shifted.  |
1971 `---------------------------------------------------------------*/
1972 yyerrlab2:
1973   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
1974
1975   for (;;)
1976     {
1977       yyn = yypact[yystate];
1978       if (yyn != YYPACT_NINF)
1979         {
1980           yyn += YYTERROR;
1981           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1982             {
1983               yyn = yytable[yyn];
1984               if (0 < yyn)
1985                 break;
1986             }
1987         }
1988
1989       /* Pop the current state because it cannot handle the error token.  */
1990       if (yyssp == yyss)
1991         YYABORT;
1992
1993       YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
1994       yydestruct (yystos[yystate], yyvsp);
1995       yyvsp--;
1996       yystate = *--yyssp;
1997
1998       YY_STACK_PRINT (yyss, yyssp);
1999     }
2000
2001   if (yyn == YYFINAL)
2002     YYACCEPT;
2003
2004   YYDPRINTF ((stderr, "Shifting error token, "));
2005
2006   *++yyvsp = yylval;
2007
2008
2009   yystate = yyn;
2010   goto yynewstate;
2011
2012
2013 /*-------------------------------------.
2014 | yyacceptlab -- YYACCEPT comes here.  |
2015 `-------------------------------------*/
2016 yyacceptlab:
2017   yyresult = 0;
2018   goto yyreturn;
2019
2020 /*-----------------------------------.
2021 | yyabortlab -- YYABORT comes here.  |
2022 `-----------------------------------*/
2023 yyabortlab:
2024   yyresult = 1;
2025   goto yyreturn;
2026
2027 #ifndef yyoverflow
2028 /*----------------------------------------------.
2029 | yyoverflowlab -- parser overflow comes here.  |
2030 `----------------------------------------------*/
2031 yyoverflowlab:
2032   yyerror ("parser stack overflow");
2033   yyresult = 2;
2034   /* Fall through.  */
2035 #endif
2036
2037 yyreturn:
2038 #ifndef yyoverflow
2039   if (yyss != yyssa)
2040     YYSTACK_FREE (yyss);
2041 #endif
2042   return yyresult;
2043 }
2044
2045
2046 #line 676 "jv-exp.y"
2047
2048 /* Take care of parsing a number (anything that starts with a digit).
2049    Set yylval and return the token type; update lexptr.
2050    LEN is the number of characters in it.  */
2051
2052 /*** Needs some error checking for the float case ***/
2053
2054 static int
2055 parse_number (p, len, parsed_float, putithere)
2056      char *p;
2057      int len;
2058      int parsed_float;
2059      YYSTYPE *putithere;
2060 {
2061   ULONGEST n = 0;
2062   ULONGEST limit, limit_div_base;
2063
2064   int c;
2065   int base = input_radix;
2066
2067   struct type *type;
2068
2069   if (parsed_float)
2070     {
2071       /* It's a float since it contains a point or an exponent.  */
2072       char c;
2073       int num = 0;      /* number of tokens scanned by scanf */
2074       char saved_char = p[len];
2075
2076       p[len] = 0;       /* null-terminate the token */
2077       if (sizeof (putithere->typed_val_float.dval) <= sizeof (float))
2078         num = sscanf (p, "%g%c", (float *) &putithere->typed_val_float.dval, &c);
2079       else if (sizeof (putithere->typed_val_float.dval) <= sizeof (double))
2080         num = sscanf (p, "%lg%c", (double *) &putithere->typed_val_float.dval, &c);
2081       else
2082         {
2083 #ifdef SCANF_HAS_LONG_DOUBLE
2084           num = sscanf (p, "%Lg%c", &putithere->typed_val_float.dval, &c);
2085 #else
2086           /* Scan it into a double, then assign it to the long double.
2087              This at least wins with values representable in the range
2088              of doubles. */
2089           double temp;
2090           num = sscanf (p, "%lg%c", &temp, &c);
2091           putithere->typed_val_float.dval = temp;
2092 #endif
2093         }
2094       p[len] = saved_char;      /* restore the input stream */
2095       if (num != 1)             /* check scanf found ONLY a float ... */
2096         return ERROR;
2097       /* See if it has `f' or `d' suffix (float or double).  */
2098
2099       c = tolower (p[len - 1]);
2100
2101       if (c == 'f' || c == 'F')
2102         putithere->typed_val_float.type = builtin_type_float;
2103       else if (isdigit (c) || c == '.' || c == 'd' || c == 'D')
2104         putithere->typed_val_float.type = builtin_type_double;
2105       else
2106         return ERROR;
2107
2108       return FLOATING_POINT_LITERAL;
2109     }
2110
2111   /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
2112   if (p[0] == '0')
2113     switch (p[1])
2114       {
2115       case 'x':
2116       case 'X':
2117         if (len >= 3)
2118           {
2119             p += 2;
2120             base = 16;
2121             len -= 2;
2122           }
2123         break;
2124
2125       case 't':
2126       case 'T':
2127       case 'd':
2128       case 'D':
2129         if (len >= 3)
2130           {
2131             p += 2;
2132             base = 10;
2133             len -= 2;
2134           }
2135         break;
2136
2137       default:
2138         base = 8;
2139         break;
2140       }
2141
2142   c = p[len-1];
2143   /* A paranoid calculation of (1<<64)-1. */
2144   limit = (ULONGEST)0xffffffff;
2145   limit = ((limit << 16) << 16) | limit;
2146   if (c == 'l' || c == 'L')
2147     {
2148       type = java_long_type;
2149       len--;
2150     }
2151   else
2152     {
2153       type = java_int_type;
2154     }
2155   limit_div_base = limit / (ULONGEST) base;
2156
2157   while (--len >= 0)
2158     {
2159       c = *p++;
2160       if (c >= '0' && c <= '9')
2161         c -= '0';
2162       else if (c >= 'A' && c <= 'Z')
2163         c -= 'A' - 10;
2164       else if (c >= 'a' && c <= 'z')
2165         c -= 'a' - 10;
2166       else
2167         return ERROR;   /* Char not a digit */
2168       if (c >= base)
2169         return ERROR;
2170       if (n > limit_div_base
2171           || (n *= base) > limit - c)
2172         error (_("Numeric constant too large"));
2173       n += c;
2174         }
2175
2176   /* If the type is bigger than a 32-bit signed integer can be, implicitly
2177      promote to long.  Java does not do this, so mark it as builtin_type_uint64
2178      rather than java_long_type.  0x80000000 will become -0x80000000 instead
2179      of 0x80000000L, because we don't know the sign at this point.
2180   */
2181   if (type == java_int_type && n > (ULONGEST)0x80000000)
2182     type = builtin_type_uint64;
2183
2184   putithere->typed_val_int.val = n;
2185   putithere->typed_val_int.type = type;
2186
2187   return INTEGER_LITERAL;
2188 }
2189
2190 struct token
2191 {
2192   char *operator;
2193   int token;
2194   enum exp_opcode opcode;
2195 };
2196
2197 static const struct token tokentab3[] =
2198   {
2199     {">>=", ASSIGN_MODIFY, BINOP_RSH},
2200     {"<<=", ASSIGN_MODIFY, BINOP_LSH}
2201   };
2202
2203 static const struct token tokentab2[] =
2204   {
2205     {"+=", ASSIGN_MODIFY, BINOP_ADD},
2206     {"-=", ASSIGN_MODIFY, BINOP_SUB},
2207     {"*=", ASSIGN_MODIFY, BINOP_MUL},
2208     {"/=", ASSIGN_MODIFY, BINOP_DIV},
2209     {"%=", ASSIGN_MODIFY, BINOP_REM},
2210     {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
2211     {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
2212     {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
2213     {"++", INCREMENT, BINOP_END},
2214     {"--", DECREMENT, BINOP_END},
2215     {"&&", ANDAND, BINOP_END},
2216     {"||", OROR, BINOP_END},
2217     {"<<", LSH, BINOP_END},
2218     {">>", RSH, BINOP_END},
2219     {"==", EQUAL, BINOP_END},
2220     {"!=", NOTEQUAL, BINOP_END},
2221     {"<=", LEQ, BINOP_END},
2222     {">=", GEQ, BINOP_END}
2223   };
2224
2225 /* Read one token, getting characters through lexptr.  */
2226
2227 static int
2228 yylex ()
2229 {
2230   int c;
2231   int namelen;
2232   unsigned int i;
2233   char *tokstart;
2234   char *tokptr;
2235   int tempbufindex;
2236   static char *tempbuf;
2237   static int tempbufsize;
2238
2239  retry:
2240
2241   prev_lexptr = lexptr;
2242
2243   tokstart = lexptr;
2244   /* See if it is a special token of length 3.  */
2245   for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
2246     if (strncmp (tokstart, tokentab3[i].operator, 3) == 0)
2247       {
2248         lexptr += 3;
2249         yylval.opcode = tokentab3[i].opcode;
2250         return tokentab3[i].token;
2251       }
2252
2253   /* See if it is a special token of length 2.  */
2254   for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
2255     if (strncmp (tokstart, tokentab2[i].operator, 2) == 0)
2256       {
2257         lexptr += 2;
2258         yylval.opcode = tokentab2[i].opcode;
2259         return tokentab2[i].token;
2260       }
2261
2262   switch (c = *tokstart)
2263     {
2264     case 0:
2265       return 0;
2266
2267     case ' ':
2268     case '\t':
2269     case '\n':
2270       lexptr++;
2271       goto retry;
2272
2273     case '\'':
2274       /* We either have a character constant ('0' or '\177' for example)
2275          or we have a quoted symbol reference ('foo(int,int)' in C++
2276          for example). */
2277       lexptr++;
2278       c = *lexptr++;
2279       if (c == '\\')
2280         c = parse_escape (&lexptr);
2281       else if (c == '\'')
2282         error (_("Empty character constant"));
2283
2284       yylval.typed_val_int.val = c;
2285       yylval.typed_val_int.type = java_char_type;
2286
2287       c = *lexptr++;
2288       if (c != '\'')
2289         {
2290           namelen = skip_quoted (tokstart) - tokstart;
2291           if (namelen > 2)
2292             {
2293               lexptr = tokstart + namelen;
2294               if (lexptr[-1] != '\'')
2295                 error (_("Unmatched single quote"));
2296               namelen -= 2;
2297               tokstart++;
2298               goto tryname;
2299             }
2300           error (_("Invalid character constant"));
2301         }
2302       return INTEGER_LITERAL;
2303
2304     case '(':
2305       paren_depth++;
2306       lexptr++;
2307       return c;
2308
2309     case ')':
2310       if (paren_depth == 0)
2311         return 0;
2312       paren_depth--;
2313       lexptr++;
2314       return c;
2315
2316     case ',':
2317       if (comma_terminates && paren_depth == 0)
2318         return 0;
2319       lexptr++;
2320       return c;
2321
2322     case '.':
2323       /* Might be a floating point number.  */
2324       if (lexptr[1] < '0' || lexptr[1] > '9')
2325         goto symbol;            /* Nope, must be a symbol. */
2326       /* FALL THRU into number case.  */
2327
2328     case '0':
2329     case '1':
2330     case '2':
2331     case '3':
2332     case '4':
2333     case '5':
2334     case '6':
2335     case '7':
2336     case '8':
2337     case '9':
2338       {
2339         /* It's a number.  */
2340         int got_dot = 0, got_e = 0, toktype;
2341         char *p = tokstart;
2342         int hex = input_radix > 10;
2343
2344         if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
2345           {
2346             p += 2;
2347             hex = 1;
2348           }
2349         else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
2350           {
2351             p += 2;
2352             hex = 0;
2353           }
2354
2355         for (;; ++p)
2356           {
2357             /* This test includes !hex because 'e' is a valid hex digit
2358                and thus does not indicate a floating point number when
2359                the radix is hex.  */
2360             if (!hex && !got_e && (*p == 'e' || *p == 'E'))
2361               got_dot = got_e = 1;
2362             /* This test does not include !hex, because a '.' always indicates
2363                a decimal floating point number regardless of the radix.  */
2364             else if (!got_dot && *p == '.')
2365               got_dot = 1;
2366             else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
2367                      && (*p == '-' || *p == '+'))
2368               /* This is the sign of the exponent, not the end of the
2369                  number.  */
2370               continue;
2371             /* We will take any letters or digits.  parse_number will
2372                complain if past the radix, or if L or U are not final.  */
2373             else if ((*p < '0' || *p > '9')
2374                      && ((*p < 'a' || *p > 'z')
2375                                   && (*p < 'A' || *p > 'Z')))
2376               break;
2377           }
2378         toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
2379         if (toktype == ERROR)
2380           {
2381             char *err_copy = (char *) alloca (p - tokstart + 1);
2382
2383             memcpy (err_copy, tokstart, p - tokstart);
2384             err_copy[p - tokstart] = 0;
2385             error (_("Invalid number \"%s\""), err_copy);
2386           }
2387         lexptr = p;
2388         return toktype;
2389       }
2390
2391     case '+':
2392     case '-':
2393     case '*':
2394     case '/':
2395     case '%':
2396     case '|':
2397     case '&':
2398     case '^':
2399     case '~':
2400     case '!':
2401     case '<':
2402     case '>':
2403     case '[':
2404     case ']':
2405     case '?':
2406     case ':':
2407     case '=':
2408     case '{':
2409     case '}':
2410     symbol:
2411       lexptr++;
2412       return c;
2413
2414     case '"':
2415
2416       /* Build the gdb internal form of the input string in tempbuf,
2417          translating any standard C escape forms seen.  Note that the
2418          buffer is null byte terminated *only* for the convenience of
2419          debugging gdb itself and printing the buffer contents when
2420          the buffer contains no embedded nulls.  Gdb does not depend
2421          upon the buffer being null byte terminated, it uses the length
2422          string instead.  This allows gdb to handle C strings (as well
2423          as strings in other languages) with embedded null bytes */
2424
2425       tokptr = ++tokstart;
2426       tempbufindex = 0;
2427
2428       do {
2429         /* Grow the static temp buffer if necessary, including allocating
2430            the first one on demand. */
2431         if (tempbufindex + 1 >= tempbufsize)
2432           {
2433             tempbuf = (char *) xrealloc (tempbuf, tempbufsize += 64);
2434           }
2435         switch (*tokptr)
2436           {
2437           case '\0':
2438           case '"':
2439             /* Do nothing, loop will terminate. */
2440             break;
2441           case '\\':
2442             tokptr++;
2443             c = parse_escape (&tokptr);
2444             if (c == -1)
2445               {
2446                 continue;
2447               }
2448             tempbuf[tempbufindex++] = c;
2449             break;
2450           default:
2451             tempbuf[tempbufindex++] = *tokptr++;
2452             break;
2453           }
2454       } while ((*tokptr != '"') && (*tokptr != '\0'));
2455       if (*tokptr++ != '"')
2456         {
2457           error (_("Unterminated string in expression"));
2458         }
2459       tempbuf[tempbufindex] = '\0';     /* See note above */
2460       yylval.sval.ptr = tempbuf;
2461       yylval.sval.length = tempbufindex;
2462       lexptr = tokptr;
2463       return (STRING_LITERAL);
2464     }
2465
2466   if (!(c == '_' || c == '$'
2467         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
2468     /* We must have come across a bad character (e.g. ';').  */
2469     error (_("Invalid character '%c' in expression"), c);
2470
2471   /* It's a name.  See how long it is.  */
2472   namelen = 0;
2473   for (c = tokstart[namelen];
2474        (c == '_'
2475         || c == '$'
2476         || (c >= '0' && c <= '9')
2477         || (c >= 'a' && c <= 'z')
2478         || (c >= 'A' && c <= 'Z')
2479         || c == '<');
2480        )
2481     {
2482       if (c == '<')
2483         {
2484           int i = namelen;
2485           while (tokstart[++i] && tokstart[i] != '>');
2486           if (tokstart[i] == '>')
2487             namelen = i;
2488         }
2489        c = tokstart[++namelen];
2490      }
2491
2492   /* The token "if" terminates the expression and is NOT
2493      removed from the input stream.  */
2494   if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
2495     {
2496       return 0;
2497     }
2498
2499   lexptr += namelen;
2500
2501   tryname:
2502
2503   /* Catch specific keywords.  Should be done with a data structure.  */
2504   switch (namelen)
2505     {
2506     case 7:
2507       if (DEPRECATED_STREQN (tokstart, "boolean", 7))
2508         return BOOLEAN;
2509       break;
2510     case 6:
2511       if (DEPRECATED_STREQN (tokstart, "double", 6))
2512         return DOUBLE;
2513       break;
2514     case 5:
2515       if (DEPRECATED_STREQN (tokstart, "short", 5))
2516         return SHORT;
2517       if (DEPRECATED_STREQN (tokstart, "false", 5))
2518         {
2519           yylval.lval = 0;
2520           return BOOLEAN_LITERAL;
2521         }
2522       if (DEPRECATED_STREQN (tokstart, "super", 5))
2523         return SUPER;
2524       if (DEPRECATED_STREQN (tokstart, "float", 5))
2525         return FLOAT;
2526       break;
2527     case 4:
2528       if (DEPRECATED_STREQN (tokstart, "long", 4))
2529         return LONG;
2530       if (DEPRECATED_STREQN (tokstart, "byte", 4))
2531         return BYTE;
2532       if (DEPRECATED_STREQN (tokstart, "char", 4))
2533         return CHAR;
2534       if (DEPRECATED_STREQN (tokstart, "true", 4))
2535         {
2536           yylval.lval = 1;
2537           return BOOLEAN_LITERAL;
2538         }
2539       break;
2540     case 3:
2541       if (strncmp (tokstart, "int", 3) == 0)
2542         return INT;
2543       if (strncmp (tokstart, "new", 3) == 0)
2544         return NEW;
2545       break;
2546     default:
2547       break;
2548     }
2549
2550   yylval.sval.ptr = tokstart;
2551   yylval.sval.length = namelen;
2552
2553   if (*tokstart == '$')
2554     {
2555       write_dollar_variable (yylval.sval);
2556       return VARIABLE;
2557     }
2558
2559   /* Input names that aren't symbols but ARE valid hex numbers,
2560      when the input radix permits them, can be names or numbers
2561      depending on the parse.  Note we support radixes > 16 here.  */
2562   if (((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
2563        (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
2564     {
2565       YYSTYPE newlval;  /* Its value is ignored.  */
2566       int hextype = parse_number (tokstart, namelen, 0, &newlval);
2567       if (hextype == INTEGER_LITERAL)
2568         return NAME_OR_INT;
2569     }
2570   return IDENTIFIER;
2571 }
2572
2573 void
2574 yyerror (msg)
2575      char *msg;
2576 {
2577   if (prev_lexptr)
2578     lexptr = prev_lexptr;
2579
2580   if (msg)
2581     error (_("%s: near `%s'"), msg, lexptr);
2582   else
2583     error (_("error in expression, near `%s'"), lexptr);
2584 }
2585
2586 static struct type *
2587 java_type_from_name (name)
2588      struct stoken name;
2589
2590 {
2591   char *tmp = copy_name (name);
2592   struct type *typ = java_lookup_class (tmp);
2593   if (typ == NULL || TYPE_CODE (typ) != TYPE_CODE_STRUCT)
2594     error (_("No class named `%s'"), tmp);
2595   return typ;
2596 }
2597
2598 /* If NAME is a valid variable name in this scope, push it and return 1.
2599    Otherwise, return 0. */
2600
2601 static int
2602 push_variable (struct stoken name)
2603 {
2604   char *tmp = copy_name (name);
2605   int is_a_field_of_this = 0;
2606   struct symbol *sym;
2607   sym = lookup_symbol (tmp, expression_context_block, VAR_DOMAIN,
2608                        &is_a_field_of_this, (struct symtab **) NULL);
2609   if (sym && SYMBOL_CLASS (sym) != LOC_TYPEDEF)
2610     {
2611       if (symbol_read_needs_frame (sym))
2612         {
2613           if (innermost_block == 0 ||
2614               contained_in (block_found, innermost_block))
2615             innermost_block = block_found;
2616         }
2617
2618       write_exp_elt_opcode (OP_VAR_VALUE);
2619       /* We want to use the selected frame, not another more inner frame
2620          which happens to be in the same block.  */
2621       write_exp_elt_block (NULL);
2622       write_exp_elt_sym (sym);
2623       write_exp_elt_opcode (OP_VAR_VALUE);
2624       return 1;
2625     }
2626   if (is_a_field_of_this)
2627     {
2628       /* it hangs off of `this'.  Must not inadvertently convert from a
2629          method call to data ref.  */
2630       if (innermost_block == 0 ||
2631           contained_in (block_found, innermost_block))
2632         innermost_block = block_found;
2633       write_exp_elt_opcode (OP_THIS);
2634       write_exp_elt_opcode (OP_THIS);
2635       write_exp_elt_opcode (STRUCTOP_PTR);
2636       write_exp_string (name);
2637       write_exp_elt_opcode (STRUCTOP_PTR);
2638       return 1;
2639     }
2640   return 0;
2641 }
2642
2643 /* Assuming a reference expression has been pushed, emit the
2644    STRUCTOP_STRUCT ops to access the field named NAME.  If NAME is a
2645    qualified name (has '.'), generate a field access for each part. */
2646
2647 static void
2648 push_fieldnames (name)
2649      struct stoken name;
2650 {
2651   int i;
2652   struct stoken token;
2653   token.ptr = name.ptr;
2654   for (i = 0;  ;  i++)
2655     {
2656       if (i == name.length || name.ptr[i] == '.')
2657         {
2658           /* token.ptr is start of current field name. */
2659           token.length = &name.ptr[i] - token.ptr;
2660           write_exp_elt_opcode (STRUCTOP_STRUCT);
2661           write_exp_string (token);
2662           write_exp_elt_opcode (STRUCTOP_STRUCT);
2663           token.ptr += token.length + 1;
2664         }
2665       if (i >= name.length)
2666         break;
2667     }
2668 }
2669
2670 /* Helper routine for push_expression_name.
2671    Handle a qualified name, where DOT_INDEX is the index of the first '.' */
2672
2673 static void
2674 push_qualified_expression_name (struct stoken name, int dot_index)
2675 {
2676   struct stoken token;
2677   char *tmp;
2678   struct type *typ;
2679
2680   token.ptr = name.ptr;
2681   token.length = dot_index;
2682
2683   if (push_variable (token))
2684     {
2685       token.ptr = name.ptr + dot_index + 1;
2686       token.length = name.length - dot_index - 1;
2687       push_fieldnames (token);
2688       return;
2689     }
2690
2691   token.ptr = name.ptr;
2692   for (;;)
2693     {
2694       token.length = dot_index;
2695       tmp = copy_name (token);
2696       typ = java_lookup_class (tmp);
2697       if (typ != NULL)
2698         {
2699           if (dot_index == name.length)
2700             {
2701               write_exp_elt_opcode(OP_TYPE);
2702               write_exp_elt_type(typ);
2703               write_exp_elt_opcode(OP_TYPE);
2704               return;
2705             }
2706           dot_index++;  /* Skip '.' */
2707           name.ptr += dot_index;
2708           name.length -= dot_index;
2709           dot_index = 0;
2710           while (dot_index < name.length && name.ptr[dot_index] != '.')
2711             dot_index++;
2712           token.ptr = name.ptr;
2713           token.length = dot_index;
2714           write_exp_elt_opcode (OP_SCOPE);
2715           write_exp_elt_type (typ);
2716           write_exp_string (token);
2717           write_exp_elt_opcode (OP_SCOPE);
2718           if (dot_index < name.length)
2719             {
2720               dot_index++;
2721               name.ptr += dot_index;
2722               name.length -= dot_index;
2723               push_fieldnames (name);
2724             }
2725           return;
2726         }
2727       else if (dot_index >= name.length)
2728         break;
2729       dot_index++;  /* Skip '.' */
2730       while (dot_index < name.length && name.ptr[dot_index] != '.')
2731         dot_index++;
2732     }
2733   error (_("unknown type `%.*s'"), name.length, name.ptr);
2734 }
2735
2736 /* Handle Name in an expression (or LHS).
2737    Handle VAR, TYPE, TYPE.FIELD1....FIELDN and VAR.FIELD1....FIELDN. */
2738
2739 static void
2740 push_expression_name (name)
2741      struct stoken name;
2742 {
2743   char *tmp;
2744   struct type *typ;
2745   char *ptr;
2746   int i;
2747
2748   for (i = 0;  i < name.length;  i++)
2749     {
2750       if (name.ptr[i] == '.')
2751         {
2752           /* It's a Qualified Expression Name. */
2753           push_qualified_expression_name (name, i);
2754           return;
2755         }
2756     }
2757
2758   /* It's a Simple Expression Name. */
2759
2760   if (push_variable (name))
2761     return;
2762   tmp = copy_name (name);
2763   typ = java_lookup_class (tmp);
2764   if (typ != NULL)
2765     {
2766       write_exp_elt_opcode(OP_TYPE);
2767       write_exp_elt_type(typ);
2768       write_exp_elt_opcode(OP_TYPE);
2769     }
2770   else
2771     {
2772       struct minimal_symbol *msymbol;
2773
2774       msymbol = lookup_minimal_symbol (tmp, NULL, NULL);
2775       if (msymbol != NULL)
2776         {
2777           write_exp_msymbol (msymbol,
2778                              lookup_function_type (builtin_type_int),
2779                              builtin_type_int);
2780         }
2781       else if (!have_full_symbols () && !have_partial_symbols ())
2782         error (_("No symbol table is loaded.  Use the \"file\" command"));
2783       else
2784         error (_("No symbol \"%s\" in current context"), tmp);
2785     }
2786
2787 }
2788
2789
2790 /* The following two routines, copy_exp and insert_exp, aren't specific to
2791    Java, so they could go in parse.c, but their only purpose is to support
2792    the parsing kludges we use in this file, so maybe it's best to isolate
2793    them here.  */
2794
2795 /* Copy the expression whose last element is at index ENDPOS - 1 in EXPR
2796    into a freshly xmalloc'ed struct expression.  Its language_defn is set
2797    to null.  */
2798 static struct expression *
2799 copy_exp (expr, endpos)
2800      struct expression *expr;
2801      int endpos;
2802 {
2803   int len = length_of_subexp (expr, endpos);
2804   struct expression *new
2805     = (struct expression *) xmalloc (sizeof (*new) + EXP_ELEM_TO_BYTES (len));
2806   new->nelts = len;
2807   memcpy (new->elts, expr->elts + endpos - len, EXP_ELEM_TO_BYTES (len));
2808   new->language_defn = 0;
2809
2810   return new;
2811 }
2812
2813 /* Insert the expression NEW into the current expression (expout) at POS.  */
2814 static void
2815 insert_exp (pos, new)
2816      int pos;
2817      struct expression *new;
2818 {
2819   int newlen = new->nelts;
2820
2821   /* Grow expout if necessary.  In this function's only use at present,
2822      this should never be necessary.  */
2823   if (expout_ptr + newlen > expout_size)
2824     {
2825       expout_size = max (expout_size * 2, expout_ptr + newlen + 10);
2826       expout = (struct expression *)
2827         xrealloc ((char *) expout, (sizeof (struct expression)
2828                                     + EXP_ELEM_TO_BYTES (expout_size)));
2829     }
2830
2831   {
2832     int i;
2833
2834     for (i = expout_ptr - 1; i >= pos; i--)
2835       expout->elts[i + newlen] = expout->elts[i];
2836   }
2837
2838   memcpy (expout->elts + pos, new->elts, EXP_ELEM_TO_BYTES (newlen));
2839   expout_ptr += newlen;
2840 }
2841
2842