2949 lines
81 KiB
C
Executable File
2949 lines
81 KiB
C
Executable File
|
||
/* 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 "value.h"
|
||
#include "command.h"
|
||
|
||
static struct expression *expout;
|
||
static int expout_size;
|
||
static int expout_ptr;
|
||
|
||
static int yylex ();
|
||
static void yyerror ();
|
||
static void write_exp_elt ();
|
||
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;
|
||
|
||
/* Data structure for saving values of arglist_len
|
||
for function calls whose arguments contain other function calls. */
|
||
|
||
struct funcall
|
||
{
|
||
struct funcall *next;
|
||
int arglist_len;
|
||
};
|
||
|
||
struct funcall *funcall_chain;
|
||
|
||
/* This kind of datum is used to represent the name
|
||
of a symbol token. */
|
||
|
||
struct stoken
|
||
{
|
||
char *ptr;
|
||
int length;
|
||
};
|
||
|
||
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
|
||
{
|
||
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 internalvar *ivar;
|
||
|
||
struct type **tvec;
|
||
int *ivec;
|
||
} YYSTYPE;
|
||
|
||
#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 10000
|
||
#endif
|
||
|
||
#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;
|
||
|
||
while (i-- > 0)
|
||
*t++ = *f++;
|
||
}
|
||
|
||
#endif
|
||
|
||
#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"
|
||
|
||
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"
|
||
|
||
|
||
/* Begin counting arguments for a function call,
|
||
saving the data about any containing call. */
|
||
|
||
static void
|
||
start_arglist ()
|
||
{
|
||
register struct funcall *new = (struct funcall *) xmalloc (sizeof (struct funcall));
|
||
|
||
new->next = funcall_chain;
|
||
new->arglist_len = arglist_len;
|
||
arglist_len = 0;
|
||
funcall_chain = new;
|
||
}
|
||
|
||
/* Return the number of arguments in a function call just terminated,
|
||
and restore the data for the containing function call. */
|
||
|
||
static int
|
||
end_arglist ()
|
||
{
|
||
register int val = arglist_len;
|
||
register struct funcall *call = funcall_chain;
|
||
funcall_chain = call->next;
|
||
arglist_len = call->arglist_len;
|
||
free (call);
|
||
return val;
|
||
}
|
||
|
||
/* Free everything in the funcall chain.
|
||
Used when there is an error inside parsing. */
|
||
|
||
static void
|
||
free_funcalls ()
|
||
{
|
||
register struct funcall *call, *next;
|
||
|
||
for (call = funcall_chain; call; call = next)
|
||
{
|
||
next = call->next;
|
||
free (call);
|
||
}
|
||
}
|
||
|
||
/* This page contains the functions for adding data to the struct expression
|
||
being constructed. */
|
||
|
||
/* Add one element to the end of the expression. */
|
||
|
||
/* 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;
|
||
{
|
||
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++] = expelt;
|
||
}
|
||
|
||
static void
|
||
write_exp_elt_opcode (expelt)
|
||
enum exp_opcode expelt;
|
||
{
|
||
union exp_element tmp;
|
||
|
||
tmp.opcode = expelt;
|
||
|
||
write_exp_elt (tmp);
|
||
}
|
||
|
||
static void
|
||
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 tmp;
|
||
|
||
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.
|
||
Follow it by its length in bytes, as a separate exp_element. */
|
||
|
||
static void
|
||
write_exp_string (str)
|
||
struct stoken str;
|
||
{
|
||
register int len = str.length;
|
||
register int lenelt
|
||
= (len + sizeof (union exp_element)) / sizeof (union exp_element);
|
||
|
||
expout_ptr += lenelt;
|
||
|
||
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))));
|
||
}
|
||
bcopy (str.ptr, (char *) &expout->elts[expout_ptr - lenelt], len);
|
||
((char *) &expout->elts[expout_ptr - lenelt])[len] = 0;
|
||
write_exp_elt_longcst ((LONGEST) len);
|
||
}
|
||
|
||
/* During parsing of a C expression, the pointer to the next character
|
||
is in this variable. */
|
||
|
||
static char *lexptr;
|
||
|
||
/* Tokens that refer to names do so with explicit pointer and length,
|
||
so they can share the storage that lexptr is parsing.
|
||
|
||
When it is necessary to pass a name to a function that expects
|
||
a null-terminated string, the substring is copied out
|
||
into a block of storage that namecopy points to.
|
||
|
||
namecopy is allocated once, guaranteed big enough, for each parsing. */
|
||
|
||
static char *namecopy;
|
||
|
||
/* Current depth in parentheses within the expression. */
|
||
|
||
static int paren_depth;
|
||
|
||
/* Nonzero means stop parsing on first comma (if not within parentheses). */
|
||
|
||
static int comma_terminates;
|
||
|
||
/* Take care of parsing a number (anything that starts with a digit).
|
||
Set yylval and return the token type; update lexptr.
|
||
LEN is the number of characters in it. */
|
||
|
||
/*** Needs some error checking for the float case ***/
|
||
|
||
static int
|
||
parse_number (p, len, parsed_float, putithere)
|
||
register char *p;
|
||
register int len;
|
||
int parsed_float;
|
||
YYSTYPE *putithere;
|
||
{
|
||
register LONGEST n = 0;
|
||
register int i;
|
||
register int c;
|
||
register int base = input_radix;
|
||
int unsigned_p = 0;
|
||
|
||
extern double atof ();
|
||
|
||
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;
|
||
}
|
||
|
||
while (len-- > 0)
|
||
{
|
||
c = *p++;
|
||
if (c >= 'A' && c <= 'Z')
|
||
c += 'a' - 'A';
|
||
if (c != 'l' && c != 'u')
|
||
n *= base;
|
||
if (c >= '0' && c <= '9')
|
||
n += i = c - '0';
|
||
else
|
||
{
|
||
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
|
||
return ERROR; /* Char not a digit */
|
||
}
|
||
if (i >= base)
|
||
return ERROR; /* Invalid digit in this base */
|
||
}
|
||
|
||
if (unsigned_p)
|
||
{
|
||
putithere->ulval = n;
|
||
return UINT;
|
||
}
|
||
else
|
||
{
|
||
putithere->lval = n;
|
||
return INT;
|
||
}
|
||
}
|
||
|
||
struct token
|
||
{
|
||
char *operator;
|
||
int token;
|
||
enum exp_opcode opcode;
|
||
};
|
||
|
||
const static struct token tokentab3[] =
|
||
{
|
||
{">>=", ASSIGN_MODIFY, BINOP_RSH},
|
||
{"<<=", ASSIGN_MODIFY, BINOP_LSH}
|
||
};
|
||
|
||
const static struct token tokentab2[] =
|
||
{
|
||
{"+=", ASSIGN_MODIFY, BINOP_ADD},
|
||
{"-=", ASSIGN_MODIFY, BINOP_SUB},
|
||
{"*=", ASSIGN_MODIFY, BINOP_MUL},
|
||
{"/=", ASSIGN_MODIFY, BINOP_DIV},
|
||
{"%=", ASSIGN_MODIFY, BINOP_REM},
|
||
{"|=", ASSIGN_MODIFY, BINOP_LOGIOR},
|
||
{"&=", ASSIGN_MODIFY, BINOP_LOGAND},
|
||
{"^=", ASSIGN_MODIFY, BINOP_LOGXOR},
|
||
{"++", INCREMENT, BINOP_END},
|
||
{"--", DECREMENT, BINOP_END},
|
||
{"->", ARROW, BINOP_END},
|
||
{"&&", AND, BINOP_END},
|
||
{"||", OR, BINOP_END},
|
||
{"::", COLONCOLON, BINOP_END},
|
||
{"<<", LSH, BINOP_END},
|
||
{">>", RSH, BINOP_END},
|
||
{"==", EQUAL, BINOP_END},
|
||
{"!=", NOTEQUAL, BINOP_END},
|
||
{"<=", LEQ, BINOP_END},
|
||
{">=", 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
|
||
yylex ()
|
||
{
|
||
register int c;
|
||
register int namelen;
|
||
register unsigned i;
|
||
register char *tokstart;
|
||
|
||
retry:
|
||
|
||
tokstart = lexptr;
|
||
/* See if it is a special token of length 3. */
|
||
for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
|
||
if (!strncmp (tokstart, tokentab3[i].operator, 3))
|
||
{
|
||
lexptr += 3;
|
||
yylval.opcode = tokentab3[i].opcode;
|
||
return tokentab3[i].token;
|
||
}
|
||
|
||
/* See if it is a special token of length 2. */
|
||
for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
|
||
if (!strncmp (tokstart, tokentab2[i].operator, 2))
|
||
{
|
||
lexptr += 2;
|
||
yylval.opcode = tokentab2[i].opcode;
|
||
return tokentab2[i].token;
|
||
}
|
||
|
||
switch (c = *tokstart)
|
||
{
|
||
case 0:
|
||
return 0;
|
||
|
||
case ' ':
|
||
case '\t':
|
||
case '\n':
|
||
lexptr++;
|
||
goto retry;
|
||
|
||
case '\'':
|
||
lexptr++;
|
||
c = *lexptr++;
|
||
if (c == '\\')
|
||
c = parse_escape (&lexptr);
|
||
yylval.lval = c;
|
||
c = *lexptr++;
|
||
if (c != '\'')
|
||
error ("Invalid character constant.");
|
||
return CHAR;
|
||
|
||
case '(':
|
||
paren_depth++;
|
||
lexptr++;
|
||
return c;
|
||
|
||
case ')':
|
||
if (paren_depth == 0)
|
||
return 0;
|
||
paren_depth--;
|
||
lexptr++;
|
||
return c;
|
||
|
||
case ',':
|
||
if (comma_terminates && paren_depth == 0)
|
||
return 0;
|
||
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 '<':
|
||
case '>':
|
||
case '[':
|
||
case ']':
|
||
case '?':
|
||
case ':':
|
||
case '=':
|
||
case '{':
|
||
case '}':
|
||
symbol:
|
||
lexptr++;
|
||
return c;
|
||
|
||
case '"':
|
||
for (namelen = 1; (c = tokstart[namelen]) != '"'; namelen++)
|
||
if (c == '\\')
|
||
{
|
||
c = tokstart[++namelen];
|
||
if (c >= '0' && c <= '9')
|
||
{
|
||
c = tokstart[++namelen];
|
||
if (c >= '0' && c <= '9')
|
||
c = tokstart[++namelen];
|
||
}
|
||
}
|
||
yylval.sval.ptr = tokstart + 1;
|
||
yylval.sval.length = namelen - 1;
|
||
lexptr += namelen + 1;
|
||
return STRING;
|
||
}
|
||
|
||
if (!(c == '_' || c == '$'
|
||
|| (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
|
||
/* We must have come across a bad character (e.g. ';'). */
|
||
error ("Invalid character '%c' in expression.", c);
|
||
|
||
/* 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'));
|
||
c = tokstart[++namelen])
|
||
;
|
||
|
||
/* The token "if" terminates the expression and is NOT
|
||
removed from the input stream. */
|
||
if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
lexptr += namelen;
|
||
|
||
/* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
|
||
and $$digits (equivalent to $<-digits> if you could type that).
|
||
Make token type LAST, and put the number (the digits) in yylval. */
|
||
|
||
if (*tokstart == '$')
|
||
{
|
||
register int negate = 0;
|
||
c = 1;
|
||
/* Double dollar means negate the number and add -1 as well.
|
||
Thus $$ alone means -1. */
|
||
if (namelen >= 2 && tokstart[1] == '$')
|
||
{
|
||
negate = 1;
|
||
c = 2;
|
||
}
|
||
if (c == namelen)
|
||
{
|
||
/* Just dollars (one or two) */
|
||
yylval.lval = - negate;
|
||
return LAST;
|
||
}
|
||
/* Is the rest of the token digits? */
|
||
for (; c < namelen; c++)
|
||
if (!(tokstart[c] >= '0' && tokstart[c] <= '9'))
|
||
break;
|
||
if (c == namelen)
|
||
{
|
||
yylval.lval = atoi (tokstart + 1 + negate);
|
||
if (negate)
|
||
yylval.lval = - yylval.lval;
|
||
return LAST;
|
||
}
|
||
}
|
||
|
||
/* Handle tokens that refer to machine registers:
|
||
$ followed by a register name. */
|
||
|
||
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;
|
||
}
|
||
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 (!strncmp (tokstart, "short", 5))
|
||
return SHORT;
|
||
break;
|
||
case 4:
|
||
if (!strncmp (tokstart, "enum", 4))
|
||
return ENUM;
|
||
if (!strncmp (tokstart, "long", 4))
|
||
return LONG;
|
||
if (!strncmp (tokstart, "this", 4))
|
||
{
|
||
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;
|
||
}
|
||
|
||
yylval.sval.ptr = tokstart;
|
||
yylval.sval.length = namelen;
|
||
|
||
/* Any other names starting in $ are debugger internal variables. */
|
||
|
||
if (*tokstart == '$')
|
||
{
|
||
yylval.ivar = lookup_internalvar (copy_name (yylval.sval) + 1);
|
||
return VARIABLE;
|
||
}
|
||
|
||
/* 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. */
|
||
{
|
||
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 void
|
||
yyerror (msg)
|
||
char *msg;
|
||
{
|
||
error ("Invalid syntax in expression.");
|
||
}
|
||
|
||
/* Return a null-terminated temporary copy of the name
|
||
of a string token. */
|
||
|
||
static char *
|
||
copy_name (token)
|
||
struct stoken token;
|
||
{
|
||
bcopy (token.ptr, namecopy, token.length);
|
||
namecopy[token.length] = 0;
|
||
return namecopy;
|
||
}
|
||
|
||
/* Reverse an expression from suffix form (in which it is constructed)
|
||
to prefix form (in which we can conveniently print or execute it). */
|
||
|
||
static void prefixify_subexp ();
|
||
|
||
static void
|
||
prefixify_expression (expr)
|
||
register struct expression *expr;
|
||
{
|
||
register int len = sizeof (struct expression) +
|
||
expr->nelts * sizeof (union exp_element);
|
||
register struct expression *temp;
|
||
register int inpos = expr->nelts, outpos = 0;
|
||
|
||
temp = (struct expression *) alloca (len);
|
||
|
||
/* Copy the original expression into temp. */
|
||
bcopy (expr, temp, len);
|
||
|
||
prefixify_subexp (temp, expr, inpos, outpos);
|
||
}
|
||
|
||
/* Return the number of exp_elements in the subexpression of EXPR
|
||
whose last exp_element is at index ENDPOS - 1 in EXPR. */
|
||
|
||
static int
|
||
length_of_subexp (expr, endpos)
|
||
register struct expression *expr;
|
||
register int endpos;
|
||
{
|
||
register int oplen = 1;
|
||
register int args = 0;
|
||
register int i;
|
||
|
||
if (endpos < 0)
|
||
error ("?error in length_of_subexp");
|
||
|
||
i = (int) expr->elts[endpos - 1].opcode;
|
||
|
||
switch (i)
|
||
{
|
||
/* C++ */
|
||
case OP_SCOPE:
|
||
oplen = 4 + ((expr->elts[endpos - 2].longconst
|
||
+ sizeof (union exp_element))
|
||
/ sizeof (union exp_element));
|
||
break;
|
||
|
||
case OP_LONG:
|
||
case OP_DOUBLE:
|
||
oplen = 4;
|
||
break;
|
||
|
||
case OP_VAR_VALUE:
|
||
case OP_LAST:
|
||
case OP_REGISTER:
|
||
case OP_INTERNALVAR:
|
||
oplen = 3;
|
||
break;
|
||
|
||
case OP_FUNCALL:
|
||
oplen = 3;
|
||
args = 1 + expr->elts[endpos - 2].longconst;
|
||
break;
|
||
|
||
case UNOP_CAST:
|
||
case UNOP_MEMVAL:
|
||
oplen = 3;
|
||
args = 1;
|
||
break;
|
||
|
||
case STRUCTOP_STRUCT:
|
||
case STRUCTOP_PTR:
|
||
args = 1;
|
||
case OP_STRING:
|
||
oplen = 3 + ((expr->elts[endpos - 2].longconst
|
||
+ sizeof (union exp_element))
|
||
/ sizeof (union exp_element));
|
||
break;
|
||
|
||
case TERNOP_COND:
|
||
args = 3;
|
||
break;
|
||
|
||
case BINOP_ASSIGN_MODIFY:
|
||
oplen = 3;
|
||
args = 2;
|
||
break;
|
||
|
||
/* C++ */
|
||
case OP_THIS:
|
||
oplen = 2;
|
||
break;
|
||
|
||
default:
|
||
args = 1 + (i < (int) BINOP_END);
|
||
}
|
||
|
||
while (args > 0)
|
||
{
|
||
oplen += length_of_subexp (expr, endpos - oplen);
|
||
args--;
|
||
}
|
||
|
||
return oplen;
|
||
}
|
||
|
||
/* Copy the subexpression ending just before index INEND in INEXPR
|
||
into OUTEXPR, starting at index OUTBEG.
|
||
In the process, convert it from suffix to prefix form. */
|
||
|
||
static void
|
||
prefixify_subexp (inexpr, outexpr, inend, outbeg)
|
||
register struct expression *inexpr;
|
||
struct expression *outexpr;
|
||
register int inend;
|
||
int outbeg;
|
||
{
|
||
register int oplen = 1;
|
||
register int args = 0;
|
||
register int i;
|
||
int *arglens;
|
||
enum exp_opcode opcode;
|
||
|
||
/* Compute how long the last operation is (in OPLEN),
|
||
and also how many preceding subexpressions serve as
|
||
arguments for it (in ARGS). */
|
||
|
||
opcode = inexpr->elts[inend - 1].opcode;
|
||
switch (opcode)
|
||
{
|
||
/* C++ */
|
||
case OP_SCOPE:
|
||
oplen = 4 + ((inexpr->elts[inend - 2].longconst
|
||
+ sizeof (union exp_element))
|
||
/ sizeof (union exp_element));
|
||
break;
|
||
|
||
case OP_LONG:
|
||
case OP_DOUBLE:
|
||
oplen = 4;
|
||
break;
|
||
|
||
case OP_VAR_VALUE:
|
||
case OP_LAST:
|
||
case OP_REGISTER:
|
||
case OP_INTERNALVAR:
|
||
oplen = 3;
|
||
break;
|
||
|
||
case OP_FUNCALL:
|
||
oplen = 3;
|
||
args = 1 + inexpr->elts[inend - 2].longconst;
|
||
break;
|
||
|
||
case UNOP_CAST:
|
||
case UNOP_MEMVAL:
|
||
oplen = 3;
|
||
args = 1;
|
||
break;
|
||
|
||
case STRUCTOP_STRUCT:
|
||
case STRUCTOP_PTR:
|
||
args = 1;
|
||
case OP_STRING:
|
||
oplen = 3 + ((inexpr->elts[inend - 2].longconst
|
||
+ sizeof (union exp_element))
|
||
/ sizeof (union exp_element));
|
||
|
||
break;
|
||
|
||
case TERNOP_COND:
|
||
args = 3;
|
||
break;
|
||
|
||
case BINOP_ASSIGN_MODIFY:
|
||
oplen = 3;
|
||
args = 2;
|
||
break;
|
||
|
||
/* C++ */
|
||
case OP_THIS:
|
||
oplen = 2;
|
||
break;
|
||
|
||
default:
|
||
args = 1 + ((int) opcode < (int) BINOP_END);
|
||
}
|
||
|
||
/* Copy the final operator itself, from the end of the input
|
||
to the beginning of the output. */
|
||
inend -= oplen;
|
||
bcopy (&inexpr->elts[inend], &outexpr->elts[outbeg],
|
||
oplen * sizeof (union exp_element));
|
||
outbeg += oplen;
|
||
|
||
/* Find the lengths of the arg subexpressions. */
|
||
arglens = (int *) alloca (args * sizeof (int));
|
||
for (i = args - 1; i >= 0; i--)
|
||
{
|
||
oplen = length_of_subexp (inexpr, inend);
|
||
arglens[i] = oplen;
|
||
inend -= oplen;
|
||
}
|
||
|
||
/* Now copy each subexpression, preserving the order of
|
||
the subexpressions, but prefixifying each one.
|
||
In this loop, inend starts at the beginning of
|
||
the expression this level is working on
|
||
and marches forward over the arguments.
|
||
outbeg does similarly in the output. */
|
||
for (i = 0; i < args; i++)
|
||
{
|
||
oplen = arglens[i];
|
||
inend += oplen;
|
||
prefixify_subexp (inexpr, outexpr, inend, outbeg);
|
||
outbeg += oplen;
|
||
}
|
||
}
|
||
|
||
/* This page contains the two entry points to this file. */
|
||
|
||
/* Read a C expression from the string *STRINGPTR points to,
|
||
parse it, and return a pointer to a struct expression that we malloc.
|
||
Use block BLOCK as the lexical context for variable names;
|
||
if BLOCK is zero, use the block of the selected stack frame.
|
||
Meanwhile, advance *STRINGPTR to point after the expression,
|
||
at the first nonwhite character that is not part of the expression
|
||
(possibly a null character).
|
||
|
||
If COMMA is nonzero, stop if a comma is reached. */
|
||
|
||
struct 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)
|
||
error_no_arg ("expression to compute");
|
||
|
||
old_chain = make_cleanup (free_funcalls, 0);
|
||
funcall_chain = 0;
|
||
|
||
expression_context_block = block ? block : get_selected_block ();
|
||
|
||
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));
|
||
make_cleanup (free_current_contents, &expout);
|
||
if (yyparse ())
|
||
yyerror (NULL);
|
||
discard_cleanups (old_chain);
|
||
expout->nelts = expout_ptr;
|
||
expout = (struct expression *)
|
||
xrealloc (expout,
|
||
sizeof (struct expression)
|
||
+ expout_ptr * sizeof (union exp_element));
|
||
prefixify_expression (expout);
|
||
*stringptr = lexptr;
|
||
return expout;
|
||
}
|
||
|
||
/* Parse STRING as an expression, and complain if this fails
|
||
to use up all of the contents of STRING. */
|
||
|
||
struct expression *
|
||
parse_c_expression (string)
|
||
char *string;
|
||
{
|
||
register struct expression *exp;
|
||
exp = parse_c_1 (&string, 0, 0);
|
||
if (*string)
|
||
error ("Junk after end of expression.");
|
||
return exp;
|
||
}
|
||
|
||
static void
|
||
push_type (tp)
|
||
enum type_pieces tp;
|
||
{
|
||
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;
|
||
}
|
||
|
||
static void
|
||
push_type_int (n)
|
||
int n;
|
||
{
|
||
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;
|
||
}
|
||
|
||
static enum type_pieces
|
||
pop_type ()
|
||
{
|
||
if (type_stack_depth)
|
||
return type_stack[--type_stack_depth].piece;
|
||
return tp_end;
|
||
}
|
||
|
||
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));
|
||
}
|