-# line 31 "expread.y"
+/* A Bison parser, made from ./expread.y */
+
+#define INT 258
+#define CHAR 259
+#define UINT 260
+#define FLOAT 261
+#define STRING 262
+#define NAME 263
+#define BLOCKNAME 264
+#define TYPENAME 265
+#define NAME_OR_INT 266
+#define NAME_OR_UINT 267
+#define STRUCT 268
+#define UNION 269
+#define ENUM 270
+#define SIZEOF 271
+#define UNSIGNED 272
+#define COLONCOLON 273
+#define ERROR 274
+#define SIGNED 275
+#define LONG 276
+#define SHORT 277
+#define INT_KEYWORD 278
+#define LAST 279
+#define REGNAME 280
+#define VARIABLE 281
+#define ASSIGN_MODIFY 282
+#define THIS 283
+#define ABOVE_COMMA 284
+#define OR 285
+#define AND 286
+#define EQUAL 287
+#define NOTEQUAL 288
+#define LEQ 289
+#define GEQ 290
+#define LSH 291
+#define RSH 292
+#define UNARY 293
+#define INCREMENT 294
+#define DECREMENT 295
+#define ARROW 296
+
+#line 29 "./expread.y"
+
+#include <stdio.h>
#include "defs.h"
#include "param.h"
#include "symtab.h"
#include "frame.h"
#include "expression.h"
-
-#include <stdio.h>
+#include "value.h"
+#include "command.h"
static struct expression *expout;
static int expout_size;
static int expout_ptr;
static int yylex ();
-static yyerror ();
+static void yyerror ();
static void write_exp_elt ();
-static void write_exp_elt2 ();
+static void write_exp_elt_opcode ();
+static void write_exp_elt_sym ();
+static void write_exp_elt_longcst ();
+static void write_exp_elt_dblcst ();
+static void write_exp_elt_type ();
+static void write_exp_elt_intern ();
static void write_exp_string ();
static void start_arglist ();
static int end_arglist ();
static void free_funcalls ();
static char *copy_name ();
+static int parse_number ();
/* If this is nonzero, this block is used as the lexical context
for symbol names. */
static struct block *expression_context_block;
+/* The innermost context required by the stack and register variables
+ we've encountered so far. */
+struct block *innermost_block;
+
+/* The block in which the most recently discovered symbol was found. */
+struct block *block_found;
+
/* Number of arguments seen so far in innermost function call. */
static int arglist_len;
int length;
};
-# line 86 "expread.y"
-typedef union
+struct ttype
+ {
+ struct stoken stoken;
+ struct type *type;
+ };
+
+struct symtoken
+ {
+ struct stoken stoken;
+ struct symbol *sym;
+ int is_a_field_of_this;
+ };
+
+/* For parsing of complicated types.
+ An array should be preceded in the list by the size of the array. */
+enum type_pieces
+ {tp_end = -1, tp_pointer, tp_reference, tp_array, tp_function};
+/* The stack can contain either an enum type_pieces or an int. */
+union type_stack_elt {
+ enum type_pieces piece;
+ int int_val;
+};
+static union type_stack_elt *type_stack;
+static int type_stack_depth, type_stack_size;
+
+static void push_type ();
+static void push_type_int ();
+static enum type_pieces pop_type ();
+static int pop_type_int ();
+
+/* Allow debugging of parsing. */
+#define YYDEBUG 1
+
+#line 132 "./expread.y"
+typedef union
{
- long lval;
+ LONGEST lval;
+ unsigned LONGEST ulval;
double dval;
struct symbol *sym;
struct type *tval;
struct stoken sval;
+ struct ttype tsym;
+ struct symtoken ssym;
int voidval;
struct block *bval;
enum exp_opcode opcode;
struct type **tvec;
int *ivec;
} YYSTYPE;
-# define INT 257
-# define CHAR 258
-# define FLOAT 259
-# define NAME 260
-# define TYPENAME 261
-# define STRING 262
-# define STRUCT 263
-# define UNION 264
-# define ENUM 265
-# define SIZEOF 266
-# define UNSIGNED 267
-# define COLONCOLON 268
-# define LAST 269
-# define REGNAME 270
-# define VARIABLE 271
-# define ASSIGN_MODIFY 272
-# define THIS 273
-# define ABOVE_COMMA 274
-# define OR 275
-# define AND 276
-# define EQUAL 277
-# define NOTEQUAL 278
-# define LEQ 279
-# define GEQ 280
-# define LSH 281
-# define RSH 282
-# define UNARY 283
-# define INCREMENT 284
-# define DECREMENT 285
-# define ARROW 286
-#define yyclearin yychar = -1
-#define yyerrok yyerrflag = 0
-extern int yychar;
-extern short yyerrflag;
+
+#ifndef YYLTYPE
+typedef
+ struct yyltype
+ {
+ int timestamp;
+ int first_line;
+ int first_column;
+ int last_line;
+ int last_column;
+ char *text;
+ }
+ yyltype;
+
+#define YYLTYPE yyltype
+#endif
+
+#include <stdio.h>
+
+#ifndef __STDC__
+#define const
+#endif
+
+
+
+#define YYFINAL 197
+#define YYFLAG -32768
+#define YYNTBASE 66
+
+#define YYTRANSLATE(x) ((unsigned)(x) <= 296 ? yytranslate[x] : 84)
+
+static const char yytranslate[] = { 0,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 59, 2, 2, 2, 51, 37, 2, 58,
+ 62, 49, 47, 29, 48, 56, 50, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 65, 2, 40,
+ 31, 41, 32, 46, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 57, 2, 61, 36, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 63, 35, 64, 60, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 1, 2, 3, 4, 5,
+ 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+ 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
+ 26, 27, 28, 30, 33, 34, 38, 39, 42, 43,
+ 44, 45, 52, 53, 54, 55
+};
+
+static const short yyprhs[] = { 0,
+ 0, 2, 4, 8, 11, 14, 17, 20, 23, 26,
+ 29, 32, 35, 38, 42, 47, 51, 56, 61, 62,
+ 68, 69, 71, 75, 80, 85, 89, 93, 97, 101,
+ 105, 109, 113, 117, 121, 125, 129, 133, 137, 141,
+ 145, 149, 153, 157, 161, 165, 171, 175, 179, 181,
+ 183, 185, 187, 189, 191, 193, 195, 197, 199, 204,
+ 206, 208, 210, 214, 218, 222, 227, 230, 232, 234,
+ 237, 239, 242, 244, 247, 249, 253, 256, 258, 261,
+ 263, 266, 270, 273, 275, 279, 286, 295, 305, 307,
+ 309, 311, 313, 316, 320, 323, 327, 331, 336, 339,
+ 343, 346, 349, 352, 355, 357, 360, 362, 364, 366,
+ 368, 370, 372, 376, 378, 380, 382, 384, 386, 388
+};
+
+static const short yyrhs[] = { 67,
+ 0, 68, 0, 67, 29, 68, 0, 49, 68, 0,
+ 37, 68, 0, 48, 68, 0, 59, 68, 0, 60,
+ 68, 0, 53, 68, 0, 54, 68, 0, 68, 53,
+ 0, 68, 54, 0, 16, 68, 0, 68, 55, 82,
+ 0, 68, 55, 49, 68, 0, 68, 56, 82, 0,
+ 68, 56, 49, 68, 0, 68, 57, 67, 61, 0,
+ 0, 68, 58, 69, 70, 62, 0, 0, 68, 0,
+ 70, 29, 68, 0, 63, 78, 64, 68, 0, 58,
+ 78, 62, 68, 0, 58, 67, 62, 0, 68, 46,
+ 68, 0, 68, 49, 68, 0, 68, 50, 68, 0,
+ 68, 51, 68, 0, 68, 47, 68, 0, 68, 48,
+ 68, 0, 68, 44, 68, 0, 68, 45, 68, 0,
+ 68, 38, 68, 0, 68, 39, 68, 0, 68, 42,
+ 68, 0, 68, 43, 68, 0, 68, 40, 68, 0,
+ 68, 41, 68, 0, 68, 37, 68, 0, 68, 36,
+ 68, 0, 68, 35, 68, 0, 68, 34, 68, 0,
+ 68, 33, 68, 0, 68, 32, 68, 65, 68, 0,
+ 68, 31, 68, 0, 68, 27, 68, 0, 3, 0,
+ 11, 0, 5, 0, 12, 0, 4, 0, 6, 0,
+ 72, 0, 24, 0, 25, 0, 26, 0, 16, 58,
+ 78, 62, 0, 7, 0, 28, 0, 9, 0, 71,
+ 18, 82, 0, 71, 18, 82, 0, 79, 18, 82,
+ 0, 79, 18, 60, 82, 0, 18, 82, 0, 83,
+ 0, 79, 0, 79, 74, 0, 49, 0, 49, 74,
+ 0, 37, 0, 37, 74, 0, 75, 0, 58, 74,
+ 62, 0, 75, 76, 0, 76, 0, 75, 77, 0,
+ 77, 0, 57, 61, 0, 57, 3, 61, 0, 58,
+ 62, 0, 73, 0, 79, 18, 49, 0, 78, 58,
+ 79, 18, 49, 62, 0, 78, 58, 79, 18, 49,
+ 62, 58, 62, 0, 78, 58, 79, 18, 49, 62,
+ 58, 81, 62, 0, 10, 0, 23, 0, 21, 0,
+ 22, 0, 21, 23, 0, 17, 21, 23, 0, 21,
+ 21, 0, 21, 21, 23, 0, 17, 21, 21, 0,
+ 17, 21, 21, 23, 0, 22, 23, 0, 17, 22,
+ 23, 0, 13, 82, 0, 14, 82, 0, 15, 82,
+ 0, 17, 80, 0, 17, 0, 20, 80, 0, 20,
+ 0, 10, 0, 23, 0, 21, 0, 22, 0, 78,
+ 0, 81, 29, 78, 0, 8, 0, 9, 0, 10,
+ 0, 11, 0, 12, 0, 8, 0, 9, 0
+};
+
+#if YYDEBUG != 0
+static const short yyrline[] = { 0,
+ 225, 229, 230, 235, 238, 241, 245, 249, 253, 257,
+ 261, 265, 269, 273, 279, 283, 289, 293, 297, 301,
+ 307, 310, 314, 318, 324, 330, 336, 340, 344, 348,
+ 352, 356, 360, 364, 368, 372, 376, 380, 384, 388,
+ 392, 396, 400, 404, 408, 412, 416, 420, 426, 436,
+ 449, 461, 474, 481, 488, 491, 497, 503, 509, 516,
+ 523, 530, 548, 558, 570, 583, 601, 647, 741, 742,
+ 777, 779, 781, 783, 785, 788, 790, 795, 801, 803,
+ 807, 809, 813, 817, 818, 820, 822, 825, 832, 834,
+ 836, 838, 840, 842, 844, 846, 848, 850, 852, 854,
+ 856, 859, 862, 865, 867, 869, 871, 875, 876, 882,
+ 888, 897, 902, 909, 910, 911, 912, 913, 916, 917
+};
+
+static const char * const yytname[] = { "$",
+"error","$illegal.","INT","CHAR","UINT","FLOAT","STRING","NAME","BLOCKNAME","TYPENAME",
+"NAME_OR_INT","NAME_OR_UINT","STRUCT","UNION","ENUM","SIZEOF","UNSIGNED","COLONCOLON","ERROR","SIGNED",
+"LONG","SHORT","INT_KEYWORD","LAST","REGNAME","VARIABLE","ASSIGN_MODIFY","THIS","','","ABOVE_COMMA",
+"'='","'?'","OR","AND","'|'","'^'","'&'","EQUAL","NOTEQUAL","'<'",
+"'>'","LEQ","GEQ","LSH","RSH","'@'","'+'","'-'","'*'","'/'",
+"'%'","UNARY","INCREMENT","DECREMENT","ARROW","'.'","'['","'('","'!'","'~'",
+"']'","')'","'{'","'}'","':'","start","exp1","exp","@1","arglist",
+"block","variable","ptype","abs_decl","direct_abs_decl","array_mod","func_mod","type","typebase","typename",
+"nonempty_typelist","name","name_not_typename",""
+};
+#endif
+
+static const short yyr1[] = { 0,
+ 66, 67, 67, 68, 68, 68, 68, 68, 68, 68,
+ 68, 68, 68, 68, 68, 68, 68, 68, 69, 68,
+ 70, 70, 70, 68, 68, 68, 68, 68, 68, 68,
+ 68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
+ 68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
+ 68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
+ 68, 71, 71, 72, 72, 72, 72, 72, 73, 73,
+ 74, 74, 74, 74, 74, 75, 75, 75, 75, 75,
+ 76, 76, 77, 78, 78, 78, 78, 78, 79, 79,
+ 79, 79, 79, 79, 79, 79, 79, 79, 79, 79,
+ 79, 79, 79, 79, 79, 79, 79, 80, 80, 80,
+ 80, 81, 81, 82, 82, 82, 82, 82, 83, 83
+};
+
+static const short yyr2[] = { 0,
+ 1, 1, 3, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 3, 4, 3, 4, 4, 0, 5,
+ 0, 1, 3, 4, 4, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 5, 3, 3, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 4, 1,
+ 1, 1, 3, 3, 3, 4, 2, 1, 1, 2,
+ 1, 2, 1, 2, 1, 3, 2, 1, 2, 1,
+ 2, 3, 2, 1, 3, 6, 8, 9, 1, 1,
+ 1, 1, 2, 3, 2, 3, 3, 4, 2, 3,
+ 2, 2, 2, 2, 1, 2, 1, 1, 1, 1,
+ 1, 1, 3, 1, 1, 1, 1, 1, 1, 1
+};
+
+static const short yydefact[] = { 0,
+ 49, 53, 51, 54, 60, 119, 120, 89, 50, 52,
+ 0, 0, 0, 0, 105, 0, 107, 91, 92, 90,
+ 56, 57, 58, 61, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 2, 0, 55, 0, 68, 114,
+ 115, 116, 117, 118, 101, 102, 103, 0, 13, 108,
+ 110, 111, 109, 104, 67, 110, 111, 106, 95, 93,
+ 99, 5, 6, 4, 9, 10, 0, 84, 0, 69,
+ 7, 8, 0, 69, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 11, 12, 0,
+ 0, 0, 19, 0, 0, 0, 97, 94, 100, 96,
+ 26, 0, 0, 0, 73, 71, 0, 0, 70, 75,
+ 78, 80, 0, 0, 3, 48, 47, 0, 45, 44,
+ 43, 42, 41, 35, 36, 39, 40, 37, 38, 33,
+ 34, 27, 31, 32, 28, 29, 30, 0, 14, 0,
+ 16, 0, 21, 64, 0, 65, 59, 98, 0, 25,
+ 85, 74, 72, 0, 81, 83, 0, 0, 77, 79,
+ 24, 0, 15, 17, 18, 22, 0, 66, 0, 82,
+ 76, 46, 0, 20, 0, 23, 86, 0, 87, 112,
+ 0, 0, 88, 113, 0, 0, 0
+};
+
+static const short yydefgoto[] = { 195,
+ 67, 35, 153, 177, 36, 37, 68, 119, 120, 121,
+ 122, 69, 38, 54, 191, 156, 39
+};
+
+static const short yypact[] = { 167,
+-32768,-32768,-32768,-32768,-32768,-32768, 7,-32768,-32768,-32768,
+ 22, 22, 22, 228, 190, 22, 245, 119, -7,-32768,
+-32768,-32768,-32768,-32768, 167, 167, 167, 167, 167, 167,
+ 167, 167, 528, 60, 303, 33,-32768, 76,-32768,-32768,
+-32768,-32768,-32768,-32768,-32768,-32768,-32768, 167, 216,-32768,
+ 134, 77,-32768,-32768,-32768,-32768,-32768,-32768, 78,-32768,
+-32768, 216, 216, 216, 216, 216, 59,-32768, -52, 75,
+ 216, 216, -55, 80, 167, 167, 167, 167, 167, 167,
+ 167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
+ 167, 167, 167, 167, 167, 167, 167,-32768,-32768, 198,
+ 249, 167,-32768, 22, 138, -34, 90,-32768,-32768,-32768,
+-32768, 528, 167, 96, 165, 165, 26, 104,-32768, -50,
+-32768,-32768, 167, 47, 303, 303, 303, 268, 355, 379,
+ 402, 424, 445, 464, 464, 479, 479, 479, 479, 506,
+ 506, 518, 529, 529, 216, 216, 216, 167,-32768, 167,
+-32768, -2, 167, 98, 22,-32768, 32,-32768, 113, 216,
+-32768,-32768,-32768, 62,-32768,-32768, 82, 106,-32768,-32768,
+ 216, 167, 216, 216,-32768, 303, 68,-32768, 137,-32768,
+-32768, 330, 167,-32768, 132, 303, 139, 105,-32768, 141,
+ 73, 528,-32768, 141, 196, 201,-32768
+};
+
+static const short yypgoto[] = {-32768,
+ 1, -14,-32768,-32768,-32768,-32768,-32768, 36,-32768, 83,
+ 85, -29, -28, 200,-32768, 10,-32768
+};
+
+
+#define YYLAST 587
+
+
+static const short yytable[] = { 49,
+ 34, 70, 112, 73, 74, 112, 117, 168, 123, 113,
+ 62, 63, 64, 65, 66, 61, 71, 72, 106, 70,
+ 45, 46, 47, 112, -62, 55, 75, 157, 164, 40,
+ 41, 42, 43, 44, 1, 2, 3, 4, 5, 6,
+ 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+ 104, 17, 18, 19, 20, 21, 22, 23, 175, 24,
+ 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
+ 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
+ 145, 146, 147, 159, 28, 29, 165, 75, 75, 30,
+ 31, 32, 114, 105, 33, 161, 183, 124, 160, 109,
+ 110, 192, 152, 40, 41, 42, 43, 44, 171, 149,
+ 151, 115, 158, 154, 8, -63, 115, 11, 12, 13,
+ 111, 15, 180, 116, 17, 18, 19, 20, 116, 184,
+ 179, 117, 118, 173, 193, 174, 117, 118, 176, 59,
+ 115, 60, 160, 181, 161, 40, 41, 42, 43, 44,
+ 162, 163, 116, 167, 107, 155, 108, 182, 190, 74,
+ 117, 118, 194, 74, 178, 166, 189, 166, 186, 1,
+ 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
+ 12, 13, 14, 15, 16, 185, 17, 18, 19, 20,
+ 21, 22, 23, 187, 24, 196, 188, 155, 112, 50,
+ 197, 115, 169, 25, 170, 40, 41, 42, 43, 44,
+ 51, 52, 53, 116, 26, 27, 58, 0, 0, 28,
+ 29, 117, 118, 0, 30, 31, 32, 0, 0, 33,
+ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+ 11, 12, 13, 14, 15, 16, 148, 17, 18, 19,
+ 20, 21, 22, 23, 50, 24, 40, 41, 42, 43,
+ 44, 0, 0, 0, 25, 56, 57, 53, 98, 99,
+ 100, 101, 102, 103, 0, 26, 27, 0, 0, 0,
+ 28, 29, 0, 0, 0, 48, 31, 32, 0, 0,
+ 33, 0, 0, 0, 76, 0, 0, 150, 77, 78,
+ 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
+ 89, 90, 91, 92, 93, 94, 95, 96, 97, 0,
+ 98, 99, 100, 101, 102, 103, 0, 0, 0, 76,
+ 0, 0, 172, 77, 78, 79, 80, 81, 82, 83,
+ 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
+ 94, 95, 96, 97, 0, 98, 99, 100, 101, 102,
+ 103, 78, 79, 80, 81, 82, 83, 84, 85, 86,
+ 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
+ 97, 0, 98, 99, 100, 101, 102, 103, 80, 81,
+ 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
+ 92, 93, 94, 95, 96, 97, 0, 98, 99, 100,
+ 101, 102, 103, 81, 82, 83, 84, 85, 86, 87,
+ 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
+ 0, 98, 99, 100, 101, 102, 103, 82, 83, 84,
+ 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
+ 95, 96, 97, 0, 98, 99, 100, 101, 102, 103,
+ 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
+ 93, 94, 95, 96, 97, 0, 98, 99, 100, 101,
+ 102, 103, 84, 85, 86, 87, 88, 89, 90, 91,
+ 92, 93, 94, 95, 96, 97, 0, 98, 99, 100,
+ 101, 102, 103, 86, 87, 88, 89, 90, 91, 92,
+ 93, 94, 95, 96, 97, 0, 98, 99, 100, 101,
+ 102, 103, 90, 91, 92, 93, 94, 95, 96, 97,
+ 0, 98, 99, 100, 101, 102, 103, 8, 0, 0,
+ 11, 12, 13, 0, 15, 0, 0, 17, 18, 19,
+ 20, 92, 93, 94, 95, 96, 97, 0, 98, 99,
+ 100, 101, 102, 103, 93, 94, 95, 96, 97, 0,
+ 98, 99, 100, 101, 102, 103, 0, 95, 96, 97,
+ 0, 98, 99, 100, 101, 102, 103
+};
+
+static const short yycheck[] = { 14,
+ 0, 30, 58, 33, 33, 58, 57, 58, 64, 62,
+ 25, 26, 27, 28, 29, 23, 31, 32, 48, 48,
+ 11, 12, 13, 58, 18, 16, 29, 62, 3, 8,
+ 9, 10, 11, 12, 3, 4, 5, 6, 7, 8,
+ 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
+ 18, 20, 21, 22, 23, 24, 25, 26, 61, 28,
+ 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
+ 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
+ 95, 96, 97, 112, 53, 54, 61, 29, 29, 58,
+ 59, 60, 18, 18, 63, 49, 29, 18, 113, 23,
+ 23, 29, 102, 8, 9, 10, 11, 12, 123, 100,
+ 101, 37, 23, 104, 10, 18, 37, 13, 14, 15,
+ 62, 17, 61, 49, 20, 21, 22, 23, 49, 62,
+ 18, 57, 58, 148, 62, 150, 57, 58, 153, 21,
+ 37, 23, 157, 62, 49, 8, 9, 10, 11, 12,
+ 115, 116, 49, 118, 21, 60, 23, 172, 188, 188,
+ 57, 58, 192, 192, 155, 62, 62, 62, 183, 3,
+ 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
+ 14, 15, 16, 17, 18, 49, 20, 21, 22, 23,
+ 24, 25, 26, 62, 28, 0, 58, 60, 58, 10,
+ 0, 37, 120, 37, 120, 8, 9, 10, 11, 12,
+ 21, 22, 23, 49, 48, 49, 17, -1, -1, 53,
+ 54, 57, 58, -1, 58, 59, 60, -1, -1, 63,
+ 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
+ 13, 14, 15, 16, 17, 18, 49, 20, 21, 22,
+ 23, 24, 25, 26, 10, 28, 8, 9, 10, 11,
+ 12, -1, -1, -1, 37, 21, 22, 23, 53, 54,
+ 55, 56, 57, 58, -1, 48, 49, -1, -1, -1,
+ 53, 54, -1, -1, -1, 58, 59, 60, -1, -1,
+ 63, -1, -1, -1, 27, -1, -1, 49, 31, 32,
+ 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
+ 43, 44, 45, 46, 47, 48, 49, 50, 51, -1,
+ 53, 54, 55, 56, 57, 58, -1, -1, -1, 27,
+ -1, -1, 65, 31, 32, 33, 34, 35, 36, 37,
+ 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+ 48, 49, 50, 51, -1, 53, 54, 55, 56, 57,
+ 58, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+ 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
+ 51, -1, 53, 54, 55, 56, 57, 58, 34, 35,
+ 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
+ 46, 47, 48, 49, 50, 51, -1, 53, 54, 55,
+ 56, 57, 58, 35, 36, 37, 38, 39, 40, 41,
+ 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
+ -1, 53, 54, 55, 56, 57, 58, 36, 37, 38,
+ 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
+ 49, 50, 51, -1, 53, 54, 55, 56, 57, 58,
+ 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
+ 47, 48, 49, 50, 51, -1, 53, 54, 55, 56,
+ 57, 58, 38, 39, 40, 41, 42, 43, 44, 45,
+ 46, 47, 48, 49, 50, 51, -1, 53, 54, 55,
+ 56, 57, 58, 40, 41, 42, 43, 44, 45, 46,
+ 47, 48, 49, 50, 51, -1, 53, 54, 55, 56,
+ 57, 58, 44, 45, 46, 47, 48, 49, 50, 51,
+ -1, 53, 54, 55, 56, 57, 58, 10, -1, -1,
+ 13, 14, 15, -1, 17, -1, -1, 20, 21, 22,
+ 23, 46, 47, 48, 49, 50, 51, -1, 53, 54,
+ 55, 56, 57, 58, 47, 48, 49, 50, 51, -1,
+ 53, 54, 55, 56, 57, 58, -1, 49, 50, 51,
+ -1, 53, 54, 55, 56, 57, 58
+};
+/* -*-C-*- Note some compilers choke on comments on `#line' lines. */
+#line 3 "/usr/latest/lib/bison.simple"
+
+/* Skeleton output parser for bison,
+ Copyright (C) 1984, 1989, 1990 Bob Corbett and Richard Stallman
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 1, or (at your option)
+ any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+
+#ifndef alloca
+#ifdef __GNUC__
+#define alloca __builtin_alloca
+#else /* Not GNU C. */
+#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__)
+#include <alloca.h>
+#else /* Not sparc */
+#ifdef MSDOS
+#include <malloc.h>
+#endif /* MSDOS */
+#endif /* Not sparc. */
+#endif /* Not GNU C. */
+#endif /* alloca not defined. */
+
+/* This is the parser code that is written into each bison parser
+ when the %semantic_parser declaration is not specified in the grammar.
+ It was written by Richard Stallman by simplifying the hairy parser
+ used when %semantic_parser is specified. */
+
+/* Note: there must be only one dollar sign in this file.
+ It is replaced by the list of actions, each action
+ as one case of the switch. */
+
+#define yyerrok (yyerrstatus = 0)
+#define yyclearin (yychar = YYEMPTY)
+#define YYEMPTY -2
+#define YYEOF 0
+#define YYACCEPT return(0)
+#define YYABORT return(1)
+#define YYERROR goto yyerrlab1
+/* Like YYERROR except do call yyerror.
+ This remains here temporarily to ease the
+ transition to the new meaning of YYERROR, for GCC.
+ Once GCC version 2 has supplanted version 1, this can go. */
+#define YYFAIL goto yyerrlab
+#define YYRECOVERING() (!!yyerrstatus)
+#define YYBACKUP(token, value) \
+do \
+ if (yychar == YYEMPTY && yylen == 1) \
+ { yychar = (token), yylval = (value); \
+ yychar1 = YYTRANSLATE (yychar); \
+ YYPOPSTACK; \
+ goto yybackup; \
+ } \
+ else \
+ { yyerror ("syntax error: cannot back up"); YYERROR; } \
+while (0)
+
+#define YYTERROR 1
+#define YYERRCODE 256
+
+#ifndef YYPURE
+#define YYLEX yylex()
+#endif
+
+#ifdef YYPURE
+#ifdef YYLSP_NEEDED
+#define YYLEX yylex(&yylval, &yylloc)
+#else
+#define YYLEX yylex(&yylval)
+#endif
+#endif
+
+/* If nonreentrant, generate the variables here */
+
+#ifndef YYPURE
+
+int yychar; /* the lookahead symbol */
+YYSTYPE yylval; /* the semantic value of the */
+ /* lookahead symbol */
+
+#ifdef YYLSP_NEEDED
+YYLTYPE yylloc; /* location data for the lookahead */
+ /* symbol */
+#endif
+
+int yynerrs; /* number of parse errors so far */
+#endif /* not YYPURE */
+
+#if YYDEBUG != 0
+int yydebug; /* nonzero means print parse trace */
+/* Since this is uninitialized, it does not stop multiple parsers
+ from coexisting. */
+#endif
+
+/* YYINITDEPTH indicates the initial size of the parser's stacks */
+
+#ifndef YYINITDEPTH
+#define YYINITDEPTH 200
+#endif
+
+/* YYMAXDEPTH is the maximum size the stacks can grow to
+ (effective only if the built-in stack extension method is used). */
+
+#if YYMAXDEPTH == 0
+#undef YYMAXDEPTH
+#endif
+
#ifndef YYMAXDEPTH
-#define YYMAXDEPTH 150
+#define YYMAXDEPTH 10000
#endif
-YYSTYPE yylval, yyval;
-# define YYERRCODE 256
+\f
+#ifndef __cplusplus
+
+/* This is the most reliable way to avoid incompatibilities
+ in available built-in functions on various systems. */
+static void
+__yy_bcopy (from, to, count)
+ char *from;
+ char *to;
+ int count;
+{
+ register char *f = from;
+ register char *t = to;
+ register int i = count;
+
+ while (i-- > 0)
+ *t++ = *f++;
+}
+
+#else /* __cplusplus */
+
+/* This is the most reliable way to avoid incompatibilities
+ in available built-in functions on various systems. */
+static void
+__yy_bcopy (char *from, char *to, int count)
+{
+ register char *f = from;
+ register char *t = to;
+ register int i = count;
-# line 625 "expread.y"
+ while (i-- > 0)
+ *t++ = *f++;
+}
+
+#endif
+\f
+#line 160 "/usr/latest/lib/bison.simple"
+int
+yyparse()
+{
+ register int yystate;
+ register int yyn;
+ register short *yyssp;
+ register YYSTYPE *yyvsp;
+ int yyerrstatus; /* number of tokens to shift before error messages enabled */
+ int yychar1; /* lookahead token as an internal (translated) token number */
+
+ short yyssa[YYINITDEPTH]; /* the state stack */
+ YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */
+
+ short *yyss = yyssa; /* refer to the stacks thru separate pointers */
+ YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */
+
+#ifdef YYLSP_NEEDED
+ YYLTYPE *yyls = yylsa;
+ YYLTYPE *yylsp;
+ YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */
+
+#define YYPOPSTACK (yyvsp--, yysp--, yylsp--)
+#else
+#define YYPOPSTACK (yyvsp--, yysp--)
+#endif
+
+ int yystacksize = YYINITDEPTH;
+
+#ifdef YYPURE
+ int yychar;
+ YYSTYPE yylval;
+ int yynerrs;
+#ifdef YYLSP_NEEDED
+ YYLTYPE yylloc;
+#endif
+#endif
+
+ YYSTYPE yyval; /* the variable used to return */
+ /* semantic values from the action */
+ /* routines */
+
+ int yylen;
+
+#if YYDEBUG != 0
+ if (yydebug)
+ fprintf(stderr, "Starting parse\n");
+#endif
+
+ yystate = 0;
+ yyerrstatus = 0;
+ yynerrs = 0;
+ yychar = YYEMPTY; /* Cause a token to be read. */
+
+ /* Initialize stack pointers.
+ Waste one element of value and location stack
+ so that they stay on the same level as the state stack. */
+
+ yyssp = yyss - 1;
+ yyvsp = yyvs;
+#ifdef YYLSP_NEEDED
+ yylsp = yyls;
+#endif
+
+/* Push a new state, which is found in yystate . */
+/* In all cases, when you get here, the value and location stacks
+ have just been pushed. so pushing a state here evens the stacks. */
+yynewstate:
+
+ *++yyssp = yystate;
+
+ if (yyssp >= yyss + yystacksize - 1)
+ {
+ /* Give user a chance to reallocate the stack */
+ /* Use copies of these so that the &'s don't force the real ones into memory. */
+ YYSTYPE *yyvs1 = yyvs;
+ short *yyss1 = yyss;
+#ifdef YYLSP_NEEDED
+ YYLTYPE *yyls1 = yyls;
+#endif
+
+ /* Get the current used size of the three stacks, in elements. */
+ int size = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+ /* Each stack pointer address is followed by the size of
+ the data in use in that stack, in bytes. */
+ yyoverflow("parser stack overflow",
+ &yyss1, size * sizeof (*yyssp),
+ &yyvs1, size * sizeof (*yyvsp),
+#ifdef YYLSP_NEEDED
+ &yyls1, size * sizeof (*yylsp),
+#endif
+ &yystacksize);
+
+ yyss = yyss1; yyvs = yyvs1;
+#ifdef YYLSP_NEEDED
+ yyls = yyls1;
+#endif
+#else /* no yyoverflow */
+ /* Extend the stack our own way. */
+ if (yystacksize >= YYMAXDEPTH)
+ {
+ yyerror("parser stack overflow");
+ return 2;
+ }
+ yystacksize *= 2;
+ if (yystacksize > YYMAXDEPTH)
+ yystacksize = YYMAXDEPTH;
+ yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
+ __yy_bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
+ yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
+ __yy_bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
+#ifdef YYLSP_NEEDED
+ yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
+ __yy_bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
+#endif
+#endif /* no yyoverflow */
+
+ yyssp = yyss + size - 1;
+ yyvsp = yyvs + size - 1;
+#ifdef YYLSP_NEEDED
+ yylsp = yyls + size - 1;
+#endif
+
+#if YYDEBUG != 0
+ if (yydebug)
+ fprintf(stderr, "Stack size increased to %d\n", yystacksize);
+#endif
+
+ if (yyssp >= yyss + yystacksize - 1)
+ YYABORT;
+ }
+
+#if YYDEBUG != 0
+ if (yydebug)
+ fprintf(stderr, "Entering state %d\n", yystate);
+#endif
+
+ yybackup:
+
+/* Do appropriate processing given the current state. */
+/* Read a lookahead token if we need one and don't already have one. */
+/* yyresume: */
+
+ /* First try to decide what to do without reference to lookahead token. */
+
+ yyn = yypact[yystate];
+ if (yyn == YYFLAG)
+ goto yydefault;
+
+ /* Not known => get a lookahead token if don't already have one. */
+
+ /* yychar is either YYEMPTY or YYEOF
+ or a valid token in external form. */
+
+ if (yychar == YYEMPTY)
+ {
+#if YYDEBUG != 0
+ if (yydebug)
+ fprintf(stderr, "Reading a token: ");
+#endif
+ yychar = YYLEX;
+ }
+
+ /* Convert token to internal form (in yychar1) for indexing tables with */
+
+ if (yychar <= 0) /* This means end of input. */
+ {
+ yychar1 = 0;
+ yychar = YYEOF; /* Don't call YYLEX any more */
+
+#if YYDEBUG != 0
+ if (yydebug)
+ fprintf(stderr, "Now at end of input.\n");
+#endif
+ }
+ else
+ {
+ yychar1 = YYTRANSLATE(yychar);
+
+#if YYDEBUG != 0
+ if (yydebug)
+ fprintf(stderr, "Next token is %d (%s)\n", yychar, yytname[yychar1]);
+#endif
+ }
+
+ yyn += yychar1;
+ if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
+ goto yydefault;
+
+ yyn = yytable[yyn];
+
+ /* yyn is what to do for this token type in this state.
+ Negative => reduce, -yyn is rule number.
+ Positive => shift, yyn is new state.
+ New state is final state => don't bother to shift,
+ just return success.
+ 0, or most negative number => error. */
+
+ if (yyn < 0)
+ {
+ if (yyn == YYFLAG)
+ goto yyerrlab;
+ yyn = -yyn;
+ goto yyreduce;
+ }
+ else if (yyn == 0)
+ goto yyerrlab;
+
+ if (yyn == YYFINAL)
+ YYACCEPT;
+
+ /* Shift the lookahead token. */
+
+#if YYDEBUG != 0
+ if (yydebug)
+ fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
+#endif
+
+ /* Discard the token being shifted unless it is eof. */
+ if (yychar != YYEOF)
+ yychar = YYEMPTY;
+
+ *++yyvsp = yylval;
+#ifdef YYLSP_NEEDED
+ *++yylsp = yylloc;
+#endif
+
+ /* count tokens shifted since error; after three, turn off error status. */
+ if (yyerrstatus) yyerrstatus--;
+
+ yystate = yyn;
+ goto yynewstate;
+
+/* Do the default action for the current state. */
+yydefault:
+
+ yyn = yydefact[yystate];
+ if (yyn == 0)
+ goto yyerrlab;
+
+/* Do a reduction. yyn is the number of a rule to reduce with. */
+yyreduce:
+ yylen = yyr2[yyn];
+ yyval = yyvsp[1-yylen]; /* implement default value of the action */
+
+#if YYDEBUG != 0
+ if (yydebug)
+ {
+ int i;
+
+ fprintf (stderr, "Reducing via rule %d (line %d), ",
+ yyn, yyrline[yyn]);
+
+ /* Print the symboles being reduced, and their result. */
+ for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
+ fprintf (stderr, "%s ", yytname[yyrhs[i]]);
+ fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
+ }
+#endif
+
+
+ switch (yyn) {
+
+case 3:
+#line 231 "./expread.y"
+{ write_exp_elt_opcode (BINOP_COMMA); ;
+ break;}
+case 4:
+#line 236 "./expread.y"
+{ write_exp_elt_opcode (UNOP_IND); ;
+ break;}
+case 5:
+#line 239 "./expread.y"
+{ write_exp_elt_opcode (UNOP_ADDR); ;
+ break;}
+case 6:
+#line 242 "./expread.y"
+{ write_exp_elt_opcode (UNOP_NEG); ;
+ break;}
+case 7:
+#line 246 "./expread.y"
+{ write_exp_elt_opcode (UNOP_ZEROP); ;
+ break;}
+case 8:
+#line 250 "./expread.y"
+{ write_exp_elt_opcode (UNOP_LOGNOT); ;
+ break;}
+case 9:
+#line 254 "./expread.y"
+{ write_exp_elt_opcode (UNOP_PREINCREMENT); ;
+ break;}
+case 10:
+#line 258 "./expread.y"
+{ write_exp_elt_opcode (UNOP_PREDECREMENT); ;
+ break;}
+case 11:
+#line 262 "./expread.y"
+{ write_exp_elt_opcode (UNOP_POSTINCREMENT); ;
+ break;}
+case 12:
+#line 266 "./expread.y"
+{ write_exp_elt_opcode (UNOP_POSTDECREMENT); ;
+ break;}
+case 13:
+#line 270 "./expread.y"
+{ write_exp_elt_opcode (UNOP_SIZEOF); ;
+ break;}
+case 14:
+#line 274 "./expread.y"
+{ write_exp_elt_opcode (STRUCTOP_PTR);
+ write_exp_string (yyvsp[0].sval);
+ write_exp_elt_opcode (STRUCTOP_PTR); ;
+ break;}
+case 15:
+#line 280 "./expread.y"
+{ write_exp_elt_opcode (STRUCTOP_MPTR); ;
+ break;}
+case 16:
+#line 284 "./expread.y"
+{ write_exp_elt_opcode (STRUCTOP_STRUCT);
+ write_exp_string (yyvsp[0].sval);
+ write_exp_elt_opcode (STRUCTOP_STRUCT); ;
+ break;}
+case 17:
+#line 290 "./expread.y"
+{ write_exp_elt_opcode (STRUCTOP_MEMBER); ;
+ break;}
+case 18:
+#line 294 "./expread.y"
+{ write_exp_elt_opcode (BINOP_SUBSCRIPT); ;
+ break;}
+case 19:
+#line 300 "./expread.y"
+{ start_arglist (); ;
+ break;}
+case 20:
+#line 302 "./expread.y"
+{ write_exp_elt_opcode (OP_FUNCALL);
+ write_exp_elt_longcst ((LONGEST) end_arglist ());
+ write_exp_elt_opcode (OP_FUNCALL); ;
+ break;}
+case 22:
+#line 311 "./expread.y"
+{ arglist_len = 1; ;
+ break;}
+case 23:
+#line 315 "./expread.y"
+{ arglist_len++; ;
+ break;}
+case 24:
+#line 319 "./expread.y"
+{ write_exp_elt_opcode (UNOP_MEMVAL);
+ write_exp_elt_type (yyvsp[-2].tval);
+ write_exp_elt_opcode (UNOP_MEMVAL); ;
+ break;}
+case 25:
+#line 325 "./expread.y"
+{ write_exp_elt_opcode (UNOP_CAST);
+ write_exp_elt_type (yyvsp[-2].tval);
+ write_exp_elt_opcode (UNOP_CAST); ;
+ break;}
+case 26:
+#line 331 "./expread.y"
+{ ;
+ break;}
+case 27:
+#line 337 "./expread.y"
+{ write_exp_elt_opcode (BINOP_REPEAT); ;
+ break;}
+case 28:
+#line 341 "./expread.y"
+{ write_exp_elt_opcode (BINOP_MUL); ;
+ break;}
+case 29:
+#line 345 "./expread.y"
+{ write_exp_elt_opcode (BINOP_DIV); ;
+ break;}
+case 30:
+#line 349 "./expread.y"
+{ write_exp_elt_opcode (BINOP_REM); ;
+ break;}
+case 31:
+#line 353 "./expread.y"
+{ write_exp_elt_opcode (BINOP_ADD); ;
+ break;}
+case 32:
+#line 357 "./expread.y"
+{ write_exp_elt_opcode (BINOP_SUB); ;
+ break;}
+case 33:
+#line 361 "./expread.y"
+{ write_exp_elt_opcode (BINOP_LSH); ;
+ break;}
+case 34:
+#line 365 "./expread.y"
+{ write_exp_elt_opcode (BINOP_RSH); ;
+ break;}
+case 35:
+#line 369 "./expread.y"
+{ write_exp_elt_opcode (BINOP_EQUAL); ;
+ break;}
+case 36:
+#line 373 "./expread.y"
+{ write_exp_elt_opcode (BINOP_NOTEQUAL); ;
+ break;}
+case 37:
+#line 377 "./expread.y"
+{ write_exp_elt_opcode (BINOP_LEQ); ;
+ break;}
+case 38:
+#line 381 "./expread.y"
+{ write_exp_elt_opcode (BINOP_GEQ); ;
+ break;}
+case 39:
+#line 385 "./expread.y"
+{ write_exp_elt_opcode (BINOP_LESS); ;
+ break;}
+case 40:
+#line 389 "./expread.y"
+{ write_exp_elt_opcode (BINOP_GTR); ;
+ break;}
+case 41:
+#line 393 "./expread.y"
+{ write_exp_elt_opcode (BINOP_LOGAND); ;
+ break;}
+case 42:
+#line 397 "./expread.y"
+{ write_exp_elt_opcode (BINOP_LOGXOR); ;
+ break;}
+case 43:
+#line 401 "./expread.y"
+{ write_exp_elt_opcode (BINOP_LOGIOR); ;
+ break;}
+case 44:
+#line 405 "./expread.y"
+{ write_exp_elt_opcode (BINOP_AND); ;
+ break;}
+case 45:
+#line 409 "./expread.y"
+{ write_exp_elt_opcode (BINOP_OR); ;
+ break;}
+case 46:
+#line 413 "./expread.y"
+{ write_exp_elt_opcode (TERNOP_COND); ;
+ break;}
+case 47:
+#line 417 "./expread.y"
+{ write_exp_elt_opcode (BINOP_ASSIGN); ;
+ break;}
+case 48:
+#line 421 "./expread.y"
+{ write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
+ write_exp_elt_opcode (yyvsp[-1].opcode);
+ write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); ;
+ break;}
+case 49:
+#line 427 "./expread.y"
+{ write_exp_elt_opcode (OP_LONG);
+ if (yyvsp[0].lval == (int) yyvsp[0].lval || yyvsp[0].lval == (unsigned int) yyvsp[0].lval)
+ write_exp_elt_type (builtin_type_int);
+ else
+ write_exp_elt_type (BUILTIN_TYPE_LONGEST);
+ write_exp_elt_longcst ((LONGEST) yyvsp[0].lval);
+ write_exp_elt_opcode (OP_LONG); ;
+ break;}
+case 50:
+#line 437 "./expread.y"
+{ YYSTYPE val;
+ parse_number (yyvsp[0].ssym.stoken.ptr, yyvsp[0].ssym.stoken.length, 0, &val);
+ write_exp_elt_opcode (OP_LONG);
+ if (val.lval == (int) val.lval ||
+ val.lval == (unsigned int) val.lval)
+ write_exp_elt_type (builtin_type_int);
+ else
+ write_exp_elt_type (BUILTIN_TYPE_LONGEST);
+ write_exp_elt_longcst (val.lval);
+ write_exp_elt_opcode (OP_LONG); ;
+ break;}
+case 51:
+#line 450 "./expread.y"
+{
+ write_exp_elt_opcode (OP_LONG);
+ if (yyvsp[0].ulval == (unsigned int) yyvsp[0].ulval)
+ write_exp_elt_type (builtin_type_unsigned_int);
+ else
+ write_exp_elt_type (BUILTIN_TYPE_UNSIGNED_LONGEST);
+ write_exp_elt_longcst ((LONGEST) yyvsp[0].ulval);
+ write_exp_elt_opcode (OP_LONG);
+ ;
+ break;}
+case 52:
+#line 462 "./expread.y"
+{ YYSTYPE val;
+ parse_number (yyvsp[0].ssym.stoken.ptr, yyvsp[0].ssym.stoken.length, 0, &val);
+ write_exp_elt_opcode (OP_LONG);
+ if (val.ulval == (unsigned int) val.ulval)
+ write_exp_elt_type (builtin_type_unsigned_int);
+ else
+ write_exp_elt_type (BUILTIN_TYPE_UNSIGNED_LONGEST);
+ write_exp_elt_longcst ((LONGEST)val.ulval);
+ write_exp_elt_opcode (OP_LONG);
+ ;
+ break;}
+case 53:
+#line 475 "./expread.y"
+{ write_exp_elt_opcode (OP_LONG);
+ write_exp_elt_type (builtin_type_char);
+ write_exp_elt_longcst ((LONGEST) yyvsp[0].lval);
+ write_exp_elt_opcode (OP_LONG); ;
+ break;}
+case 54:
+#line 482 "./expread.y"
+{ write_exp_elt_opcode (OP_DOUBLE);
+ write_exp_elt_type (builtin_type_double);
+ write_exp_elt_dblcst (yyvsp[0].dval);
+ write_exp_elt_opcode (OP_DOUBLE); ;
+ break;}
+case 56:
+#line 492 "./expread.y"
+{ write_exp_elt_opcode (OP_LAST);
+ write_exp_elt_longcst ((LONGEST) yyvsp[0].lval);
+ write_exp_elt_opcode (OP_LAST); ;
+ break;}
+case 57:
+#line 498 "./expread.y"
+{ write_exp_elt_opcode (OP_REGISTER);
+ write_exp_elt_longcst ((LONGEST) yyvsp[0].lval);
+ write_exp_elt_opcode (OP_REGISTER); ;
+ break;}
+case 58:
+#line 504 "./expread.y"
+{ write_exp_elt_opcode (OP_INTERNALVAR);
+ write_exp_elt_intern (yyvsp[0].ivar);
+ write_exp_elt_opcode (OP_INTERNALVAR); ;
+ break;}
+case 59:
+#line 510 "./expread.y"
+{ write_exp_elt_opcode (OP_LONG);
+ write_exp_elt_type (builtin_type_int);
+ write_exp_elt_longcst ((LONGEST) TYPE_LENGTH (yyvsp[-1].tval));
+ write_exp_elt_opcode (OP_LONG); ;
+ break;}
+case 60:
+#line 517 "./expread.y"
+{ write_exp_elt_opcode (OP_STRING);
+ write_exp_string (yyvsp[0].sval);
+ write_exp_elt_opcode (OP_STRING); ;
+ break;}
+case 61:
+#line 524 "./expread.y"
+{ write_exp_elt_opcode (OP_THIS);
+ write_exp_elt_opcode (OP_THIS); ;
+ break;}
+case 62:
+#line 531 "./expread.y"
+{
+ if (yyvsp[0].ssym.sym != 0)
+ yyval.bval = SYMBOL_BLOCK_VALUE (yyvsp[0].ssym.sym);
+ else
+ {
+ struct symtab *tem =
+ lookup_symtab (copy_name (yyvsp[0].ssym.stoken));
+ if (tem)
+ yyval.bval = BLOCKVECTOR_BLOCK
+ (BLOCKVECTOR (tem), STATIC_BLOCK);
+ else
+ error ("No file or function \"%s\".",
+ copy_name (yyvsp[0].ssym.stoken));
+ }
+ ;
+ break;}
+case 63:
+#line 549 "./expread.y"
+{ struct symbol *tem
+ = lookup_symbol (copy_name (yyvsp[0].sval), yyvsp[-2].bval,
+ VAR_NAMESPACE, 0, NULL);
+ if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
+ error ("No function \"%s\" in specified context.",
+ copy_name (yyvsp[0].sval));
+ yyval.bval = SYMBOL_BLOCK_VALUE (tem); ;
+ break;}
+case 64:
+#line 559 "./expread.y"
+{ struct symbol *sym;
+ sym = lookup_symbol (copy_name (yyvsp[0].sval), yyvsp[-2].bval,
+ VAR_NAMESPACE, 0, NULL);
+ if (sym == 0)
+ error ("No symbol \"%s\" in specified context.",
+ copy_name (yyvsp[0].sval));
+ write_exp_elt_opcode (OP_VAR_VALUE);
+ write_exp_elt_sym (sym);
+ write_exp_elt_opcode (OP_VAR_VALUE); ;
+ break;}
+case 65:
+#line 571 "./expread.y"
+{
+ struct type *type = yyvsp[-2].tval;
+ if (TYPE_CODE (type) != TYPE_CODE_STRUCT
+ && TYPE_CODE (type) != TYPE_CODE_UNION)
+ error ("`%s' is not defined as an aggregate type.",
+ TYPE_NAME (type));
+
+ write_exp_elt_opcode (OP_SCOPE);
+ write_exp_elt_type (type);
+ write_exp_string (yyvsp[0].sval);
+ write_exp_elt_opcode (OP_SCOPE);
+ ;
+ break;}
+case 66:
+#line 584 "./expread.y"
+{
+ struct type *type = yyvsp[-3].tval;
+ if (TYPE_CODE (type) != TYPE_CODE_STRUCT
+ && TYPE_CODE (type) != TYPE_CODE_UNION)
+ error ("`%s' is not defined as an aggregate type.",
+ TYPE_NAME (type));
+
+ if (strcmp (type_name_no_tag (type), yyvsp[0].sval.ptr))
+ error ("invalid destructor `%s::~%s'",
+ type_name_no_tag (type), yyvsp[0].sval.ptr);
+
+ write_exp_elt_opcode (OP_SCOPE);
+ write_exp_elt_type (type);
+ write_exp_string (yyvsp[0].sval);
+ write_exp_elt_opcode (OP_SCOPE);
+ write_exp_elt_opcode (UNOP_LOGNOT);
+ ;
+ break;}
+case 67:
+#line 602 "./expread.y"
+{
+ char *name = copy_name (yyvsp[0].sval);
+ struct symbol *sym;
+ int i;
+
+ sym =
+ lookup_symbol (name, 0, VAR_NAMESPACE, 0, NULL);
+ if (sym)
+ {
+ write_exp_elt_opcode (OP_VAR_VALUE);
+ write_exp_elt_sym (sym);
+ write_exp_elt_opcode (OP_VAR_VALUE);
+ break;
+ }
+ for (i = 0; i < misc_function_count; i++)
+ if (!strcmp (misc_function_vector[i].name, name))
+ break;
+
+ if (i < misc_function_count)
+ {
+ enum misc_function_type mft =
+ misc_function_vector[i].type;
+
+ write_exp_elt_opcode (OP_LONG);
+ write_exp_elt_type (builtin_type_int);
+ write_exp_elt_longcst ((LONGEST) misc_function_vector[i].address);
+ write_exp_elt_opcode (OP_LONG);
+ write_exp_elt_opcode (UNOP_MEMVAL);
+ if (mft == mf_data || mft == mf_bss)
+ write_exp_elt_type (builtin_type_int);
+ else if (mft == mf_text)
+ write_exp_elt_type (lookup_function_type (builtin_type_int));
+ else
+ write_exp_elt_type (builtin_type_char);
+ write_exp_elt_opcode (UNOP_MEMVAL);
+ }
+ else
+ if (symtab_list == 0
+ && partial_symtab_list == 0)
+ error ("No symbol table is loaded. Use the \"file\" command.");
+ else
+ error ("No symbol \"%s\" in current context.", name);
+ ;
+ break;}
+case 68:
+#line 648 "./expread.y"
+{ struct symbol *sym = yyvsp[0].ssym.sym;
+
+ if (sym)
+ {
+ switch (sym->class)
+ {
+ case LOC_REGISTER:
+ case LOC_ARG:
+ case LOC_REF_ARG:
+ case LOC_REGPARM:
+ case LOC_LOCAL:
+ case LOC_LOCAL_ARG:
+ if (innermost_block == 0 ||
+ contained_in (block_found,
+ innermost_block))
+ innermost_block = block_found;
+ case LOC_UNDEF:
+ case LOC_CONST:
+ case LOC_STATIC:
+ case LOC_TYPEDEF:
+ case LOC_LABEL:
+ case LOC_BLOCK:
+ case LOC_CONST_BYTES:
+
+ /* In this case the expression can
+ be evaluated regardless of what
+ frame we are in, so there is no
+ need to check for the
+ innermost_block. These cases are
+ listed so that gcc -Wall will
+ report types that may not have
+ been considered. */
+
+ break;
+ }
+ write_exp_elt_opcode (OP_VAR_VALUE);
+ write_exp_elt_sym (sym);
+ write_exp_elt_opcode (OP_VAR_VALUE);
+ }
+ else if (yyvsp[0].ssym.is_a_field_of_this)
+ {
+ /* C++: it hangs off of `this'. Must
+ not inadvertently convert from a method call
+ to data ref. */
+ if (innermost_block == 0 ||
+ contained_in (block_found, innermost_block))
+ innermost_block = block_found;
+ write_exp_elt_opcode (OP_THIS);
+ write_exp_elt_opcode (OP_THIS);
+ write_exp_elt_opcode (STRUCTOP_PTR);
+ write_exp_string (yyvsp[0].ssym.stoken);
+ write_exp_elt_opcode (STRUCTOP_PTR);
+ }
+ else
+ {
+ register int i;
+ register char *arg = copy_name (yyvsp[0].ssym.stoken);
+
+ /* FIXME, this search is linear! At least
+ optimize the strcmp with a 1-char cmp... */
+ for (i = 0; i < misc_function_count; i++)
+ if (!strcmp (misc_function_vector[i].name, arg))
+ break;
+
+ if (i < misc_function_count)
+ {
+ enum misc_function_type mft =
+ misc_function_vector[i].type;
+
+ write_exp_elt_opcode (OP_LONG);
+ write_exp_elt_type (builtin_type_int);
+ write_exp_elt_longcst ((LONGEST) misc_function_vector[i].address);
+ write_exp_elt_opcode (OP_LONG);
+ write_exp_elt_opcode (UNOP_MEMVAL);
+ if (mft == mf_data || mft == mf_bss)
+ write_exp_elt_type (builtin_type_int);
+ else if (mft == mf_text)
+ write_exp_elt_type (lookup_function_type (builtin_type_int));
+ else
+ write_exp_elt_type (builtin_type_char);
+ write_exp_elt_opcode (UNOP_MEMVAL);
+ }
+ else if (symtab_list == 0
+ && partial_symtab_list == 0)
+ error ("No symbol table is loaded. Use the \"file\" command.");
+ else
+ error ("No symbol \"%s\" in current context.",
+ copy_name (yyvsp[0].ssym.stoken));
+ }
+ ;
+ break;}
+case 70:
+#line 743 "./expread.y"
+{
+ /* This is where the interesting stuff happens. */
+ int done = 0;
+ int array_size;
+ struct type *follow_type = yyvsp[-1].tval;
+
+ while (!done)
+ switch (pop_type ())
+ {
+ case tp_end:
+ done = 1;
+ break;
+ case tp_pointer:
+ follow_type = lookup_pointer_type (follow_type);
+ break;
+ case tp_reference:
+ follow_type = lookup_reference_type (follow_type);
+ break;
+ case tp_array:
+ array_size = pop_type_int ();
+ if (array_size != -1)
+ follow_type = create_array_type (follow_type,
+ array_size);
+ else
+ follow_type = lookup_pointer_type (follow_type);
+ break;
+ case tp_function:
+ follow_type = lookup_function_type (follow_type);
+ break;
+ }
+ yyval.tval = follow_type;
+ ;
+ break;}
+case 71:
+#line 778 "./expread.y"
+{ push_type (tp_pointer); yyval.voidval = 0; ;
+ break;}
+case 72:
+#line 780 "./expread.y"
+{ push_type (tp_pointer); yyval.voidval = yyvsp[0].voidval; ;
+ break;}
+case 73:
+#line 782 "./expread.y"
+{ push_type (tp_reference); yyval.voidval = 0; ;
+ break;}
+case 74:
+#line 784 "./expread.y"
+{ push_type (tp_reference); yyval.voidval = yyvsp[0].voidval; ;
+ break;}
+case 76:
+#line 789 "./expread.y"
+{ yyval.voidval = yyvsp[-1].voidval; ;
+ break;}
+case 77:
+#line 791 "./expread.y"
+{
+ push_type_int (yyvsp[0].lval);
+ push_type (tp_array);
+ ;
+ break;}
+case 78:
+#line 796 "./expread.y"
+{
+ push_type_int (yyvsp[0].lval);
+ push_type (tp_array);
+ yyval.voidval = 0;
+ ;
+ break;}
+case 79:
+#line 802 "./expread.y"
+{ push_type (tp_function); ;
+ break;}
+case 80:
+#line 804 "./expread.y"
+{ push_type (tp_function); ;
+ break;}
+case 81:
+#line 808 "./expread.y"
+{ yyval.lval = -1; ;
+ break;}
+case 82:
+#line 810 "./expread.y"
+{ yyval.lval = yyvsp[-1].lval; ;
+ break;}
+case 83:
+#line 814 "./expread.y"
+{ yyval.voidval = 0; ;
+ break;}
+case 85:
+#line 819 "./expread.y"
+{ yyval.tval = lookup_member_type (builtin_type_int, yyvsp[-2].tval); ;
+ break;}
+case 86:
+#line 821 "./expread.y"
+{ yyval.tval = lookup_member_type (yyvsp[-5].tval, yyvsp[-3].tval); ;
+ break;}
+case 87:
+#line 823 "./expread.y"
+{ yyval.tval = lookup_member_type
+ (lookup_function_type (yyvsp[-7].tval), yyvsp[-5].tval); ;
+ break;}
+case 88:
+#line 826 "./expread.y"
+{ yyval.tval = lookup_member_type
+ (lookup_function_type (yyvsp[-8].tval), yyvsp[-6].tval);
+ free (yyvsp[-1].tvec); ;
+ break;}
+case 89:
+#line 833 "./expread.y"
+{ yyval.tval = yyvsp[0].tsym.type; ;
+ break;}
+case 90:
+#line 835 "./expread.y"
+{ yyval.tval = builtin_type_int; ;
+ break;}
+case 91:
+#line 837 "./expread.y"
+{ yyval.tval = builtin_type_long; ;
+ break;}
+case 92:
+#line 839 "./expread.y"
+{ yyval.tval = builtin_type_short; ;
+ break;}
+case 93:
+#line 841 "./expread.y"
+{ yyval.tval = builtin_type_long; ;
+ break;}
+case 94:
+#line 843 "./expread.y"
+{ yyval.tval = builtin_type_unsigned_long; ;
+ break;}
+case 95:
+#line 845 "./expread.y"
+{ yyval.tval = builtin_type_long_long; ;
+ break;}
+case 96:
+#line 847 "./expread.y"
+{ yyval.tval = builtin_type_long_long; ;
+ break;}
+case 97:
+#line 849 "./expread.y"
+{ yyval.tval = builtin_type_unsigned_long_long; ;
+ break;}
+case 98:
+#line 851 "./expread.y"
+{ yyval.tval = builtin_type_unsigned_long_long; ;
+ break;}
+case 99:
+#line 853 "./expread.y"
+{ yyval.tval = builtin_type_short; ;
+ break;}
+case 100:
+#line 855 "./expread.y"
+{ yyval.tval = builtin_type_unsigned_short; ;
+ break;}
+case 101:
+#line 857 "./expread.y"
+{ yyval.tval = lookup_struct (copy_name (yyvsp[0].sval),
+ expression_context_block); ;
+ break;}
+case 102:
+#line 860 "./expread.y"
+{ yyval.tval = lookup_union (copy_name (yyvsp[0].sval),
+ expression_context_block); ;
+ break;}
+case 103:
+#line 863 "./expread.y"
+{ yyval.tval = lookup_enum (copy_name (yyvsp[0].sval),
+ expression_context_block); ;
+ break;}
+case 104:
+#line 866 "./expread.y"
+{ yyval.tval = lookup_unsigned_typename (TYPE_NAME(yyvsp[0].tsym.type)); ;
+ break;}
+case 105:
+#line 868 "./expread.y"
+{ yyval.tval = builtin_type_unsigned_int; ;
+ break;}
+case 106:
+#line 870 "./expread.y"
+{ yyval.tval = yyvsp[0].tsym.type; ;
+ break;}
+case 107:
+#line 872 "./expread.y"
+{ yyval.tval = builtin_type_int; ;
+ break;}
+case 109:
+#line 877 "./expread.y"
+{
+ yyval.tsym.stoken.ptr = "int";
+ yyval.tsym.stoken.length = 3;
+ yyval.tsym.type = builtin_type_int;
+ ;
+ break;}
+case 110:
+#line 883 "./expread.y"
+{
+ yyval.tsym.stoken.ptr = "long";
+ yyval.tsym.stoken.length = 4;
+ yyval.tsym.type = builtin_type_long;
+ ;
+ break;}
+case 111:
+#line 889 "./expread.y"
+{
+ yyval.tsym.stoken.ptr = "short";
+ yyval.tsym.stoken.length = 5;
+ yyval.tsym.type = builtin_type_short;
+ ;
+ break;}
+case 112:
+#line 898 "./expread.y"
+{ yyval.tvec = (struct type **)xmalloc (sizeof (struct type *) * 2);
+ yyval.tvec[0] = (struct type *)0;
+ yyval.tvec[1] = yyvsp[0].tval;
+ ;
+ break;}
+case 113:
+#line 903 "./expread.y"
+{ int len = sizeof (struct type *) * ++(yyvsp[-2].ivec[0]);
+ yyval.tvec = (struct type **)xrealloc (yyvsp[-2].tvec, len);
+ yyval.tvec[yyval.ivec[0]] = yyvsp[0].tval;
+ ;
+ break;}
+case 114:
+#line 909 "./expread.y"
+{ yyval.sval = yyvsp[0].ssym.stoken; ;
+ break;}
+case 115:
+#line 910 "./expread.y"
+{ yyval.sval = yyvsp[0].ssym.stoken; ;
+ break;}
+case 116:
+#line 911 "./expread.y"
+{ yyval.sval = yyvsp[0].tsym.stoken; ;
+ break;}
+case 117:
+#line 912 "./expread.y"
+{ yyval.sval = yyvsp[0].ssym.stoken; ;
+ break;}
+case 118:
+#line 913 "./expread.y"
+{ yyval.sval = yyvsp[0].ssym.stoken; ;
+ break;}
+}
+ /* the action file gets copied in in place of this dollarsign */
+#line 423 "/usr/latest/lib/bison.simple"
+\f
+ yyvsp -= yylen;
+ yyssp -= yylen;
+#ifdef YYLSP_NEEDED
+ yylsp -= yylen;
+#endif
+
+#if YYDEBUG != 0
+ if (yydebug)
+ {
+ short *ssp1 = yyss - 1;
+ fprintf (stderr, "state stack now");
+ while (ssp1 != yyssp)
+ fprintf (stderr, " %d", *++ssp1);
+ fprintf (stderr, "\n");
+ }
+#endif
+
+ *++yyvsp = yyval;
+
+#ifdef YYLSP_NEEDED
+ yylsp++;
+ if (yylen == 0)
+ {
+ yylsp->first_line = yylloc.first_line;
+ yylsp->first_column = yylloc.first_column;
+ yylsp->last_line = (yylsp-1)->last_line;
+ yylsp->last_column = (yylsp-1)->last_column;
+ yylsp->text = 0;
+ }
+ else
+ {
+ yylsp->last_line = (yylsp+yylen-1)->last_line;
+ yylsp->last_column = (yylsp+yylen-1)->last_column;
+ }
+#endif
+
+ /* Now "shift" the result of the reduction.
+ Determine what state that goes to,
+ based on the state we popped back to
+ and the rule number reduced by. */
+
+ yyn = yyr1[yyn];
+
+ yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
+ if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+ yystate = yytable[yystate];
+ else
+ yystate = yydefgoto[yyn - YYNTBASE];
+
+ goto yynewstate;
+
+yyerrlab: /* here on detecting error */
+
+ if (! yyerrstatus)
+ /* If not already recovering from an error, report this error. */
+ {
+ ++yynerrs;
+
+#ifdef YYERROR_VERBOSE
+ yyn = yypact[yystate];
+
+ if (yyn > YYFLAG && yyn < YYLAST)
+ {
+ int size = 0;
+ char *msg;
+ int x, count;
+
+ count = 0;
+ for (x = 0; x < (sizeof(yytname) / sizeof(char *)); x++)
+ if (yycheck[x + yyn] == x)
+ size += strlen(yytname[x]) + 15, count++;
+ msg = (char *) xmalloc(size + 15);
+ strcpy(msg, "parse error");
+
+ if (count < 5)
+ {
+ count = 0;
+ for (x = 0; x < (sizeof(yytname) / sizeof(char *)); x++)
+ if (yycheck[x + yyn] == x)
+ {
+ strcat(msg, count == 0 ? ", expecting `" : " or `");
+ strcat(msg, yytname[x]);
+ strcat(msg, "'");
+ count++;
+ }
+ }
+ yyerror(msg);
+ free(msg);
+ }
+ else
+#endif /* YYERROR_VERBOSE */
+ yyerror("parse error");
+ }
+
+yyerrlab1: /* here on error raised explicitly by an action */
+
+ if (yyerrstatus == 3)
+ {
+ /* if just tried and failed to reuse lookahead token after an error, discard it. */
+
+ /* return failure if at end of input */
+ if (yychar == YYEOF)
+ YYABORT;
+
+#if YYDEBUG != 0
+ if (yydebug)
+ fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
+#endif
+
+ yychar = YYEMPTY;
+ }
+
+ /* Else will try to reuse lookahead token
+ after shifting the error token. */
+
+ yyerrstatus = 3; /* Each real token shifted decrements this */
+
+ goto yyerrhandle;
+
+yyerrdefault: /* current state does not do anything special for the error token. */
+
+#if 0
+ /* This is wrong; only states that explicitly want error tokens
+ should shift them. */
+ yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
+ if (yyn) goto yydefault;
+#endif
+
+yyerrpop: /* pop the current state because it cannot handle the error token */
+
+ if (yyssp == yyss) YYABORT;
+ yyvsp--;
+ yystate = *--yyssp;
+#ifdef YYLSP_NEEDED
+ yylsp--;
+#endif
+
+#if YYDEBUG != 0
+ if (yydebug)
+ {
+ short *ssp1 = yyss - 1;
+ fprintf (stderr, "Error: state stack now");
+ while (ssp1 != yyssp)
+ fprintf (stderr, " %d", *++ssp1);
+ fprintf (stderr, "\n");
+ }
+#endif
+
+yyerrhandle:
+
+ yyn = yypact[yystate];
+ if (yyn == YYFLAG)
+ goto yyerrdefault;
+
+ yyn += YYTERROR;
+ if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
+ goto yyerrdefault;
+
+ yyn = yytable[yyn];
+ if (yyn < 0)
+ {
+ if (yyn == YYFLAG)
+ goto yyerrpop;
+ yyn = -yyn;
+ goto yyreduce;
+ }
+ else if (yyn == 0)
+ goto yyerrpop;
+
+ if (yyn == YYFINAL)
+ YYACCEPT;
+
+#if YYDEBUG != 0
+ if (yydebug)
+ fprintf(stderr, "Shifting error token, ");
+#endif
+
+ *++yyvsp = yylval;
+#ifdef YYLSP_NEEDED
+ *++yylsp = yylloc;
+#endif
+
+ yystate = yyn;
+ goto yynewstate;
+}
+#line 928 "./expread.y"
\f
/* Begin counting arguments for a function call,
/* Add one element to the end of the expression. */
-/* To avoid a bug in the Sun 4 compiler, we pass only things that
- can fit into a single register through here. */
+/* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
+ a register through here */
+
static void
write_exp_elt (expelt)
- /* union exp_element expelt; */
- long expelt;
+ union exp_element expelt;
{
- union exp_element temp;
- temp.longconst = expelt;
-
if (expout_ptr >= expout_size)
{
expout_size *= 2;
sizeof (struct expression)
+ expout_size * sizeof (union exp_element));
}
- expout->elts[expout_ptr++] = /* expelt */ temp;
+ expout->elts[expout_ptr++] = expelt;
+}
+
+static void
+write_exp_elt_opcode (expelt)
+ enum exp_opcode expelt;
+{
+ union exp_element tmp;
+
+ tmp.opcode = expelt;
+
+ write_exp_elt (tmp);
}
-/* Things that take more space must come through here. */
static void
-write_exp_elt2 (expelt)
+write_exp_elt_sym (expelt)
+ struct symbol *expelt;
+{
+ union exp_element tmp;
+
+ tmp.symbol = expelt;
+
+ write_exp_elt (tmp);
+}
+
+static void
+write_exp_elt_longcst (expelt)
+ LONGEST expelt;
+{
+ union exp_element tmp;
+
+ tmp.longconst = expelt;
+
+ write_exp_elt (tmp);
+}
+
+static void
+write_exp_elt_dblcst (expelt)
double expelt;
{
- union exp_element temp;
- temp.doubleconst = expelt;
+ union exp_element tmp;
- if (expout_ptr >= expout_size)
- {
- expout_size *= 2;
- expout = (struct expression *) xrealloc (expout,
- sizeof (struct expression)
- + expout_size * sizeof (union exp_element));
- }
- expout->elts[expout_ptr++] = temp;
+ tmp.doubleconst = expelt;
+
+ write_exp_elt (tmp);
+}
+
+static void
+write_exp_elt_type (expelt)
+ struct type *expelt;
+{
+ union exp_element tmp;
+
+ tmp.type = expelt;
+
+ write_exp_elt (tmp);
+}
+
+static void
+write_exp_elt_intern (expelt)
+ struct internalvar *expelt;
+{
+ union exp_element tmp;
+
+ tmp.internalvar = expelt;
+
+ write_exp_elt (tmp);
}
/* Add a string constant to the end of the expression.
if (expout_ptr >= expout_size)
{
expout_size = max (expout_size * 2, expout_ptr + 10);
- expout = (struct expression *) xrealloc (expout,
- sizeof (struct expression)
- + expout_size * sizeof (union exp_element));
+ expout = (struct expression *)
+ xrealloc (expout, (sizeof (struct expression)
+ + (expout_size * sizeof (union exp_element))));
}
bcopy (str.ptr, (char *) &expout->elts[expout_ptr - lenelt], len);
((char *) &expout->elts[expout_ptr - lenelt])[len] = 0;
- write_exp_elt (len);
+ write_exp_elt_longcst ((LONGEST) len);
}
\f
/* During parsing of a C expression, the pointer to the next character
/*** Needs some error checking for the float case ***/
static int
-parse_number (olen)
- int olen;
+parse_number (p, len, parsed_float, putithere)
+ register char *p;
+ register int len;
+ int parsed_float;
+ YYSTYPE *putithere;
{
- register char *p = lexptr;
- register long n = 0;
+ register LONGEST n = 0;
+ register int i;
register int c;
- register int base = 10;
- register int len = olen;
- char *err_copy;
+ register int base = input_radix;
+ int unsigned_p = 0;
extern double atof ();
- for (c = 0; c < len; c++)
- if (p[c] == '.')
- {
- /* It's a float since it contains a point. */
- yylval.dval = atof (p);
- lexptr += len;
- return FLOAT;
+ if (parsed_float)
+ {
+ /* It's a float since it contains a point or an exponent. */
+ putithere->dval = atof (p);
+ return FLOAT;
+ }
+
+ /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
+ if (p[0] == '0')
+ switch (p[1])
+ {
+ case 'x':
+ case 'X':
+ if (len >= 3)
+ {
+ p += 2;
+ base = 16;
+ len -= 2;
+ }
+ break;
+
+ case 't':
+ case 'T':
+ case 'd':
+ case 'D':
+ if (len >= 3)
+ {
+ p += 2;
+ base = 10;
+ len -= 2;
+ }
+ break;
+
+ default:
+ base = 8;
+ break;
}
- if (len >= 3 && (!strncmp (p, "0x", 2) || !strncmp (p, "0X", 2)))
- {
- p += 2;
- base = 16;
- len -= 2;
- }
- else if (*p == '0')
- base = 8;
-
while (len-- > 0)
{
c = *p++;
- n *= base;
+ if (c >= 'A' && c <= 'Z')
+ c += 'a' - 'A';
+ if (c != 'l' && c != 'u')
+ n *= base;
if (c >= '0' && c <= '9')
- n += c - '0';
+ n += i = c - '0';
else
{
- if (c >= 'A' && c <= 'Z') c += 'a' - 'A';
- if (base == 16 && c >= 'a' && c <= 'f')
- n += c - 'a' + 10;
+ if (base > 10 && c >= 'a' && c <= 'f')
+ n += i = c - 'a' + 10;
else if (len == 0 && c == 'l')
;
+ else if (len == 0 && c == 'u')
+ unsigned_p = 1;
else
- {
- err_copy = (char *) alloca (olen + 1);
- bcopy (lexptr, err_copy, olen);
- err_copy[olen] = 0;
- error ("Invalid number \"%s\".", err_copy);
- }
+ return ERROR; /* Char not a digit */
}
+ if (i >= base)
+ return ERROR; /* Invalid digit in this base */
}
- lexptr = p;
- yylval.lval = n;
- return INT;
+ if (unsigned_p)
+ {
+ putithere->ulval = n;
+ return UINT;
+ }
+ else
+ {
+ putithere->lval = n;
+ return INT;
+ }
}
struct token
enum exp_opcode opcode;
};
-static struct token tokentab3[] =
+const static struct token tokentab3[] =
{
{">>=", ASSIGN_MODIFY, BINOP_RSH},
{"<<=", ASSIGN_MODIFY, BINOP_LSH}
};
-static struct token tokentab2[] =
+const static struct token tokentab2[] =
{
{"+=", ASSIGN_MODIFY, BINOP_ADD},
{"-=", ASSIGN_MODIFY, BINOP_SUB},
{">=", GEQ, BINOP_END}
};
+/* assign machine-independent names to certain registers
+ * (unless overridden by the REGISTER_NAMES table)
+ */
+struct std_regs {
+ char *name;
+ int regnum;
+} std_regs[] = {
+#ifdef PC_REGNUM
+ { "pc", PC_REGNUM },
+#endif
+#ifdef FP_REGNUM
+ { "fp", FP_REGNUM },
+#endif
+#ifdef SP_REGNUM
+ { "sp", SP_REGNUM },
+#endif
+#ifdef PS_REGNUM
+ { "ps", PS_REGNUM },
+#endif
+};
+
+#define NUM_STD_REGS (sizeof std_regs / sizeof std_regs[0])
+
/* Read one token, getting characters through lexptr. */
static int
{
register int c;
register int namelen;
- register int i;
+ register unsigned i;
register char *tokstart;
retry:
lexptr++;
return c;
+ case '.':
+ /* Might be a floating point number. */
+ if (lexptr[1] < '0' || lexptr[1] > '9')
+ goto symbol; /* Nope, must be a symbol. */
+ /* FALL THRU into number case. */
+
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ {
+ /* It's a number. */
+ int got_dot = 0, got_e = 0, toktype;
+ register char *p = tokstart;
+ int hex = input_radix > 10;
+
+ if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
+ {
+ p += 2;
+ hex = 1;
+ }
+ else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
+ {
+ p += 2;
+ hex = 0;
+ }
+
+ for (;; ++p)
+ {
+ if (!hex && !got_e && (*p == 'e' || *p == 'E'))
+ got_dot = got_e = 1;
+ else if (!hex && !got_dot && *p == '.')
+ got_dot = 1;
+ else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
+ && (*p == '-' || *p == '+'))
+ /* This is the sign of the exponent, not the end of the
+ number. */
+ continue;
+ /* We will take any letters or digits. parse_number will
+ complain if past the radix, or if L or U are not final. */
+ else if ((*p < '0' || *p > '9')
+ && ((*p < 'a' || *p > 'z')
+ && (*p < 'A' || *p > 'Z')))
+ break;
+ }
+ toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
+ if (toktype == ERROR)
+ {
+ char *err_copy = (char *) alloca (p - tokstart + 1);
+
+ bcopy (tokstart, err_copy, p - tokstart);
+ err_copy[p - tokstart] = 0;
+ error ("Invalid number \"%s\".", err_copy);
+ }
+ lexptr = p;
+ return toktype;
+ }
+
case '+':
case '-':
case '*':
case '>':
case '[':
case ']':
- case '.':
case '?':
case ':':
case '=':
case '{':
case '}':
+ symbol:
lexptr++;
return c;
lexptr += namelen + 1;
return STRING;
}
- if (c >= '0' && c <= '9')
- {
- /* It's a number */
- for (namelen = 0;
- c = tokstart[namelen],
- (c == '_' || c == '$' || c == '.' || (c >= '0' && c <= '9')
- || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
- namelen++)
- ;
- return parse_number (namelen);
- }
if (!(c == '_' || c == '$'
|| (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
- error ("Invalid token in expression.");
+ /* We must have come across a bad character (e.g. ';'). */
+ error ("Invalid character '%c' in expression.", c);
- /* It is a name. See how long it is. */
-
- for (namelen = 0;
- c = tokstart[namelen],
+ /* It's a name. See how long it is. */
+ namelen = 0;
+ for (c = tokstart[namelen];
(c == '_' || c == '$' || (c >= '0' && c <= '9')
|| (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
- namelen++)
+ c = tokstart[++namelen])
;
/* The token "if" terminates the expression and is NOT
/* Handle tokens that refer to machine registers:
$ followed by a register name. */
- if (*tokstart == '$')
+ if (*tokstart == '$') {
for (c = 0; c < NUM_REGS; c++)
if (namelen - 1 == strlen (reg_names[c])
&& !strncmp (tokstart + 1, reg_names[c], namelen - 1))
yylval.lval = c;
return REGNAME;
}
-
- if (namelen == 6 && !strncmp (tokstart, "struct", 6))
- {
- return STRUCT;
- }
- if (namelen == 5)
+ for (c = 0; c < NUM_STD_REGS; c++)
+ if (namelen - 1 == strlen (std_regs[c].name)
+ && !strncmp (tokstart + 1, std_regs[c].name, namelen - 1))
+ {
+ yylval.lval = std_regs[c].regnum;
+ return REGNAME;
+ }
+ }
+ /* Catch specific keywords. Should be done with a data structure. */
+ switch (namelen)
{
+ case 8:
+ if (!strncmp (tokstart, "unsigned", 8))
+ return UNSIGNED;
+ break;
+ case 6:
+ if (!strncmp (tokstart, "struct", 6))
+ return STRUCT;
+ if (!strncmp (tokstart, "signed", 6))
+ return SIGNED;
+ if (!strncmp (tokstart, "sizeof", 6))
+ return SIZEOF;
+ break;
+ case 5:
if (!strncmp (tokstart, "union", 5))
- {
- return UNION;
- }
- }
- if (namelen == 4)
- {
+ return UNION;
+ if (!strncmp (tokstart, "short", 5))
+ return SHORT;
+ break;
+ case 4:
if (!strncmp (tokstart, "enum", 4))
- {
- return ENUM;
- }
+ return ENUM;
+ if (!strncmp (tokstart, "long", 4))
+ return LONG;
if (!strncmp (tokstart, "this", 4))
{
- return THIS;
+ static const char this_name[] =
+ { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' };
+
+ if (lookup_symbol (this_name, expression_context_block,
+ VAR_NAMESPACE, 0, NULL))
+ return THIS;
}
+ break;
+ case 3:
+ if (!strncmp (tokstart, "int", 3))
+ return INT_KEYWORD;
+ break;
+ default:
+ break;
}
- if (namelen == 6 && !strncmp (tokstart, "sizeof", 6))
- {
- return SIZEOF;
- }
- if (namelen == 8 && !strncmp (tokstart, "unsigned", 6))
- {
- return UNSIGNED;
- }
+
yylval.sval.ptr = tokstart;
yylval.sval.length = namelen;
if (*tokstart == '$')
{
- yylval.ivar = (struct internalvar *) lookup_internalvar (copy_name (yylval.sval) + 1);
+ yylval.ivar = lookup_internalvar (copy_name (yylval.sval) + 1);
return VARIABLE;
}
- /* Use token-type TYPENAME for symbols that happen to be defined
+ /* Use token-type BLOCKNAME for symbols that happen to be defined as
+ functions or symtabs. If this is not so, then ...
+ Use token-type TYPENAME for symbols that happen to be defined
currently as names of types; NAME for other symbols.
The caller is not constrained to care about the distinction. */
- if (lookup_typename (copy_name (yylval.sval), expression_context_block, 1))
- return TYPENAME;
- return NAME;
+ {
+ char *tmp = copy_name (yylval.sval);
+ struct symbol *sym;
+ int is_a_field_of_this = 0;
+ int hextype;
+
+ sym = lookup_symbol (tmp, expression_context_block,
+ VAR_NAMESPACE, &is_a_field_of_this, NULL);
+ if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) ||
+ lookup_partial_symtab (tmp))
+ {
+ yylval.ssym.sym = sym;
+ yylval.ssym.is_a_field_of_this = is_a_field_of_this;
+ return BLOCKNAME;
+ }
+ if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
+ {
+ yylval.tsym.type = SYMBOL_TYPE (sym);
+ return TYPENAME;
+ }
+ if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)
+ return TYPENAME;
+
+ /* Input names that aren't symbols but ARE valid hex numbers,
+ when the input radix permits them, can be names or numbers
+ depending on the parse. Note we support radixes > 16 here. */
+ if (!sym &&
+ ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
+ (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
+ {
+ YYSTYPE newlval; /* Its value is ignored. */
+ hextype = parse_number (tokstart, namelen, 0, &newlval);
+ if (hextype == INT)
+ {
+ yylval.ssym.sym = sym;
+ yylval.ssym.is_a_field_of_this = is_a_field_of_this;
+ return NAME_OR_INT;
+ }
+ if (hextype == UINT)
+ {
+ yylval.ssym.sym = sym;
+ yylval.ssym.is_a_field_of_this = is_a_field_of_this;
+ return NAME_OR_UINT;
+ }
+ }
+
+ /* Any other kind of symbol */
+ yylval.ssym.sym = sym;
+ yylval.ssym.is_a_field_of_this = is_a_field_of_this;
+ return NAME;
+ }
}
-static
-yyerror ()
+static void
+yyerror (msg)
+ char *msg;
{
error ("Invalid syntax in expression.");
}
parse_c_1 (stringptr, block, comma)
char **stringptr;
struct block *block;
+ int comma;
{
struct cleanup *old_chain;
lexptr = *stringptr;
+ paren_depth = 0;
+ type_stack_depth = 0;
+
comma_terminates = comma;
if (lexptr == 0 || *lexptr == 0)
namecopy = (char *) alloca (strlen (lexptr) + 1);
expout_size = 10;
expout_ptr = 0;
- expout = (struct expression *) xmalloc (sizeof (struct expression)
- + expout_size * sizeof (union exp_element));
+ expout = (struct expression *)
+ xmalloc (sizeof (struct expression)
+ + expout_size * sizeof (union exp_element));
make_cleanup (free_current_contents, &expout);
if (yyparse ())
- yyerror ();
+ yyerror (NULL);
discard_cleanups (old_chain);
expout->nelts = expout_ptr;
expout = (struct expression *)
error ("Junk after end of expression.");
return exp;
}
-short yyexca[] ={
--1, 1,
- 0, -1,
- -2, 0,
--1, 26,
- 268, 79,
- -2, 64,
--1, 124,
- 268, 60,
- -2, 61,
- };
-# define YYNPROD 81
-# define YYLAST 696
-short yyact[]={
-
- 43, 54, 140, 39, 123, 41, 44, 120, 45, 37,
- 42, 78, 77, 73, 39, 29, 30, 31, 142, 32,
- 37, 131, 33, 52, 60, 53, 59, 40, 80, 81,
- 143, 148, 33, 135, 149, 43, 54, 59, 39, 135,
- 41, 44, 71, 45, 37, 42, 137, 129, 122, 138,
- 90, 33, 144, 92, 38, 23, 74, 55, 52, 60,
- 53, 59, 40, 146, 118, 38, 119, 88, 117, 17,
- 43, 54, 1, 39, 0, 41, 44, 0, 45, 37,
- 42, 128, 118, 0, 119, 0, 117, 56, 0, 38,
- 0, 0, 55, 52, 0, 53, 59, 40, 7, 0,
- 0, 75, 2, 5, 0, 13, 0, 4, 0, 0,
- 6, 43, 54, 115, 39, 0, 41, 44, 0, 45,
- 37, 42, 56, 0, 38, 0, 118, 55, 119, 132,
- 117, 0, 0, 0, 52, 0, 53, 59, 40, 7,
- 91, 0, 0, 0, 5, 0, 70, 0, 4, 0,
- 0, 6, 0, 43, 54, 0, 39, 56, 41, 44,
- 0, 45, 37, 42, 0, 38, 0, 0, 55, 116,
- 118, 0, 119, 121, 117, 0, 52, 0, 53, 59,
- 40, 0, 0, 0, 0, 0, 0, 147, 12, 0,
- 0, 8, 150, 0, 145, 0, 43, 54, 56, 39,
- 0, 41, 44, 0, 45, 37, 42, 38, 0, 0,
- 55, 0, 0, 0, 0, 0, 0, 0, 0, 52,
- 0, 53, 59, 40, 0, 0, 0, 0, 0, 12,
- 39, 0, 8, 0, 0, 61, 37, 0, 58, 57,
- 48, 49, 50, 51, 46, 47, 0, 34, 35, 36,
- 38, 80, 81, 59, 40, 0, 0, 0, 34, 35,
- 36, 0, 43, 0, 0, 39, 0, 41, 80, 81,
- 61, 37, 42, 58, 57, 48, 49, 50, 51, 46,
- 47, 38, 34, 35, 36, 80, 81, 0, 59, 40,
- 0, 0, 0, 0, 43, 0, 0, 39, 0, 41,
- 44, 0, 45, 37, 42, 0, 0, 0, 0, 57,
- 48, 49, 50, 51, 46, 47, 38, 34, 35, 36,
- 59, 40, 14, 15, 16, 26, 28, 21, 29, 30,
- 31, 11, 32, 25, 18, 19, 20, 0, 22, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 38, 9,
- 10, 48, 49, 50, 51, 46, 47, 0, 34, 35,
- 36, 0, 0, 14, 15, 16, 26, 28, 21, 29,
- 30, 31, 11, 32, 25, 18, 19, 20, 43, 22,
- 0, 39, 0, 41, 44, 0, 45, 37, 42, 0,
- 9, 10, 0, 48, 49, 50, 51, 46, 47, 0,
- 34, 35, 36, 43, 59, 40, 39, 0, 41, 44,
- 24, 45, 37, 42, 73, 0, 29, 30, 31, 0,
- 32, 0, 0, 72, 76, 0, 52, 0, 53, 59,
- 40, 0, 38, 0, 0, 0, 48, 49, 50, 51,
- 46, 47, 0, 34, 35, 36, 43, 0, 0, 39,
- 0, 41, 44, 27, 45, 37, 42, 38, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 52,
- 0, 53, 59, 40, 34, 35, 36, 0, 0, 79,
- 0, 76, 0, 82, 83, 84, 85, 0, 0, 0,
- 87, 89, 0, 0, 0, 0, 0, 0, 0, 0,
- 38, 0, 0, 0, 0, 0, 0, 0, 0, 34,
- 35, 36, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 134, 124, 125, 0, 0, 0, 0, 0, 46, 47,
- 3, 34, 35, 36, 0, 62, 63, 64, 65, 66,
- 67, 68, 69, 0, 0, 72, 0, 0, 0, 0,
- 72, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 86, 0, 0, 125, 0, 0,
- 0, 93, 94, 95, 96, 97, 98, 99, 100, 101,
- 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
- 112, 113, 114, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 34, 35, 36, 0, 126,
- 0, 127, 0, 130, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 48, 49, 50, 51, 46, 47, 0,
- 34, 35, 36, 0, 0, 0, 0, 133, 0, 0,
- 0, 0, 136, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 139, 136, 0, 0, 0, 0, 0, 141,
- 0, 0, 0, 0, 0, 0, 0, 0, 50, 51,
- 46, 47, 0, 34, 35, 36 };
-short yypact[]={
-
- 65,-1000, -22, -2, 65, 65, 65, 65, 65, 65,
- 65, 106,-248, 65,-1000,-1000,-1000,-1000,-1000,-1000,
--1000,-1000,-1000,-256,-257,-232,-1000,-1000,-1000,-232,
--232,-232,-232, 65,-1000,-1000, 25, 8, 65,-1000,
- 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
- 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
- 65, 65, -26, -26, -26, -26, -26, -26, -26, -26,
- 65, 44,-261,-1000, 132, 7,-264,-232,-232,-1000,
--1000,-1000,-1000,-1000,-1000,-1000, -2,-1000, 65,-1000,
- 65, -12, 65, -26, 190, 190, 190, 225, 225, 341,
- 341, 409, 409, 257, 257, 257, 257, 366, 159, 116,
- 74, 33, -37, -2, -2, 88, 65,-1000,-1000,-248,
- -3, 65,-1000, -9,-1000,-1000, 190, 190,-1000, 5,
- -2, 65, 65, -26,-266,-1000, -26,-1000, 65, -2,
- -24, -2, -11, 12, 153,-1000, -10, 26,-1000,-248,
- 26 };
-short yypgo[]={
-
- 0, 540, 101, 72, 69, 42, 410, 63, 55, 453,
- 53, 47 };
-short yyr1[]={
-
- 0, 3, 2, 2, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 10,
- 1, 11, 11, 11, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 8,
- 8, 4, 4, 4, 4, 5, 5, 5, 5, 5,
- 5, 5, 6, 6, 6, 6, 6, 7, 7, 9,
- 9 };
-short yyr2[]={
-
- 0, 1, 1, 3, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 3, 4, 3, 4, 4, 0,
- 5, 0, 1, 3, 4, 4, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 5, 3, 3, 1,
- 1, 1, 1, 1, 1, 1, 4, 1, 1, 1,
- 3, 3, 3, 2, 1, 1, 2, 2, 3, 6,
- 8, 9, 1, 2, 2, 2, 2, 1, 3, 1,
- 1 };
-short yychk[]={
-
--1000, -3, -2, -1, 42, 38, 45, 33, 126, 284,
- 285, 266, 123, 40, 257, 258, 259, -4, 269, 270,
- 271, 262, 273, -8, -6, 268, 260, -9, 261, 263,
- 264, 265, 267, 44, 284, 285, 286, 46, 91, 40,
- 64, 42, 47, 37, 43, 45, 281, 282, 277, 278,
- 279, 280, 60, 62, 38, 94, 124, 276, 275, 63,
- 61, 272, -1, -1, -1, -1, -1, -1, -1, -1,
- 40, -5, -6, 261, -5, -2, -6, 268, 268, -9,
- 260, 261, -9, -9, -9, -9, -1, -9, 42, -9,
- 42, -2, -10, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -5, 125, 42, 38, 40,
- 268, 41, 41, 268, -9, -9, -1, -1, 93, -11,
- -1, 58, 41, -1, -6, 42, -1, 41, 44, -1,
- 268, -1, 42, 41, 40, 41, -7, -5, 41, 44,
- -5 };
-short yydef[]={
-
- 0, -2, 1, 2, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 49, 50, 51, 52, 53, 54,
- 55, 57, 58, 0, 0, 0, -2, 59, 72, 0,
- 0, 0, 0, 0, 11, 12, 0, 0, 0, 19,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 4, 5, 6, 7, 8, 9, 10, 13,
- 0, 0, 65, 72, 0, 0, 65, 0, 0, 63,
- 79, 80, 73, 74, 75, 76, 3, 14, 0, 16,
- 0, 0, 21, 27, 28, 29, 30, 31, 32, 33,
- 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
- 44, 45, 0, 47, 48, 0, 0, 66, 67, 0,
- 0, 0, 26, 0, -2, 62, 15, 17, 18, 0,
- 22, 0, 56, 24, 0, 68, 25, 20, 0, 46,
- 0, 23, 0, 69, 0, 70, 0, 77, 71, 0,
- 78 };
-#ifndef lint
-static char yaccpar_sccsid[] = "@(#)yaccpar 1.6 88/02/08 SMI"; /* from UCB 4.1 83/02/11 */
-#endif
-
-#
-# define YYFLAG -1000
-# define YYERROR goto yyerrlab
-# define YYACCEPT return(0)
-# define YYABORT return(1)
-
-/* parser for yacc output */
-
-#ifdef YYDEBUG
-int yydebug = 0; /* 1 for debugging */
-#endif
-YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
-int yychar = -1; /* current input token number */
-int yynerrs = 0; /* number of errors */
-short yyerrflag = 0; /* error recovery flag */
-
-yyparse() {
-
- short yys[YYMAXDEPTH];
- short yyj, yym;
- register YYSTYPE *yypvt;
- register short yystate, *yyps, yyn;
- register YYSTYPE *yypv;
- register short *yyxi;
-
- yystate = 0;
- yychar = -1;
- yynerrs = 0;
- yyerrflag = 0;
- yyps= &yys[-1];
- yypv= &yyv[-1];
-
- yystack: /* put a state and value onto the stack */
-
-#ifdef YYDEBUG
- if( yydebug ) printf( "state %d, char 0%o\n", yystate, yychar );
-#endif
- if( ++yyps>= &yys[YYMAXDEPTH] ) { yyerror( "yacc stack overflow" ); return(1); }
- *yyps = yystate;
- ++yypv;
- *yypv = yyval;
-
- yynewstate:
-
- yyn = yypact[yystate];
-
- if( yyn<= YYFLAG ) goto yydefault; /* simple state */
-
- if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0;
- if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault;
-
- if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
- yychar = -1;
- yyval = yylval;
- yystate = yyn;
- if( yyerrflag > 0 ) --yyerrflag;
- goto yystack;
- }
-
- yydefault:
- /* default state action */
-
- if( (yyn=yydef[yystate]) == -2 ) {
- if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0;
- /* look through exception table */
-
- for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */
-
- while( *(yyxi+=2) >= 0 ){
- if( *yyxi == yychar ) break;
- }
- if( (yyn = yyxi[1]) < 0 ) return(0); /* accept */
- }
-
- if( yyn == 0 ){ /* error */
- /* error ... attempt to resume parsing */
-
- switch( yyerrflag ){
-
- case 0: /* brand new error */
-
- yyerror( "syntax error" );
- yyerrlab:
- ++yynerrs;
- case 1:
- case 2: /* incompletely recovered error ... try again */
-
- yyerrflag = 3;
-
- /* find a state where "error" is a legal shift action */
-
- while ( yyps >= yys ) {
- yyn = yypact[*yyps] + YYERRCODE;
- if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
- yystate = yyact[yyn]; /* simulate a shift of "error" */
- goto yystack;
- }
- yyn = yypact[*yyps];
-
- /* the current yyps has no shift onn "error", pop stack */
-
-#ifdef YYDEBUG
- if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
-#endif
- --yyps;
- --yypv;
- }
-
- /* there is no state on the stack with an error shift ... abort */
-
- yyabort:
- return(1);
-
-
- case 3: /* no shift yet; clobber input char */
-
-#ifdef YYDEBUG
- if( yydebug ) printf( "error recovery discards char %d\n", yychar );
-#endif
-
- if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
- yychar = -1;
- goto yynewstate; /* try again in the same state */
-
- }
-
- }
-
- /* reduction by production yyn */
-
-#ifdef YYDEBUG
- if( yydebug ) printf("reduce %d\n",yyn);
-#endif
- yyps -= yyr2[yyn];
- yypvt = yypv;
- yypv -= yyr2[yyn];
- yyval = yypv[1];
- yym=yyn;
- /* consult goto table to find next state */
- yyn = yyr1[yyn];
- yyj = yypgo[yyn] + *yyps + 1;
- if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
- switch(yym){
-
-case 3:
-# line 159 "expread.y"
-{ write_exp_elt (BINOP_COMMA); } break;
-case 4:
-# line 164 "expread.y"
-{ write_exp_elt (UNOP_IND); } break;
-case 5:
-# line 167 "expread.y"
-{ write_exp_elt (UNOP_ADDR); } break;
-case 6:
-# line 170 "expread.y"
-{ write_exp_elt (UNOP_NEG); } break;
-case 7:
-# line 174 "expread.y"
-{ write_exp_elt (UNOP_ZEROP); } break;
-case 8:
-# line 178 "expread.y"
-{ write_exp_elt (UNOP_LOGNOT); } break;
-case 9:
-# line 182 "expread.y"
-{ write_exp_elt (UNOP_PREINCREMENT); } break;
-case 10:
-# line 186 "expread.y"
-{ write_exp_elt (UNOP_PREDECREMENT); } break;
-case 11:
-# line 190 "expread.y"
-{ write_exp_elt (UNOP_POSTINCREMENT); } break;
-case 12:
-# line 194 "expread.y"
-{ write_exp_elt (UNOP_POSTDECREMENT); } break;
-case 13:
-# line 198 "expread.y"
-{ write_exp_elt (UNOP_SIZEOF); } break;
-case 14:
-# line 202 "expread.y"
-{ write_exp_elt (STRUCTOP_PTR);
- write_exp_string (yypvt[-0].sval);
- write_exp_elt (STRUCTOP_PTR); } break;
-case 15:
-# line 208 "expread.y"
-{ write_exp_elt (STRUCTOP_MPTR); } break;
-case 16:
-# line 212 "expread.y"
-{ write_exp_elt (STRUCTOP_STRUCT);
- write_exp_string (yypvt[-0].sval);
- write_exp_elt (STRUCTOP_STRUCT); } break;
-case 17:
-# line 218 "expread.y"
-{ write_exp_elt (STRUCTOP_MEMBER); } break;
-case 18:
-# line 222 "expread.y"
-{ write_exp_elt (BINOP_SUBSCRIPT); } break;
-case 19:
-# line 228 "expread.y"
-{ start_arglist (); } break;
-case 20:
-# line 230 "expread.y"
-{ write_exp_elt (OP_FUNCALL);
- write_exp_elt (end_arglist ());
- write_exp_elt (OP_FUNCALL); } break;
-case 22:
-# line 239 "expread.y"
-{ arglist_len = 1; } break;
-case 23:
-# line 243 "expread.y"
-{ arglist_len++; } break;
-case 24:
-# line 247 "expread.y"
-{ write_exp_elt (UNOP_MEMVAL);
- write_exp_elt (yypvt[-2].tval);
- write_exp_elt (UNOP_MEMVAL); } break;
-case 25:
-# line 253 "expread.y"
-{ write_exp_elt (UNOP_CAST);
- write_exp_elt (yypvt[-2].tval);
- write_exp_elt (UNOP_CAST); } break;
-case 26:
-# line 259 "expread.y"
-{ } break;
-case 27:
-# line 265 "expread.y"
-{ write_exp_elt (BINOP_REPEAT); } break;
-case 28:
-# line 269 "expread.y"
-{ write_exp_elt (BINOP_MUL); } break;
-case 29:
-# line 273 "expread.y"
-{ write_exp_elt (BINOP_DIV); } break;
-case 30:
-# line 277 "expread.y"
-{ write_exp_elt (BINOP_REM); } break;
-case 31:
-# line 281 "expread.y"
-{ write_exp_elt (BINOP_ADD); } break;
-case 32:
-# line 285 "expread.y"
-{ write_exp_elt (BINOP_SUB); } break;
-case 33:
-# line 289 "expread.y"
-{ write_exp_elt (BINOP_LSH); } break;
-case 34:
-# line 293 "expread.y"
-{ write_exp_elt (BINOP_RSH); } break;
-case 35:
-# line 297 "expread.y"
-{ write_exp_elt (BINOP_EQUAL); } break;
-case 36:
-# line 301 "expread.y"
-{ write_exp_elt (BINOP_NOTEQUAL); } break;
-case 37:
-# line 305 "expread.y"
-{ write_exp_elt (BINOP_LEQ); } break;
-case 38:
-# line 309 "expread.y"
-{ write_exp_elt (BINOP_GEQ); } break;
-case 39:
-# line 313 "expread.y"
-{ write_exp_elt (BINOP_LESS); } break;
-case 40:
-# line 317 "expread.y"
-{ write_exp_elt (BINOP_GTR); } break;
-case 41:
-# line 321 "expread.y"
-{ write_exp_elt (BINOP_LOGAND); } break;
-case 42:
-# line 325 "expread.y"
-{ write_exp_elt (BINOP_LOGXOR); } break;
-case 43:
-# line 329 "expread.y"
-{ write_exp_elt (BINOP_LOGIOR); } break;
-case 44:
-# line 333 "expread.y"
-{ write_exp_elt (BINOP_AND); } break;
-case 45:
-# line 337 "expread.y"
-{ write_exp_elt (BINOP_OR); } break;
-case 46:
-# line 341 "expread.y"
-{ write_exp_elt (TERNOP_COND); } break;
-case 47:
-# line 345 "expread.y"
-{ write_exp_elt (BINOP_ASSIGN); } break;
-case 48:
-# line 349 "expread.y"
-{ write_exp_elt (BINOP_ASSIGN_MODIFY);
- write_exp_elt (yypvt[-1].opcode);
- write_exp_elt (BINOP_ASSIGN_MODIFY); } break;
-case 49:
-# line 355 "expread.y"
-{ write_exp_elt (OP_LONG);
- write_exp_elt (builtin_type_long);
- write_exp_elt (yypvt[-0].lval);
- write_exp_elt (OP_LONG); } break;
-case 50:
-# line 362 "expread.y"
-{ write_exp_elt (OP_LONG);
- write_exp_elt (builtin_type_char);
- write_exp_elt (yypvt[-0].lval);
- write_exp_elt (OP_LONG); } break;
-case 51:
-# line 369 "expread.y"
-{ write_exp_elt (OP_DOUBLE);
- write_exp_elt (builtin_type_double);
- write_exp_elt2 (yypvt[-0].dval);
- write_exp_elt (OP_DOUBLE); } break;
-case 53:
-# line 379 "expread.y"
-{ write_exp_elt (OP_LAST);
- write_exp_elt (yypvt[-0].lval);
- write_exp_elt (OP_LAST); } break;
-case 54:
-# line 385 "expread.y"
-{ write_exp_elt (OP_REGISTER);
- write_exp_elt (yypvt[-0].lval);
- write_exp_elt (OP_REGISTER); } break;
-case 55:
-# line 391 "expread.y"
-{ write_exp_elt (OP_INTERNALVAR);
- write_exp_elt (yypvt[-0].ivar);
- write_exp_elt (OP_INTERNALVAR); } break;
-case 56:
-# line 397 "expread.y"
-{ write_exp_elt (OP_LONG);
- write_exp_elt (builtin_type_int);
- write_exp_elt ((long) TYPE_LENGTH (yypvt[-1].tval));
- write_exp_elt (OP_LONG); } break;
-case 57:
-# line 404 "expread.y"
-{ write_exp_elt (OP_STRING);
- write_exp_string (yypvt[-0].sval);
- write_exp_elt (OP_STRING); } break;
-case 58:
-# line 411 "expread.y"
-{ write_exp_elt (OP_THIS);
- write_exp_elt (OP_THIS); } break;
-case 59:
-# line 418 "expread.y"
-{
- struct symtab *tem = lookup_symtab (copy_name (yypvt[-0].sval));
- struct symbol *sym;
-
- if (tem)
- yyval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (tem), 1);
- else
- {
- sym = lookup_symbol (copy_name (yypvt[-0].sval),
- expression_context_block,
- VAR_NAMESPACE);
- if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
- yyval.bval = SYMBOL_BLOCK_VALUE (sym);
- else
- error ("No file or function \"%s\".",
- copy_name (yypvt[-0].sval));
- }
- } break;
-case 60:
-# line 439 "expread.y"
+static void
+push_type (tp)
+ enum type_pieces tp;
{
- struct symbol *tem
- = lookup_symbol (copy_name (yypvt[-0].sval), yypvt[-2].bval, VAR_NAMESPACE);
- if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
- error ("No function \"%s\" in specified context.",
- copy_name (yypvt[-0].sval));
- yyval.bval = SYMBOL_BLOCK_VALUE (tem);
- } break;
-case 61:
-# line 450 "expread.y"
-{
- struct symbol *sym;
- sym = lookup_symbol (copy_name (yypvt[-0].sval), yypvt[-2].bval, VAR_NAMESPACE);
- if (sym == 0)
- error ("No symbol \"%s\" in specified context.",
- copy_name (yypvt[-0].sval));
- write_exp_elt (OP_VAR_VALUE);
- write_exp_elt (sym);
- write_exp_elt (OP_VAR_VALUE);
- } break;
-case 62:
-# line 463 "expread.y"
-{
- struct type *type = yypvt[-2].tval;
- if (TYPE_CODE (type) != TYPE_CODE_STRUCT
- && TYPE_CODE (type) != TYPE_CODE_UNION)
- error ("`%s' is not defined as an aggregate type.",
- TYPE_NAME (type));
+ if (type_stack_depth == type_stack_size)
+ {
+ type_stack_size *= 2;
+ type_stack = (union type_stack_elt *)
+ xrealloc (type_stack, type_stack_size * sizeof (*type_stack));
+ }
+ type_stack[type_stack_depth++].piece = tp;
+}
- write_exp_elt (OP_SCOPE);
- write_exp_elt (type);
- write_exp_string (yypvt[-0].sval);
- write_exp_elt (OP_SCOPE);
- } break;
-case 63:
-# line 476 "expread.y"
+static void
+push_type_int (n)
+ int n;
{
- char *name = copy_name (yypvt[-0].sval);
- struct symbol *sym;
- int i;
-
- sym = lookup_symbol_2 (name, 0, VAR_NAMESPACE);
- if (sym)
- {
- write_exp_elt (OP_VAR_VALUE);
- write_exp_elt (sym);
- write_exp_elt (OP_VAR_VALUE);
- break;
- }
- for (i = 0; i < misc_function_count; i++)
- if (!strcmp (misc_function_vector[i].name, name))
- break;
+ if (type_stack_depth == type_stack_size)
+ {
+ type_stack_size *= 2;
+ type_stack = (union type_stack_elt *)
+ xrealloc (type_stack, type_stack_size * sizeof (*type_stack));
+ }
+ type_stack[type_stack_depth++].int_val = n;
+}
- if (i < misc_function_count)
- {
- write_exp_elt (OP_LONG);
- write_exp_elt (builtin_type_int);
- write_exp_elt (misc_function_vector[i].address);
- write_exp_elt (OP_LONG);
- write_exp_elt (UNOP_MEMVAL);
- write_exp_elt (builtin_type_char);
- write_exp_elt (UNOP_MEMVAL);
- }
- else
- if (symtab_list == 0)
- error ("No symbol table is loaded. Use the \"symbol-file\" command.");
- else
- error ("No symbol \"%s\" in current context.", name);
- } break;
-case 64:
-# line 512 "expread.y"
-{ struct symbol *sym;
- sym = lookup_symbol_1 (copy_name (yypvt[-0].sval),
- expression_context_block,
- VAR_NAMESPACE);
- if (sym)
- {
- write_exp_elt (OP_VAR_VALUE);
- write_exp_elt (sym);
- write_exp_elt (OP_VAR_VALUE);
- }
- else
- {
- register char *arg = copy_name (yypvt[-0].sval);
- register int i;
- int v, val;
- /* C++: see if it hangs off of `this'. Must
- not inadvertently convert from a method call
- to data ref. */
- v = (int)value_of_this (0);
- if (v)
- {
- val = check_field (v, arg);
- if (val)
- {
- write_exp_elt (OP_THIS);
- write_exp_elt (OP_THIS);
- write_exp_elt (STRUCTOP_PTR);
- write_exp_string (yypvt[-0].sval);
- write_exp_elt (STRUCTOP_PTR);
- break;
- }
- }
- sym = lookup_symbol_2 (arg, 0, VAR_NAMESPACE);
- if (sym)
- {
- write_exp_elt (OP_VAR_VALUE);
- write_exp_elt (sym);
- write_exp_elt (OP_VAR_VALUE);
- break; /* YACC-dependent */
- }
- for (i = 0; i < misc_function_count; i++)
- if (!strcmp (misc_function_vector[i].name, arg))
- break;
+static enum type_pieces
+pop_type ()
+{
+ if (type_stack_depth)
+ return type_stack[--type_stack_depth].piece;
+ return tp_end;
+}
- if (i < misc_function_count)
- {
- write_exp_elt (OP_LONG);
- write_exp_elt (builtin_type_int);
- write_exp_elt (misc_function_vector[i].address);
- write_exp_elt (OP_LONG);
- write_exp_elt (UNOP_MEMVAL);
- write_exp_elt (builtin_type_char);
- write_exp_elt (UNOP_MEMVAL);
- }
- else
- if (symtab_list == 0)
- error ("No symbol table is loaded. Use the \"symbol-file\" command.");
- else
- error ("No symbol \"%s\" in current context.",
- copy_name (yypvt[-0].sval));
- }
- } break;
-case 66:
-# line 578 "expread.y"
-{ yyval.tval = lookup_pointer_type (yypvt[-1].tval); } break;
-case 67:
-# line 580 "expread.y"
-{ yyval.tval = lookup_reference_type (yypvt[-1].tval); } break;
-case 68:
-# line 582 "expread.y"
-{ yyval.tval = lookup_member_type (builtin_type_int, yypvt[-2].tval); } break;
-case 69:
-# line 584 "expread.y"
-{ yyval.tval = lookup_member_type (yypvt[-5].tval, yypvt[-3].tval); } break;
-case 70:
-# line 586 "expread.y"
-{ yyval.tval = lookup_member_type (lookup_function_type (yypvt[-7].tval, 0), yypvt[-5].tval); } break;
-case 71:
-# line 588 "expread.y"
-{ yyval.tval = lookup_member_type (lookup_function_type (yypvt[-8].tval, yypvt[-1].tvec), yypvt[-6].tval);
- free (yypvt[-1].tvec); } break;
-case 72:
-# line 594 "expread.y"
-{ yyval.tval = lookup_typename (copy_name (yypvt[-0].sval),
- expression_context_block, 0); } break;
-case 73:
-# line 597 "expread.y"
-{ yyval.tval = lookup_struct (copy_name (yypvt[-0].sval),
- expression_context_block); } break;
-case 74:
-# line 600 "expread.y"
-{ yyval.tval = lookup_union (copy_name (yypvt[-0].sval),
- expression_context_block); } break;
-case 75:
-# line 603 "expread.y"
-{ yyval.tval = lookup_enum (copy_name (yypvt[-0].sval),
- expression_context_block); } break;
-case 76:
-# line 606 "expread.y"
-{ yyval.tval = lookup_unsigned_typename (copy_name (yypvt[-0].sval)); } break;
-case 77:
-# line 611 "expread.y"
-{ yyval.tvec = (struct type **)xmalloc (sizeof (struct type *) * 2);
- yyval.tvec[0] = (struct type *)0;
- yyval.tvec[1] = yypvt[-0].tval;
- } break;
-case 78:
-# line 616 "expread.y"
-{ int len = sizeof (struct type *) * ++(yypvt[-2].ivec[0]);
- yyval.tvec = (struct type **)xrealloc (yypvt[-2].tvec, len);
- yyval.tvec[yyval.ivec[0]] = yypvt[-0].tval;
- } break;
- }
- goto yystack; /* stack new state and value */
+static int
+pop_type_int ()
+{
+ if (type_stack_depth)
+ return type_stack[--type_stack_depth].int_val;
+ /* "Can't happen". */
+ return 0;
+}
- }
+void
+_initialize_expread ()
+{
+ type_stack_size = 80;
+ type_stack_depth = 0;
+ type_stack = (union type_stack_elt *)
+ xmalloc (type_stack_size * sizeof (*type_stack));
+}
projects / binutils.git / blobdiff