projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix -Wuh and -Wnhu options so that they work.
[deliverable/binutils-gdb.git] / gdb / c-exp.tab.c
CommitLineData
9733ab3f
SS		 1
2/* A Bison parser, made from c-exp.y
3 by GNU Bison version 1.25
4 */
5
6#define YYBISON 1 /* Identify Bison output. */
7
8#define INT 258
9#define FLOAT 259
10#define STRING 260
11#define NAME 261
12#define TYPENAME 262
13#define NAME_OR_INT 263
14#define STRUCT 264
15#define CLASS 265
16#define UNION 266
17#define ENUM 267
18#define SIZEOF 268
19#define UNSIGNED 269
20#define COLONCOLON 270
21#define TEMPLATE 271
22#define ERROR 272
23#define SIGNED_KEYWORD 273
24#define LONG 274
25#define SHORT 275
26#define INT_KEYWORD 276
27#define CONST_KEYWORD 277
28#define VOLATILE_KEYWORD 278
29#define DOUBLE_KEYWORD 279
30#define VARIABLE 280
31#define ASSIGN_MODIFY 281
32#define THIS 282
33#define TRUEKEYWORD 283
34#define FALSEKEYWORD 284
35#define ABOVE_COMMA 285
36#define OROR 286
37#define ANDAND 287
38#define EQUAL 288
39#define NOTEQUAL 289
40#define LEQ 290
41#define GEQ 291
42#define LSH 292
43#define RSH 293
44#define UNARY 294
45#define INCREMENT 295
46#define DECREMENT 296
47#define ARROW 297
48#define BLOCKNAME 298
49#define FILENAME 299
50
51#line 38 "c-exp.y"
52
53
54#include "defs.h"
55#include "gdb_string.h"
56#include <ctype.h>
57#include "expression.h"
58#include "value.h"
59#include "parser-defs.h"
60#include "language.h"
61#include "c-lang.h"
62#include "bfd.h" /* Required by objfiles.h. */
63#include "symfile.h" /* Required by objfiles.h. */
64#include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
65
66/* Flag indicating we're dealing with HP-compiled objects */
67extern int hp_som_som_object_present;
68
69/* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
70 as well as gratuitiously global symbol names, so we can have multiple
71 yacc generated parsers in gdb. Note that these are only the variables
72 produced by yacc. If other parser generators (bison, byacc, etc) produce
73 additional global names that conflict at link time, then those parser
74 generators need to be fixed instead of adding those names to this list. */
75
76#define yymaxdepth c_maxdepth
77#define yyparse c_parse
78#define yylex c_lex
79#define yyerror c_error
80#define yylval c_lval
81#define yychar c_char
82#define yydebug c_debug
83#define yypact c_pact
84#define yyr1 c_r1
85#define yyr2 c_r2
86#define yydef c_def
87#define yychk c_chk
88#define yypgo c_pgo
89#define yyact c_act
90#define yyexca c_exca
91#define yyerrflag c_errflag
92#define yynerrs c_nerrs
93#define yyps c_ps
94#define yypv c_pv
95#define yys c_s
96#define yy_yys c_yys
97#define yystate c_state
98#define yytmp c_tmp
99#define yyv c_v
100#define yy_yyv c_yyv
101#define yyval c_val
102#define yylloc c_lloc
103#define yyreds c_reds /* With YYDEBUG defined */
104#define yytoks c_toks /* With YYDEBUG defined */
105#define yylhs c_yylhs
106#define yylen c_yylen
107#define yydefred c_yydefred
108#define yydgoto c_yydgoto
109#define yysindex c_yysindex
110#define yyrindex c_yyrindex
111#define yygindex c_yygindex
112#define yytable c_yytable
113#define yycheck c_yycheck
114
115#ifndef YYDEBUG
116#define YYDEBUG 0 /* Default to no yydebug support */
117#endif
118
119int
120yyparse PARAMS ((void));
121
122static int
123yylex PARAMS ((void));
124
125void
126yyerror PARAMS ((char *));
127
128
129#line 120 "c-exp.y"
130typedef union
131 {
132 LONGEST lval;
133 struct {
134 LONGEST val;
135 struct type *type;
136 } typed_val_int;
137 struct {
138 DOUBLEST dval;
139 struct type *type;
140 } typed_val_float;
141 struct symbol *sym;
142 struct type *tval;
143 struct stoken sval;
144 struct ttype tsym;
145 struct symtoken ssym;
146 int voidval;
147 struct block *bval;
148 enum exp_opcode opcode;
149 struct internalvar *ivar;
150
151 struct type **tvec;
152 int *ivec;
153 } YYSTYPE;
154#line 145 "c-exp.y"
155
156/* YYSTYPE gets defined by %union */
157static int
158parse_number PARAMS ((char *, int, int, YYSTYPE *));
159#include <stdio.h>
160
161#ifndef __cplusplus
162#ifndef __STDC__
163#define const
164#endif
165#endif
166
167
168
169#define YYFINAL 214
170#define YYFLAG -32768
171#define YYNTBASE 69
172
173#define YYTRANSLATE(x) ((unsigned)(x) <= 299 ? yytranslate[x] : 91)
174
175static const char yytranslate[] = { 0,
176 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
177 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
178 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
179 2, 2, 62, 2, 2, 2, 52, 38, 2, 59,
180 65, 50, 48, 30, 49, 57, 51, 2, 2, 2,
181 2, 2, 2, 2, 2, 2, 2, 68, 2, 41,
182 32, 42, 33, 47, 2, 2, 2, 2, 2, 2,
183 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
184 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
185 58, 2, 64, 37, 2, 2, 2, 2, 2, 2,
186 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
187 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
188 2, 2, 66, 36, 67, 63, 2, 2, 2, 2,
189 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
190 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
191 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
192 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
193 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
194 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
195 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
196 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
197 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
198 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
199 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
200 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
201 2, 2, 2, 2, 2, 1, 2, 3, 4, 5,
202 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
203 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
204 26, 27, 28, 29, 31, 34, 35, 39, 40, 43,
205 44, 45, 46, 53, 54, 55, 56, 60, 61
206};
207
208#if YYDEBUG != 0
209static const short yyprhs[] = { 0,
210 0, 2, 4, 6, 8, 12, 15, 18, 21, 24,
211 27, 30, 33, 36, 39, 42, 46, 50, 55, 59,
212 63, 68, 73, 74, 80, 82, 83, 85, 89, 91,
213 95, 100, 105, 109, 113, 117, 121, 125, 129, 133,
214 137, 141, 145, 149, 153, 157, 161, 165, 169, 173,
215 177, 181, 185, 191, 195, 199, 201, 203, 205, 207,
216 209, 214, 216, 218, 220, 222, 224, 226, 230, 234,
217 238, 243, 245, 248, 250, 252, 255, 258, 261, 265,
218 269, 271, 274, 276, 279, 281, 285, 288, 290, 293,
219 295, 298, 302, 305, 309, 311, 315, 317, 319, 321,
220 323, 326, 330, 333, 337, 341, 346, 349, 353, 355,
221 358, 361, 364, 367, 370, 373, 375, 378, 380, 386,
222 389, 392, 394, 396, 398, 400, 402, 406, 408, 410,
223 412, 414, 416
224};
225
226static const short yyrhs[] = { 71,
227 0, 70, 0, 85, 0, 72, 0, 71, 30, 72,
228 0, 50, 72, 0, 38, 72, 0, 49, 72, 0,
229 62, 72, 0, 63, 72, 0, 54, 72, 0, 55,
230 72, 0, 72, 54, 0, 72, 55, 0, 13, 72,
231 0, 72, 56, 89, 0, 72, 56, 79, 0, 72,
232 56, 50, 72, 0, 72, 57, 89, 0, 72, 57,
233 79, 0, 72, 57, 50, 72, 0, 72, 58, 71,
234 64, 0, 0, 72, 59, 73, 75, 65, 0, 66,
235 0, 0, 72, 0, 75, 30, 72, 0, 67, 0,
236 74, 75, 76, 0, 74, 85, 76, 72, 0, 59,
237 85, 65, 72, 0, 59, 71, 65, 0, 72, 47,
238 72, 0, 72, 50, 72, 0, 72, 51, 72, 0,
239 72, 52, 72, 0, 72, 48, 72, 0, 72, 49,
240 72, 0, 72, 45, 72, 0, 72, 46, 72, 0,
241 72, 39, 72, 0, 72, 40, 72, 0, 72, 43,
242 72, 0, 72, 44, 72, 0, 72, 41, 72, 0,
243 72, 42, 72, 0, 72, 38, 72, 0, 72, 37,
244 72, 0, 72, 36, 72, 0, 72, 35, 72, 0,
245 72, 34, 72, 0, 72, 33, 72, 68, 72, 0,
246 72, 32, 72, 0, 72, 26, 72, 0, 3, 0,
247 8, 0, 4, 0, 78, 0, 25, 0, 13, 59,
248 85, 65, 0, 5, 0, 27, 0, 28, 0, 29,
249 0, 60, 0, 61, 0, 77, 15, 89, 0, 77,
250 15, 89, 0, 86, 15, 89, 0, 86, 15, 63,
251 89, 0, 79, 0, 15, 89, 0, 90, 0, 86,
252 0, 86, 22, 0, 86, 23, 0, 86, 81, 0,
253 86, 22, 81, 0, 86, 23, 81, 0, 50, 0,
254 50, 81, 0, 38, 0, 38, 81, 0, 82, 0,
255 59, 81, 65, 0, 82, 83, 0, 83, 0, 82,
256 84, 0, 84, 0, 58, 64, 0, 58, 3, 64,
257 0, 59, 65, 0, 59, 88, 65, 0, 80, 0,
258 86, 15, 50, 0, 7, 0, 21, 0, 19, 0,
259 20, 0, 19, 21, 0, 14, 19, 21, 0, 19,
260 19, 0, 19, 19, 21, 0, 14, 19, 19, 0,
261 14, 19, 19, 21, 0, 20, 21, 0, 14, 20,
262 21, 0, 24, 0, 19, 24, 0, 9, 89, 0,
263 10, 89, 0, 11, 89, 0, 12, 89, 0, 14,
264 87, 0, 14, 0, 18, 87, 0, 18, 0, 16,
265 89, 41, 85, 42, 0, 22, 86, 0, 23, 86,
266 0, 7, 0, 21, 0, 19, 0, 20, 0, 85,
267 0, 88, 30, 85, 0, 6, 0, 60, 0, 7,
268 0, 8, 0, 6, 0, 60, 0
269};
270
271#endif
272
273#if YYDEBUG != 0
274static const short yyrline[] = { 0,
275 230, 231, 234, 241, 242, 247, 250, 253, 257, 261,
276 265, 269, 273, 277, 281, 285, 291, 299, 303, 309,
277 317, 321, 325, 329, 335, 339, 342, 346, 350, 353,
278 360, 366, 372, 378, 382, 386, 390, 394, 398, 402,
279 406, 410, 414, 418, 422, 426, 430, 434, 438, 442,
280 446, 450, 454, 458, 462, 468, 475, 486, 493, 496,
281 500, 508, 533, 538, 545, 554, 562, 568, 579, 595,
282 608, 632, 633, 667, 725, 731, 732, 733, 735, 737,
283 741, 743, 745, 747, 749, 752, 754, 759, 766, 768,
284 772, 774, 778, 780, 792, 793, 798, 800, 802, 804,
285 806, 808, 810, 812, 814, 816, 818, 820, 822, 824,
286 826, 829, 832, 835, 838, 840, 842, 844, 849, 856,
287 857, 860, 861, 867, 873, 882, 887, 894, 895, 896,
288 897, 900, 901
289};
290#endif
291
292
293#if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
294
295static const char * const yytname[] = { "$","error","$undefined.","INT","FLOAT",
296"STRING","NAME","TYPENAME","NAME_OR_INT","STRUCT","CLASS","UNION","ENUM","SIZEOF",
297"UNSIGNED","COLONCOLON","TEMPLATE","ERROR","SIGNED_KEYWORD","LONG","SHORT","INT_KEYWORD",
298"CONST_KEYWORD","VOLATILE_KEYWORD","DOUBLE_KEYWORD","VARIABLE","ASSIGN_MODIFY",
299"THIS","TRUEKEYWORD","FALSEKEYWORD","','","ABOVE_COMMA","'='","'?'","OROR","ANDAND",
300"'|'","'^'","'&'","EQUAL","NOTEQUAL","'<'","'>'","LEQ","GEQ","LSH","RSH","'@'",
301"'+'","'-'","'*'","'/'","'%'","UNARY","INCREMENT","DECREMENT","ARROW","'.'",
302"'['","'('","BLOCKNAME","FILENAME","'!'","'~'","']'","')'","'{'","'}'","':'",
303"start","type_exp","exp1","exp","@1","lcurly","arglist","rcurly","block","variable",
304"qualified_name","ptype","abs_decl","direct_abs_decl","array_mod","func_mod",
305"type","typebase","typename","nonempty_typelist","name","name_not_typename", NULL
306};
307#endif
308
309static const short yyr1[] = { 0,
310 69, 69, 70, 71, 71, 72, 72, 72, 72, 72,
311 72, 72, 72, 72, 72, 72, 72, 72, 72, 72,
312 72, 72, 73, 72, 74, 75, 75, 75, 76, 72,
313 72, 72, 72, 72, 72, 72, 72, 72, 72, 72,
314 72, 72, 72, 72, 72, 72, 72, 72, 72, 72,
315 72, 72, 72, 72, 72, 72, 72, 72, 72, 72,
316 72, 72, 72, 72, 72, 77, 77, 77, 78, 79,
317 79, 78, 78, 78, 80, 80, 80, 80, 80, 80,
318 81, 81, 81, 81, 81, 82, 82, 82, 82, 82,
319 83, 83, 84, 84, 85, 85, 86, 86, 86, 86,
320 86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
321 86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
322 86, 87, 87, 87, 87, 88, 88, 89, 89, 89,
323 89, 90, 90
324};
325
326static const short yyr2[] = { 0,
327 1, 1, 1, 1, 3, 2, 2, 2, 2, 2,
328 2, 2, 2, 2, 2, 3, 3, 4, 3, 3,
329 4, 4, 0, 5, 1, 0, 1, 3, 1, 3,
330 4, 4, 3, 3, 3, 3, 3, 3, 3, 3,
331 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
332 3, 3, 5, 3, 3, 1, 1, 1, 1, 1,
333 4, 1, 1, 1, 1, 1, 1, 3, 3, 3,
334 4, 1, 2, 1, 1, 2, 2, 2, 3, 3,
335 1, 2, 1, 2, 1, 3, 2, 1, 2, 1,
336 2, 3, 2, 3, 1, 3, 1, 1, 1, 1,
337 2, 3, 2, 3, 3, 4, 2, 3, 1, 2,
338 2, 2, 2, 2, 2, 1, 2, 1, 5, 2,
339 2, 1, 1, 1, 1, 1, 3, 1, 1, 1,
340 1, 1, 1
341};
342
343static const short yydefact[] = { 0,
344 56, 58, 62, 132, 97, 57, 0, 0, 0, 0,
345 0, 116, 0, 0, 118, 99, 100, 98, 0, 0,
346 109, 60, 63, 64, 65, 0, 0, 0, 0, 0,
347 0, 133, 67, 0, 0, 25, 2, 1, 4, 26,
348 0, 59, 72, 95, 3, 75, 74, 128, 130, 131,
349 129, 111, 112, 113, 114, 0, 15, 0, 122, 124,
350 125, 123, 115, 73, 0, 124, 125, 117, 103, 101,
351 110, 107, 120, 121, 7, 8, 6, 11, 12, 0,
352 0, 9, 10, 0, 0, 0, 0, 0, 0, 0,
353 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
354 0, 0, 0, 0, 0, 0, 13, 14, 0, 0,
355 0, 23, 27, 0, 0, 0, 0, 76, 77, 83,
356 81, 0, 0, 78, 85, 88, 90, 0, 0, 105,
357 102, 108, 0, 104, 33, 0, 5, 55, 54, 0,
358 52, 51, 50, 49, 48, 42, 43, 46, 47, 44,
359 45, 40, 41, 34, 38, 39, 35, 36, 37, 130,
360 0, 17, 16, 0, 20, 19, 0, 26, 0, 29,
361 30, 0, 69, 96, 0, 70, 79, 80, 84, 82,
362 0, 91, 93, 0, 126, 75, 0, 0, 87, 89,
363 61, 106, 0, 32, 0, 18, 21, 22, 0, 28,
364 31, 71, 92, 86, 0, 0, 94, 119, 53, 24,
365 127, 0, 0, 0
366};
367
368static const short yydefgoto[] = { 212,
369 37, 80, 39, 168, 40, 114, 171, 41, 42, 43,
370 44, 124, 125, 126, 127, 185, 58, 63, 187, 176,
371 47
372};
373
374static const short yypact[] = { 205,
375-32768,-32768,-32768,-32768,-32768,-32768, 46, 46, 46, 46,
376 269, 57, 46, 46, 100, 134, -14,-32768, 228, 228,
377-32768,-32768,-32768,-32768,-32768, 205, 205, 205, 205, 205,
378 205, 21,-32768, 205, 205,-32768,-32768, -16, 504, 205,
379 22,-32768,-32768,-32768,-32768, 107,-32768,-32768,-32768,-32768,
380-32768,-32768,-32768,-32768,-32768, 205, 14, 23,-32768, 7,
381 24,-32768,-32768,-32768, 10,-32768,-32768,-32768, 34,-32768,
382-32768,-32768,-32768,-32768, 14, 14, 14, 14, 14, -26,
383 -21, 14, 14, 205, 205, 205, 205, 205, 205, 205,
384 205, 205, 205, 205, 205, 205, 205, 205, 205, 205,
385 205, 205, 205, 205, 205, 205,-32768,-32768, 419, 438,
386 205,-32768, 504, -25, -2, 46, 53, 8, 8, 8,
387 8, -1, 359,-32768, -41,-32768,-32768, 9, 42, 54,
388-32768,-32768, 228,-32768,-32768, 205, 504, 504, 504, 467,
389 556, 580, 603, 625, 646, 665, 665, 254, 254, 254,
390 254, 124, 124, 356, 416, 416, 14, 14, 14, 89,
391 205,-32768,-32768, 205,-32768,-32768, -17, 205, 205,-32768,
392-32768, 205, 93,-32768, 46,-32768,-32768,-32768,-32768,-32768,
393 45,-32768,-32768, 50,-32768, 146, -22, 128,-32768,-32768,
394 333,-32768, 68, 14, 205, 14, 14,-32768, -3, 504,
395 14,-32768,-32768,-32768, 67, 228,-32768,-32768, 531,-32768,
396-32768, 125, 126,-32768
397};
398
399static const short yypgoto[] = {-32768,
400-32768, 3, -5,-32768,-32768, -44, 12,-32768,-32768, -76,
401-32768, 79,-32768, 11, 16, 1, 0, 113,-32768, 2,
402-32768
403};
404
405
406#define YYLAST 724
407
408
409static const short yytable[] = { 46,
410 45, 181, 38, 84, 169, 57, 72, 206, 52, 53,
411 54, 55, 84, 84, 64, 65, 122, 188, 73, 74,
412 75, 76, 77, 78, 79, 130, 169, 131, 82, 83,
413 46, 81, 162, 165, 113, -66, 116, 129, 135, 46,
414 115, 170, 207, 136, 132, 120, 198, 48, 49, 50,
415 133, 48, 49, 50, 134, 46, 128, 121, 48, 49,
416 50, 210, 182, 59, 170, 122, 123, 107, 108, 109,
417 110, 111, 112, 191, 192, 60, 61, 62, 137, 138,
418 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,
419 149, 150, 151, 152, 153, 154, 155, 156, 157, 158,
420 159, 51, 174, -97, 175, 51, 59, -68, 203, 208,
421 163, 166, 51, 167, 204, 175, 174, 173, 66, 67,
422 62, 117, 186, 199, 213, 214, 172, 68, 118, 119,
423 194, 0, 186, 193, 5, 189, 7, 8, 9, 10,
424 190, 12, 0, 14, 120, 15, 16, 17, 18, 19,
425 20, 21, 69, 0, 70, 196, 121, 71, 197, 0,
426 205, 0, 113, 200, 122, 123, 201, 118, 119, 0,
427 101, 102, 103, 104, 105, 106, 202, 107, 108, 109,
428 110, 111, 112, 120, 0, 194, 0, 186, 0, 209,
429 0, 0, 183, 0, 0, 121, 177, 178, 179, 180,
430 0, 184, 0, 122, 123, 186, 211, 1, 2, 3,
431 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
432 14, 0, 15, 16, 17, 18, 19, 20, 21, 22,
433 0, 23, 24, 25, 5, 0, 7, 8, 9, 10,
434 0, 12, 26, 14, 0, 15, 16, 17, 18, 19,
435 20, 21, 0, 27, 28, 0, 0, 0, 29, 30,
436 0, 0, 0, 31, 32, 33, 34, 35, 0, 0,
437 36, 1, 2, 3, 4, 5, 6, 7, 8, 9,
438 10, 11, 12, 13, 14, 0, 15, 16, 17, 18,
439 19, 20, 21, 22, 0, 23, 24, 25, 99, 100,
440 101, 102, 103, 104, 105, 106, 26, 107, 108, 109,
441 110, 111, 112, 0, 0, 0, 0, 27, 28, 0,
442 0, 0, 29, 30, 0, 0, 0, 56, 32, 33,
443 34, 35, 0, 0, 36, 1, 2, 3, 4, 5,
444 6, 7, 8, 9, 10, 11, 12, 13, 14, 0,
445 15, 16, 17, 18, 19, 20, 21, 22, 0, 23,
446 24, 25, 0, 0, 0, 5, 0, 7, 8, 9,
447 10, 0, 12, 0, 14, 0, 15, 16, 17, 18,
448 19, 20, 21, 0, 0, 0, 29, 30, 0, 0,
449 0, 31, 32, 33, 34, 35, 120, 0, 36, 0,
450 0, 0, 0, 102, 103, 104, 105, 106, 121, 107,
451 108, 109, 110, 111, 112, 0, 122, 123, 0, 0,
452 0, 0, 0, 183, 48, 160, 50, 7, 8, 9,
453 10, 0, 12, 0, 14, 0, 15, 16, 17, 18,
454 19, 20, 21, 48, 160, 50, 7, 8, 9, 10,
455 0, 12, 0, 14, 0, 15, 16, 17, 18, 19,
456 20, 21, 0, 0, 0, 104, 105, 106, 161, 107,
457 108, 109, 110, 111, 112, 0, 0, 0, 51, 0,
458 0, 0, 0, 0, 0, 0, 0, 164, 0, 0,
459 0, 0, 85, 0, 0, 0, 0, 51, 86, 87,
460 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
461 98, 99, 100, 101, 102, 103, 104, 105, 106, 0,
462 107, 108, 109, 110, 111, 112, 0, 0, 0, 85,
463 0, 0, 0, 0, 195, 86, 87, 88, 89, 90,
464 91, 92, 93, 94, 95, 96, 97, 98, 99, 100,
465 101, 102, 103, 104, 105, 106, 0, 107, 108, 109,
466 110, 111, 112, 87, 88, 89, 90, 91, 92, 93,
467 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
468 104, 105, 106, 0, 107, 108, 109, 110, 111, 112,
469 89, 90, 91, 92, 93, 94, 95, 96, 97, 98,
470 99, 100, 101, 102, 103, 104, 105, 106, 0, 107,
471 108, 109, 110, 111, 112, 90, 91, 92, 93, 94,
472 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
473 105, 106, 0, 107, 108, 109, 110, 111, 112, 91,
474 92, 93, 94, 95, 96, 97, 98, 99, 100, 101,
475 102, 103, 104, 105, 106, 0, 107, 108, 109, 110,
476 111, 112, 92, 93, 94, 95, 96, 97, 98, 99,
477 100, 101, 102, 103, 104, 105, 106, 0, 107, 108,
478 109, 110, 111, 112, 93, 94, 95, 96, 97, 98,
479 99, 100, 101, 102, 103, 104, 105, 106, 0, 107,
480 108, 109, 110, 111, 112, 95, 96, 97, 98, 99,
481 100, 101, 102, 103, 104, 105, 106, 0, 107, 108,
482 109, 110, 111, 112
483};
484
485static const short yycheck[] = { 0,
486 0, 3, 0, 30, 30, 11, 21, 30, 7, 8,
487 9, 10, 30, 30, 13, 14, 58, 59, 19, 20,
488 26, 27, 28, 29, 30, 19, 30, 21, 34, 35,
489 31, 31, 109, 110, 40, 15, 15, 15, 65, 40,
490 40, 67, 65, 65, 21, 38, 64, 6, 7, 8,
491 41, 6, 7, 8, 21, 56, 56, 50, 6, 7,
492 8, 65, 64, 7, 67, 58, 59, 54, 55, 56,
493 57, 58, 59, 65, 21, 19, 20, 21, 84, 85,
494 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
495 96, 97, 98, 99, 100, 101, 102, 103, 104, 105,
496 106, 60, 50, 15, 63, 60, 7, 15, 64, 42,
497 109, 110, 60, 111, 65, 63, 50, 116, 19, 20,
498 21, 15, 123, 168, 0, 0, 115, 15, 22, 23,
499 136, -1, 133, 133, 7, 125, 9, 10, 11, 12,
500 125, 14, -1, 16, 38, 18, 19, 20, 21, 22,
501 23, 24, 19, -1, 21, 161, 50, 24, 164, -1,
502 15, -1, 168, 169, 58, 59, 172, 22, 23, -1,
503 47, 48, 49, 50, 51, 52, 175, 54, 55, 56,
504 57, 58, 59, 38, -1, 191, -1, 188, -1, 195,
505 -1, -1, 65, -1, -1, 50, 118, 119, 120, 121,
506 -1, 123, -1, 58, 59, 206, 206, 3, 4, 5,
507 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
508 16, -1, 18, 19, 20, 21, 22, 23, 24, 25,
509 -1, 27, 28, 29, 7, -1, 9, 10, 11, 12,
510 -1, 14, 38, 16, -1, 18, 19, 20, 21, 22,
511 23, 24, -1, 49, 50, -1, -1, -1, 54, 55,
512 -1, -1, -1, 59, 60, 61, 62, 63, -1, -1,
513 66, 3, 4, 5, 6, 7, 8, 9, 10, 11,
514 12, 13, 14, 15, 16, -1, 18, 19, 20, 21,
515 22, 23, 24, 25, -1, 27, 28, 29, 45, 46,
516 47, 48, 49, 50, 51, 52, 38, 54, 55, 56,
517 57, 58, 59, -1, -1, -1, -1, 49, 50, -1,
518 -1, -1, 54, 55, -1, -1, -1, 59, 60, 61,
519 62, 63, -1, -1, 66, 3, 4, 5, 6, 7,
520 8, 9, 10, 11, 12, 13, 14, 15, 16, -1,
521 18, 19, 20, 21, 22, 23, 24, 25, -1, 27,
522 28, 29, -1, -1, -1, 7, -1, 9, 10, 11,
523 12, -1, 14, -1, 16, -1, 18, 19, 20, 21,
524 22, 23, 24, -1, -1, -1, 54, 55, -1, -1,
525 -1, 59, 60, 61, 62, 63, 38, -1, 66, -1,
526 -1, -1, -1, 48, 49, 50, 51, 52, 50, 54,
527 55, 56, 57, 58, 59, -1, 58, 59, -1, -1,
528 -1, -1, -1, 65, 6, 7, 8, 9, 10, 11,
529 12, -1, 14, -1, 16, -1, 18, 19, 20, 21,
530 22, 23, 24, 6, 7, 8, 9, 10, 11, 12,
531 -1, 14, -1, 16, -1, 18, 19, 20, 21, 22,
532 23, 24, -1, -1, -1, 50, 51, 52, 50, 54,
533 55, 56, 57, 58, 59, -1, -1, -1, 60, -1,
534 -1, -1, -1, -1, -1, -1, -1, 50, -1, -1,
535 -1, -1, 26, -1, -1, -1, -1, 60, 32, 33,
536 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
537 44, 45, 46, 47, 48, 49, 50, 51, 52, -1,
538 54, 55, 56, 57, 58, 59, -1, -1, -1, 26,
539 -1, -1, -1, -1, 68, 32, 33, 34, 35, 36,
540 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
541 47, 48, 49, 50, 51, 52, -1, 54, 55, 56,
542 57, 58, 59, 33, 34, 35, 36, 37, 38, 39,
543 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
544 50, 51, 52, -1, 54, 55, 56, 57, 58, 59,
545 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
546 45, 46, 47, 48, 49, 50, 51, 52, -1, 54,
547 55, 56, 57, 58, 59, 36, 37, 38, 39, 40,
548 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
549 51, 52, -1, 54, 55, 56, 57, 58, 59, 37,
550 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
551 48, 49, 50, 51, 52, -1, 54, 55, 56, 57,
552 58, 59, 38, 39, 40, 41, 42, 43, 44, 45,
553 46, 47, 48, 49, 50, 51, 52, -1, 54, 55,
554 56, 57, 58, 59, 39, 40, 41, 42, 43, 44,
555 45, 46, 47, 48, 49, 50, 51, 52, -1, 54,
556 55, 56, 57, 58, 59, 41, 42, 43, 44, 45,
557 46, 47, 48, 49, 50, 51, 52, -1, 54, 55,
558 56, 57, 58, 59
559};
560/* -*-C-*- Note some compilers choke on comments on `#line' lines. */
561#line 3 "/stone/jimb/main-98r2/share/bison.simple"
562
563/* Skeleton output parser for bison,
564 Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
565
566 This program is free software; you can redistribute it and/or modify
567 it under the terms of the GNU General Public License as published by
568 the Free Software Foundation; either version 2, or (at your option)
569 any later version.
570
571 This program is distributed in the hope that it will be useful,
572 but WITHOUT ANY WARRANTY; without even the implied warranty of
573 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
574 GNU General Public License for more details.
575
576 You should have received a copy of the GNU General Public License
577 along with this program; if not, write to the Free Software
578 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
579
580/* As a special exception, when this file is copied by Bison into a
581 Bison output file, you may use that output file without restriction.
582 This special exception was added by the Free Software Foundation
583 in version 1.24 of Bison. */
584
585#ifndef alloca
586#ifdef __GNUC__
587#define alloca __builtin_alloca
588#else /* not GNU C. */
589#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi)
590#include <alloca.h>
591#else /* not sparc */
592#if defined (MSDOS) && !defined (__TURBOC__)
593#else /* not MSDOS, or __TURBOC__ */
594#if defined(_AIX)
595 #pragma alloca
596#else /* not MSDOS, __TURBOC__, or _AIX */
597#ifdef __hpux
598#ifdef __cplusplus
599extern "C" {
600void *alloca (unsigned int);
601};
602#else /* not __cplusplus */
603void *alloca ();
604#endif /* not __cplusplus */
605#endif /* __hpux */
606#endif /* not _AIX */
607#endif /* not MSDOS, or __TURBOC__ */
608#endif /* not sparc. */
609#endif /* not GNU C. */
610#endif /* alloca not defined. */
611
612/* This is the parser code that is written into each bison parser
613 when the %semantic_parser declaration is not specified in the grammar.
614 It was written by Richard Stallman by simplifying the hairy parser
615 used when %semantic_parser is specified. */
616
617/* Note: there must be only one dollar sign in this file.
618 It is replaced by the list of actions, each action
619 as one case of the switch. */
620
621#define yyerrok (yyerrstatus = 0)
622#define yyclearin (yychar = YYEMPTY)
623#define YYEMPTY -2
624#define YYEOF 0
625#define YYACCEPT return(0)
626#define YYABORT return(1)
627#define YYERROR goto yyerrlab1
628/* Like YYERROR except do call yyerror.
629 This remains here temporarily to ease the
630 transition to the new meaning of YYERROR, for GCC.
631 Once GCC version 2 has supplanted version 1, this can go. */
632#define YYFAIL goto yyerrlab
633#define YYRECOVERING() (!!yyerrstatus)
634#define YYBACKUP(token, value) \
635do \
636 if (yychar == YYEMPTY && yylen == 1) \
637 { yychar = (token), yylval = (value); \
638 yychar1 = YYTRANSLATE (yychar); \
639 YYPOPSTACK; \
640 goto yybackup; \
641 } \
642 else \
643 { yyerror ("syntax error: cannot back up"); YYERROR; } \
644while (0)
645
646#define YYTERROR 1
647#define YYERRCODE 256
648
649#ifndef YYPURE
650#define YYLEX yylex()
651#endif
652
653#ifdef YYPURE
654#ifdef YYLSP_NEEDED
655#ifdef YYLEX_PARAM
656#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM)
657#else
658#define YYLEX yylex(&yylval, &yylloc)
659#endif
660#else /* not YYLSP_NEEDED */
661#ifdef YYLEX_PARAM
662#define YYLEX yylex(&yylval, YYLEX_PARAM)
663#else
664#define YYLEX yylex(&yylval)
665#endif
666#endif /* not YYLSP_NEEDED */
667#endif
668
669/* If nonreentrant, generate the variables here */
670
671#ifndef YYPURE
672
673int yychar; /* the lookahead symbol */
674YYSTYPE yylval; /* the semantic value of the */
675 /* lookahead symbol */
676
677#ifdef YYLSP_NEEDED
678YYLTYPE yylloc; /* location data for the lookahead */
679 /* symbol */
680#endif
681
682int yynerrs; /* number of parse errors so far */
683#endif /* not YYPURE */
684
685#if YYDEBUG != 0
686int yydebug; /* nonzero means print parse trace */
687/* Since this is uninitialized, it does not stop multiple parsers
688 from coexisting. */
689#endif
690
691/* YYINITDEPTH indicates the initial size of the parser's stacks */
692
693#ifndef YYINITDEPTH
694#define YYINITDEPTH 200
695#endif
696
697/* YYMAXDEPTH is the maximum size the stacks can grow to
698 (effective only if the built-in stack extension method is used). */
699
700#if YYMAXDEPTH == 0
701#undef YYMAXDEPTH
702#endif
703
704#ifndef YYMAXDEPTH
705#define YYMAXDEPTH 10000
706#endif
707
708/* Prevent warning if -Wstrict-prototypes. */
709#ifdef __GNUC__
710int yyparse (void);
711#endif
712\f
713#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
714#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT)
715#else /* not GNU C or C++ */
716#ifndef __cplusplus
717
718/* This is the most reliable way to avoid incompatibilities
719 in available built-in functions on various systems. */
720static void
721__yy_memcpy (to, from, count)
722 char *to;
723 char *from;
724 int count;
725{
726 register char *f = from;
727 register char *t = to;
728 register int i = count;
729
730 while (i-- > 0)
731 *t++ = *f++;
732}
733
734#else /* __cplusplus */
735
736/* This is the most reliable way to avoid incompatibilities
737 in available built-in functions on various systems. */
738static void
739__yy_memcpy (char *to, char *from, int count)
740{
741 register char *f = from;
742 register char *t = to;
743 register int i = count;
744
745 while (i-- > 0)
746 *t++ = *f++;
747}
748
749#endif
750#endif
751\f
752#line 196 "/stone/jimb/main-98r2/share/bison.simple"
753
754/* The user can define YYPARSE_PARAM as the name of an argument to be passed
755 into yyparse. The argument should have type void *.
756 It should actually point to an object.
757 Grammar actions can access the variable by casting it
758 to the proper pointer type. */
759
760#ifdef YYPARSE_PARAM
761#ifdef __cplusplus
762#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
763#define YYPARSE_PARAM_DECL
764#else /* not __cplusplus */
765#define YYPARSE_PARAM_ARG YYPARSE_PARAM
766#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
767#endif /* not __cplusplus */
768#else /* not YYPARSE_PARAM */
769#define YYPARSE_PARAM_ARG
770#define YYPARSE_PARAM_DECL
771#endif /* not YYPARSE_PARAM */
772
773int
774yyparse(YYPARSE_PARAM_ARG)
775 YYPARSE_PARAM_DECL
776{
777 register int yystate;
778 register int yyn;
779 register short *yyssp;
780 register YYSTYPE *yyvsp;
781 int yyerrstatus; /* number of tokens to shift before error messages enabled */
782 int yychar1 = 0; /* lookahead token as an internal (translated) token number */
783
784 short yyssa[YYINITDEPTH]; /* the state stack */
785 YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */
786
787 short *yyss = yyssa; /* refer to the stacks thru separate pointers */
788 YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to xreallocate them elsewhere */
789
790#ifdef YYLSP_NEEDED
791 YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */
792 YYLTYPE *yyls = yylsa;
793 YYLTYPE *yylsp;
794
795#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
796#else
797#define YYPOPSTACK (yyvsp--, yyssp--)
798#endif
799
800 int yystacksize = YYINITDEPTH;
801
802#ifdef YYPURE
803 int yychar;
804 YYSTYPE yylval;
805 int yynerrs;
806#ifdef YYLSP_NEEDED
807 YYLTYPE yylloc;
808#endif
809#endif
810
811 YYSTYPE yyval; /* the variable used to return */
812 /* semantic values from the action */
813 /* routines */
814
815 int yylen;
816
817#if YYDEBUG != 0
818 if (yydebug)
819 fprintf(stderr, "Starting parse\n");
820#endif
821
822 yystate = 0;
823 yyerrstatus = 0;
824 yynerrs = 0;
825 yychar = YYEMPTY; /* Cause a token to be read. */
826
827 /* Initialize stack pointers.
828 Waste one element of value and location stack
829 so that they stay on the same level as the state stack.
830 The wasted elements are never initialized. */
831
832 yyssp = yyss - 1;
833 yyvsp = yyvs;
834#ifdef YYLSP_NEEDED
835 yylsp = yyls;
836#endif
837
838/* Push a new state, which is found in yystate . */
839/* In all cases, when you get here, the value and location stacks
840 have just been pushed. so pushing a state here evens the stacks. */
841yynewstate:
842
843 *++yyssp = yystate;
844
845 if (yyssp >= yyss + yystacksize - 1)
846 {
847 /* Give user a chance to xreallocate the stack */
848 /* Use copies of these so that the &'s don't force the real ones into memory. */
849 YYSTYPE *yyvs1 = yyvs;
850 short *yyss1 = yyss;
851#ifdef YYLSP_NEEDED
852 YYLTYPE *yyls1 = yyls;
853#endif
854
855 /* Get the current used size of the three stacks, in elements. */
856 int size = yyssp - yyss + 1;
857
858#ifdef yyoverflow
859 /* Each stack pointer address is followed by the size of
860 the data in use in that stack, in bytes. */
861#ifdef YYLSP_NEEDED
862 /* This used to be a conditional around just the two extra args,
863 but that might be undefined if yyoverflow is a macro. */
864 yyoverflow("parser stack overflow",
865 &yyss1, size * sizeof (*yyssp),
866 &yyvs1, size * sizeof (*yyvsp),
867 &yyls1, size * sizeof (*yylsp),
868 &yystacksize);
869#else
870 yyoverflow("parser stack overflow",
871 &yyss1, size * sizeof (*yyssp),
872 &yyvs1, size * sizeof (*yyvsp),
873 &yystacksize);
874#endif
875
876 yyss = yyss1; yyvs = yyvs1;
877#ifdef YYLSP_NEEDED
878 yyls = yyls1;
879#endif
880#else /* no yyoverflow */
881 /* Extend the stack our own way. */
882 if (yystacksize >= YYMAXDEPTH)
883 {
884 yyerror("parser stack overflow");
885 return 2;
886 }
887 yystacksize *= 2;
888 if (yystacksize > YYMAXDEPTH)
889 yystacksize = YYMAXDEPTH;
890 yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
891 __yy_memcpy ((char *)yyss, (char *)yyss1, size * sizeof (*yyssp));
892 yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
893 __yy_memcpy ((char *)yyvs, (char *)yyvs1, size * sizeof (*yyvsp));
894#ifdef YYLSP_NEEDED
895 yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
896 __yy_memcpy ((char *)yyls, (char *)yyls1, size * sizeof (*yylsp));
897#endif
898#endif /* no yyoverflow */
899
900 yyssp = yyss + size - 1;
901 yyvsp = yyvs + size - 1;
902#ifdef YYLSP_NEEDED
903 yylsp = yyls + size - 1;
904#endif
905
906#if YYDEBUG != 0
907 if (yydebug)
908 fprintf(stderr, "Stack size increased to %d\n", yystacksize);
909#endif
910
911 if (yyssp >= yyss + yystacksize - 1)
912 YYABORT;
913 }
914
915#if YYDEBUG != 0
916 if (yydebug)
917 fprintf(stderr, "Entering state %d\n", yystate);
918#endif
919
920 goto yybackup;
921 yybackup:
922
923/* Do appropriate processing given the current state. */
924/* Read a lookahead token if we need one and don't already have one. */
925/* yyresume: */
926
927 /* First try to decide what to do without reference to lookahead token. */
928
929 yyn = yypact[yystate];
930 if (yyn == YYFLAG)
931 goto yydefault;
932
933 /* Not known => get a lookahead token if don't already have one. */
934
935 /* yychar is either YYEMPTY or YYEOF
936 or a valid token in external form. */
937
938 if (yychar == YYEMPTY)
939 {
940#if YYDEBUG != 0
941 if (yydebug)
942 fprintf(stderr, "Reading a token: ");
943#endif
944 yychar = YYLEX;
945 }
946
947 /* Convert token to internal form (in yychar1) for indexing tables with */
948
949 if (yychar <= 0) /* This means end of input. */
950 {
951 yychar1 = 0;
952 yychar = YYEOF; /* Don't call YYLEX any more */
953
954#if YYDEBUG != 0
955 if (yydebug)
956 fprintf(stderr, "Now at end of input.\n");
957#endif
958 }
959 else
960 {
961 yychar1 = YYTRANSLATE(yychar);
962
963#if YYDEBUG != 0
964 if (yydebug)
965 {
966 fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
967 /* Give the individual parser a way to print the precise meaning
968 of a token, for further debugging info. */
969#ifdef YYPRINT
970 YYPRINT (stderr, yychar, yylval);
971#endif
972 fprintf (stderr, ")\n");
973 }
974#endif
975 }
976
977 yyn += yychar1;
978 if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
979 goto yydefault;
980
981 yyn = yytable[yyn];
982
983 /* yyn is what to do for this token type in this state.
984 Negative => reduce, -yyn is rule number.
985 Positive => shift, yyn is new state.
986 New state is final state => don't bother to shift,
987 just return success.
988 0, or most negative number => error. */
989
990 if (yyn < 0)
991 {
992 if (yyn == YYFLAG)
993 goto yyerrlab;
994 yyn = -yyn;
995 goto yyreduce;
996 }
997 else if (yyn == 0)
998 goto yyerrlab;
999
1000 if (yyn == YYFINAL)
1001 YYACCEPT;
1002
1003 /* Shift the lookahead token. */
1004
1005#if YYDEBUG != 0
1006 if (yydebug)
1007 fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
1008#endif
1009
1010 /* Discard the token being shifted unless it is eof. */
1011 if (yychar != YYEOF)
1012 yychar = YYEMPTY;
1013
1014 *++yyvsp = yylval;
1015#ifdef YYLSP_NEEDED
1016 *++yylsp = yylloc;
1017#endif
1018
1019 /* count tokens shifted since error; after three, turn off error status. */
1020 if (yyerrstatus) yyerrstatus--;
1021
1022 yystate = yyn;
1023 goto yynewstate;
1024
1025/* Do the default action for the current state. */
1026yydefault:
1027
1028 yyn = yydefact[yystate];
1029 if (yyn == 0)
1030 goto yyerrlab;
1031
1032/* Do a reduction. yyn is the number of a rule to reduce with. */
1033yyreduce:
1034 yylen = yyr2[yyn];
1035 if (yylen > 0)
1036 yyval = yyvsp[1-yylen]; /* implement default value of the action */
1037
1038#if YYDEBUG != 0
1039 if (yydebug)
1040 {
1041 int i;
1042
1043 fprintf (stderr, "Reducing via rule %d (line %d), ",
1044 yyn, yyrline[yyn]);
1045
1046 /* Print the symbols being reduced, and their result. */
1047 for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
1048 fprintf (stderr, "%s ", yytname[yyrhs[i]]);
1049 fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
1050 }
1051#endif
1052
1053
1054 switch (yyn) {
1055
1056case 3:
1057#line 235 "c-exp.y"
1058{ write_exp_elt_opcode(OP_TYPE);
1059 write_exp_elt_type(yyvsp[0].tval);
1060 write_exp_elt_opcode(OP_TYPE);;
1061 break;}
1062case 5:
1063#line 243 "c-exp.y"
1064{ write_exp_elt_opcode (BINOP_COMMA); ;
1065 break;}
1066case 6:
1067#line 248 "c-exp.y"
1068{ write_exp_elt_opcode (UNOP_IND); ;
1069 break;}
1070case 7:
1071#line 251 "c-exp.y"
1072{ write_exp_elt_opcode (UNOP_ADDR); ;
1073 break;}
1074case 8:
1075#line 254 "c-exp.y"
1076{ write_exp_elt_opcode (UNOP_NEG); ;
1077 break;}
1078case 9:
1079#line 258 "c-exp.y"
1080{ write_exp_elt_opcode (UNOP_LOGICAL_NOT); ;
1081 break;}
1082case 10:
1083#line 262 "c-exp.y"
1084{ write_exp_elt_opcode (UNOP_COMPLEMENT); ;
1085 break;}
1086case 11:
1087#line 266 "c-exp.y"
1088{ write_exp_elt_opcode (UNOP_PREINCREMENT); ;
1089 break;}
1090case 12:
1091#line 270 "c-exp.y"
1092{ write_exp_elt_opcode (UNOP_PREDECREMENT); ;
1093 break;}
1094case 13:
1095#line 274 "c-exp.y"
1096{ write_exp_elt_opcode (UNOP_POSTINCREMENT); ;
1097 break;}
1098case 14:
1099#line 278 "c-exp.y"
1100{ write_exp_elt_opcode (UNOP_POSTDECREMENT); ;
1101 break;}
1102case 15:
1103#line 282 "c-exp.y"
1104{ write_exp_elt_opcode (UNOP_SIZEOF); ;
1105 break;}
1106case 16:
1107#line 286 "c-exp.y"
1108{ write_exp_elt_opcode (STRUCTOP_PTR);
1109 write_exp_string (yyvsp[0].sval);
1110 write_exp_elt_opcode (STRUCTOP_PTR); ;
1111 break;}
1112case 17:
1113#line 292 "c-exp.y"
1114{ /* exp->type::name becomes exp->*(&type::name) */
1115 /* Note: this doesn't work if name is a
1116 static member! FIXME */
1117 write_exp_elt_opcode (UNOP_ADDR);
1118 write_exp_elt_opcode (STRUCTOP_MPTR); ;
1119 break;}
1120case 18:
1121#line 300 "c-exp.y"
1122{ write_exp_elt_opcode (STRUCTOP_MPTR); ;
1123 break;}
1124case 19:
1125#line 304 "c-exp.y"
1126{ write_exp_elt_opcode (STRUCTOP_STRUCT);
1127 write_exp_string (yyvsp[0].sval);
1128 write_exp_elt_opcode (STRUCTOP_STRUCT); ;
1129 break;}
1130case 20:
1131#line 310 "c-exp.y"
1132{ /* exp.type::name becomes exp.*(&type::name) */
1133 /* Note: this doesn't work if name is a
1134 static member! FIXME */
1135 write_exp_elt_opcode (UNOP_ADDR);
1136 write_exp_elt_opcode (STRUCTOP_MEMBER); ;
1137 break;}
1138case 21:
1139#line 318 "c-exp.y"
1140{ write_exp_elt_opcode (STRUCTOP_MEMBER); ;
1141 break;}
1142case 22:
1143#line 322 "c-exp.y"
1144{ write_exp_elt_opcode (BINOP_SUBSCRIPT); ;
1145 break;}
1146case 23:
1147#line 328 "c-exp.y"
1148{ start_arglist (); ;
1149 break;}
1150case 24:
1151#line 330 "c-exp.y"
1152{ write_exp_elt_opcode (OP_FUNCALL);
1153 write_exp_elt_longcst ((LONGEST) end_arglist ());
1154 write_exp_elt_opcode (OP_FUNCALL); ;
1155 break;}
1156case 25:
1157#line 336 "c-exp.y"
1158{ start_arglist (); ;
1159 break;}
1160case 27:
1161#line 343 "c-exp.y"
1162{ arglist_len = 1; ;
1163 break;}
1164case 28:
1165#line 347 "c-exp.y"
1166{ arglist_len++; ;
1167 break;}
1168case 29:
1169#line 351 "c-exp.y"
1170{ yyval.lval = end_arglist () - 1; ;
1171 break;}
1172case 30:
1173#line 354 "c-exp.y"
1174{ write_exp_elt_opcode (OP_ARRAY);
1175 write_exp_elt_longcst ((LONGEST) 0);
1176 write_exp_elt_longcst ((LONGEST) yyvsp[0].lval);
1177 write_exp_elt_opcode (OP_ARRAY); ;
1178 break;}
1179case 31:
1180#line 361 "c-exp.y"
1181{ write_exp_elt_opcode (UNOP_MEMVAL);
1182 write_exp_elt_type (yyvsp[-2].tval);
1183 write_exp_elt_opcode (UNOP_MEMVAL); ;
1184 break;}
1185case 32:
1186#line 367 "c-exp.y"
1187{ write_exp_elt_opcode (UNOP_CAST);
1188 write_exp_elt_type (yyvsp[-2].tval);
1189 write_exp_elt_opcode (UNOP_CAST); ;
1190 break;}
1191case 33:
1192#line 373 "c-exp.y"
1193{ ;
1194 break;}
1195case 34:
1196#line 379 "c-exp.y"
1197{ write_exp_elt_opcode (BINOP_REPEAT); ;
1198 break;}
1199case 35:
1200#line 383 "c-exp.y"
1201{ write_exp_elt_opcode (BINOP_MUL); ;
1202 break;}
1203case 36:
1204#line 387 "c-exp.y"
1205{ write_exp_elt_opcode (BINOP_DIV); ;
1206 break;}
1207case 37:
1208#line 391 "c-exp.y"
1209{ write_exp_elt_opcode (BINOP_REM); ;
1210 break;}
1211case 38:
1212#line 395 "c-exp.y"
1213{ write_exp_elt_opcode (BINOP_ADD); ;
1214 break;}
1215case 39:
1216#line 399 "c-exp.y"
1217{ write_exp_elt_opcode (BINOP_SUB); ;
1218 break;}
1219case 40:
1220#line 403 "c-exp.y"
1221{ write_exp_elt_opcode (BINOP_LSH); ;
1222 break;}
1223case 41:
1224#line 407 "c-exp.y"
1225{ write_exp_elt_opcode (BINOP_RSH); ;
1226 break;}
1227case 42:
1228#line 411 "c-exp.y"
1229{ write_exp_elt_opcode (BINOP_EQUAL); ;
1230 break;}
1231case 43:
1232#line 415 "c-exp.y"
1233{ write_exp_elt_opcode (BINOP_NOTEQUAL); ;
1234 break;}
1235case 44:
1236#line 419 "c-exp.y"
1237{ write_exp_elt_opcode (BINOP_LEQ); ;
1238 break;}
1239case 45:
1240#line 423 "c-exp.y"
1241{ write_exp_elt_opcode (BINOP_GEQ); ;
1242 break;}
1243case 46:
1244#line 427 "c-exp.y"
1245{ write_exp_elt_opcode (BINOP_LESS); ;
1246 break;}
1247case 47:
1248#line 431 "c-exp.y"
1249{ write_exp_elt_opcode (BINOP_GTR); ;
1250 break;}
1251case 48:
1252#line 435 "c-exp.y"
1253{ write_exp_elt_opcode (BINOP_BITWISE_AND); ;
1254 break;}
1255case 49:
1256#line 439 "c-exp.y"
1257{ write_exp_elt_opcode (BINOP_BITWISE_XOR); ;
1258 break;}
1259case 50:
1260#line 443 "c-exp.y"
1261{ write_exp_elt_opcode (BINOP_BITWISE_IOR); ;
1262 break;}
1263case 51:
1264#line 447 "c-exp.y"
1265{ write_exp_elt_opcode (BINOP_LOGICAL_AND); ;
1266 break;}
1267case 52:
1268#line 451 "c-exp.y"
1269{ write_exp_elt_opcode (BINOP_LOGICAL_OR); ;
1270 break;}
1271case 53:
1272#line 455 "c-exp.y"
1273{ write_exp_elt_opcode (TERNOP_COND); ;
1274 break;}
1275case 54:
1276#line 459 "c-exp.y"
1277{ write_exp_elt_opcode (BINOP_ASSIGN); ;
1278 break;}
1279case 55:
1280#line 463 "c-exp.y"
1281{ write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
1282 write_exp_elt_opcode (yyvsp[-1].opcode);
1283 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); ;
1284 break;}
1285case 56:
1286#line 469 "c-exp.y"
1287{ write_exp_elt_opcode (OP_LONG);
1288 write_exp_elt_type (yyvsp[0].typed_val_int.type);
1289 write_exp_elt_longcst ((LONGEST)(yyvsp[0].typed_val_int.val));
1290 write_exp_elt_opcode (OP_LONG); ;
1291 break;}
1292case 57:
1293#line 476 "c-exp.y"
1294{ YYSTYPE val;
1295 parse_number (yyvsp[0].ssym.stoken.ptr, yyvsp[0].ssym.stoken.length, 0, &val);
1296 write_exp_elt_opcode (OP_LONG);
1297 write_exp_elt_type (val.typed_val_int.type);
1298 write_exp_elt_longcst ((LONGEST)val.typed_val_int.val);
1299 write_exp_elt_opcode (OP_LONG);
1300 ;
1301 break;}
1302case 58:
1303#line 487 "c-exp.y"
1304{ write_exp_elt_opcode (OP_DOUBLE);
1305 write_exp_elt_type (yyvsp[0].typed_val_float.type);
1306 write_exp_elt_dblcst (yyvsp[0].typed_val_float.dval);
1307 write_exp_elt_opcode (OP_DOUBLE); ;
1308 break;}
1309case 61:
1310#line 501 "c-exp.y"
1311{ write_exp_elt_opcode (OP_LONG);
1312 write_exp_elt_type (builtin_type_int);
1313 CHECK_TYPEDEF (yyvsp[-1].tval);
1314 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH (yyvsp[-1].tval));
1315 write_exp_elt_opcode (OP_LONG); ;
1316 break;}
1317case 62:
1318#line 509 "c-exp.y"
1319{ /* C strings are converted into array constants with
1320 an explicit null byte added at the end. Thus
1321 the array upper bound is the string length.
1322 There is no such thing in C as a completely empty
1323 string. */
1324 char *sp = yyvsp[0].sval.ptr; int count = yyvsp[0].sval.length;
1325 while (count-- > 0)
1326 {
1327 write_exp_elt_opcode (OP_LONG);
1328 write_exp_elt_type (builtin_type_char);
1329 write_exp_elt_longcst ((LONGEST)(*sp++));
1330 write_exp_elt_opcode (OP_LONG);
1331 }
1332 write_exp_elt_opcode (OP_LONG);
1333 write_exp_elt_type (builtin_type_char);
1334 write_exp_elt_longcst ((LONGEST)'\0');
1335 write_exp_elt_opcode (OP_LONG);
1336 write_exp_elt_opcode (OP_ARRAY);
1337 write_exp_elt_longcst ((LONGEST) 0);
1338 write_exp_elt_longcst ((LONGEST) (yyvsp[0].sval.length));
1339 write_exp_elt_opcode (OP_ARRAY); ;
1340 break;}
1341case 63:
1342#line 534 "c-exp.y"
1343{ write_exp_elt_opcode (OP_THIS);
1344 write_exp_elt_opcode (OP_THIS); ;
1345 break;}
1346case 64:
1347#line 539 "c-exp.y"
1348{ write_exp_elt_opcode (OP_LONG);
1349 write_exp_elt_type (builtin_type_bool);
1350 write_exp_elt_longcst ((LONGEST) 1);
1351 write_exp_elt_opcode (OP_LONG); ;
1352 break;}
1353case 65:
1354#line 546 "c-exp.y"
1355{ write_exp_elt_opcode (OP_LONG);
1356 write_exp_elt_type (builtin_type_bool);
1357 write_exp_elt_longcst ((LONGEST) 0);
1358 write_exp_elt_opcode (OP_LONG); ;
1359 break;}
1360case 66:
1361#line 555 "c-exp.y"
1362{
1363 if (yyvsp[0].ssym.sym)
1364 yyval.bval = SYMBOL_BLOCK_VALUE (yyvsp[0].ssym.sym);
1365 else
1366 error ("No file or function \"%s\".",
1367 copy_name (yyvsp[0].ssym.stoken));
1368 ;
1369 break;}
1370case 67:
1371#line 563 "c-exp.y"
1372{
1373 yyval.bval = yyvsp[0].bval;
1374 ;
1375 break;}
1376case 68:
1377#line 569 "c-exp.y"
1378{ struct symbol *tem
1379 = lookup_symbol (copy_name (yyvsp[0].sval), yyvsp[-2].bval,
1380 VAR_NAMESPACE, (int *) NULL,
1381 (struct symtab **) NULL);
1382 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
1383 error ("No function \"%s\" in specified context.",
1384 copy_name (yyvsp[0].sval));
1385 yyval.bval = SYMBOL_BLOCK_VALUE (tem); ;
1386 break;}
1387case 69:
1388#line 580 "c-exp.y"
1389{ struct symbol *sym;
1390 sym = lookup_symbol (copy_name (yyvsp[0].sval), yyvsp[-2].bval,
1391 VAR_NAMESPACE, (int *) NULL,
1392 (struct symtab **) NULL);
1393 if (sym == 0)
1394 error ("No symbol \"%s\" in specified context.",
1395 copy_name (yyvsp[0].sval));
1396
1397 write_exp_elt_opcode (OP_VAR_VALUE);
1398 /* block_found is set by lookup_symbol. */
1399 write_exp_elt_block (block_found);
1400 write_exp_elt_sym (sym);
1401 write_exp_elt_opcode (OP_VAR_VALUE); ;
1402 break;}
1403case 70:
1404#line 596 "c-exp.y"
1405{
1406 struct type *type = yyvsp[-2].tval;
1407 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
1408 && TYPE_CODE (type) != TYPE_CODE_UNION)
1409 error ("`%s' is not defined as an aggregate type.",
1410 TYPE_NAME (type));
1411
1412 write_exp_elt_opcode (OP_SCOPE);
1413 write_exp_elt_type (type);
1414 write_exp_string (yyvsp[0].sval);
1415 write_exp_elt_opcode (OP_SCOPE);
1416 ;
1417 break;}
1418case 71:
1419#line 609 "c-exp.y"
1420{
1421 struct type *type = yyvsp[-3].tval;
1422 struct stoken tmp_token;
1423 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
1424 && TYPE_CODE (type) != TYPE_CODE_UNION)
1425 error ("`%s' is not defined as an aggregate type.",
1426 TYPE_NAME (type));
1427
1428 tmp_token.ptr = (char*) alloca (yyvsp[0].sval.length + 2);
1429 tmp_token.length = yyvsp[0].sval.length + 1;
1430 tmp_token.ptr[0] = '~';
1431 memcpy (tmp_token.ptr+1, yyvsp[0].sval.ptr, yyvsp[0].sval.length);
1432 tmp_token.ptr[tmp_token.length] = 0;
1433
1434 /* Check for valid destructor name. */
1435 destructor_name_p (tmp_token.ptr, type);
1436 write_exp_elt_opcode (OP_SCOPE);
1437 write_exp_elt_type (type);
1438 write_exp_string (tmp_token);
1439 write_exp_elt_opcode (OP_SCOPE);
1440 ;
1441 break;}
1442case 73:
1443#line 634 "c-exp.y"
1444{
1445 char *name = copy_name (yyvsp[0].sval);
1446 struct symbol *sym;
1447 struct minimal_symbol *msymbol;
1448
1449 sym =
1450 lookup_symbol (name, (const struct block *) NULL,
1451 VAR_NAMESPACE, (int *) NULL,
1452 (struct symtab **) NULL);
1453 if (sym)
1454 {
1455 write_exp_elt_opcode (OP_VAR_VALUE);
1456 write_exp_elt_block (NULL);
1457 write_exp_elt_sym (sym);
1458 write_exp_elt_opcode (OP_VAR_VALUE);
1459 break;
1460 }
1461
1462 msymbol = lookup_minimal_symbol (name, NULL, NULL);
1463 if (msymbol != NULL)
1464 {
1465 write_exp_msymbol (msymbol,
1466 lookup_function_type (builtin_type_int),
1467 builtin_type_int);
1468 }
1469 else
1470 if (!have_full_symbols () && !have_partial_symbols ())
1471 error ("No symbol table is loaded. Use the \"file\" command.");
1472 else
1473 error ("No symbol \"%s\" in current context.", name);
1474 ;
1475 break;}
1476case 74:
1477#line 668 "c-exp.y"
1478{ struct symbol *sym = yyvsp[0].ssym.sym;
1479
1480 if (sym)
1481 {
1482 if (symbol_read_needs_frame (sym))
1483 {
1484 if (innermost_block == 0 ||
1485 contained_in (block_found,
1486 innermost_block))
1487 innermost_block = block_found;
1488 }
1489
1490 write_exp_elt_opcode (OP_VAR_VALUE);
1491 /* We want to use the selected frame, not
1492 another more inner frame which happens to
1493 be in the same block. */
1494 write_exp_elt_block (NULL);
1495 write_exp_elt_sym (sym);
1496 write_exp_elt_opcode (OP_VAR_VALUE);
1497 }
1498 else if (yyvsp[0].ssym.is_a_field_of_this)
1499 {
1500 /* C++: it hangs off of `this'. Must
1501 not inadvertently convert from a method call
1502 to data ref. */
1503 if (innermost_block == 0 ||
1504 contained_in (block_found, innermost_block))
1505 innermost_block = block_found;
1506 write_exp_elt_opcode (OP_THIS);
1507 write_exp_elt_opcode (OP_THIS);
1508 write_exp_elt_opcode (STRUCTOP_PTR);
1509 write_exp_string (yyvsp[0].ssym.stoken);
1510 write_exp_elt_opcode (STRUCTOP_PTR);
1511 }
1512 else
1513 {
1514 struct minimal_symbol *msymbol;
1515 register char *arg = copy_name (yyvsp[0].ssym.stoken);
1516
1517 msymbol =
1518 lookup_minimal_symbol (arg, NULL, NULL);
1519 if (msymbol != NULL)
1520 {
1521 write_exp_msymbol (msymbol,
1522 lookup_function_type (builtin_type_int),
1523 builtin_type_int);
1524 }
1525 else if (!have_full_symbols () && !have_partial_symbols ())
1526 error ("No symbol table is loaded. Use the \"file\" command.");
1527 else
1528 error ("No symbol \"%s\" in current context.",
1529 copy_name (yyvsp[0].ssym.stoken));
1530 }
1531 ;
1532 break;}
1533case 78:
1534#line 734 "c-exp.y"
1535{ yyval.tval = follow_types (yyvsp[-1].tval); ;
1536 break;}
1537case 79:
1538#line 736 "c-exp.y"
1539{ yyval.tval = follow_types (yyvsp[-2].tval); ;
1540 break;}
1541case 80:
1542#line 738 "c-exp.y"
1543{ yyval.tval = follow_types (yyvsp[-2].tval); ;
1544 break;}
1545case 81:
1546#line 742 "c-exp.y"
1547{ push_type (tp_pointer); yyval.voidval = 0; ;
1548 break;}
1549case 82:
1550#line 744 "c-exp.y"
1551{ push_type (tp_pointer); yyval.voidval = yyvsp[0].voidval; ;
1552 break;}
1553case 83:
1554#line 746 "c-exp.y"
1555{ push_type (tp_reference); yyval.voidval = 0; ;
1556 break;}
1557case 84:
1558#line 748 "c-exp.y"
1559{ push_type (tp_reference); yyval.voidval = yyvsp[0].voidval; ;
1560 break;}
1561case 86:
1562#line 753 "c-exp.y"
1563{ yyval.voidval = yyvsp[-1].voidval; ;
1564 break;}
1565case 87:
1566#line 755 "c-exp.y"
1567{
1568 push_type_int (yyvsp[0].lval);
1569 push_type (tp_array);
1570 ;
1571 break;}
1572case 88:
1573#line 760 "c-exp.y"
1574{
1575 push_type_int (yyvsp[0].lval);
1576 push_type (tp_array);
1577 yyval.voidval = 0;
1578 ;
1579 break;}
1580case 89:
1581#line 767 "c-exp.y"
1582{ push_type (tp_function); ;
1583 break;}
1584case 90:
1585#line 769 "c-exp.y"
1586{ push_type (tp_function); ;
1587 break;}
1588case 91:
1589#line 773 "c-exp.y"
1590{ yyval.lval = -1; ;
1591 break;}
1592case 92:
1593#line 775 "c-exp.y"
1594{ yyval.lval = yyvsp[-1].typed_val_int.val; ;
1595 break;}
1596case 93:
1597#line 779 "c-exp.y"
1598{ yyval.voidval = 0; ;
1599 break;}
1600case 94:
1601#line 781 "c-exp.y"
1602{ free ((PTR)yyvsp[-1].tvec); yyval.voidval = 0; ;
1603 break;}
1604case 96:
1605#line 794 "c-exp.y"
1606{ yyval.tval = lookup_member_type (builtin_type_int, yyvsp[-2].tval); ;
1607 break;}
1608case 97:
1609#line 799 "c-exp.y"
1610{ yyval.tval = yyvsp[0].tsym.type; ;
1611 break;}
1612case 98:
1613#line 801 "c-exp.y"
1614{ yyval.tval = builtin_type_int; ;
1615 break;}
1616case 99:
1617#line 803 "c-exp.y"
1618{ yyval.tval = builtin_type_long; ;
1619 break;}
1620case 100:
1621#line 805 "c-exp.y"
1622{ yyval.tval = builtin_type_short; ;
1623 break;}
1624case 101:
1625#line 807 "c-exp.y"
1626{ yyval.tval = builtin_type_long; ;
1627 break;}
1628case 102:
1629#line 809 "c-exp.y"
1630{ yyval.tval = builtin_type_unsigned_long; ;
1631 break;}
1632case 103:
1633#line 811 "c-exp.y"
1634{ yyval.tval = builtin_type_long_long; ;
1635 break;}
1636case 104:
1637#line 813 "c-exp.y"
1638{ yyval.tval = builtin_type_long_long; ;
1639 break;}
1640case 105:
1641#line 815 "c-exp.y"
1642{ yyval.tval = builtin_type_unsigned_long_long; ;
1643 break;}
1644case 106:
1645#line 817 "c-exp.y"
1646{ yyval.tval = builtin_type_unsigned_long_long; ;
1647 break;}
1648case 107:
1649#line 819 "c-exp.y"
1650{ yyval.tval = builtin_type_short; ;
1651 break;}
1652case 108:
1653#line 821 "c-exp.y"
1654{ yyval.tval = builtin_type_unsigned_short; ;
1655 break;}
1656case 109:
1657#line 823 "c-exp.y"
1658{ yyval.tval = builtin_type_double; ;
1659 break;}
1660case 110:
1661#line 825 "c-exp.y"
1662{ yyval.tval = builtin_type_long_double; ;
1663 break;}
1664case 111:
1665#line 827 "c-exp.y"
1666{ yyval.tval = lookup_struct (copy_name (yyvsp[0].sval),
1667 expression_context_block); ;
1668 break;}
1669case 112:
1670#line 830 "c-exp.y"
1671{ yyval.tval = lookup_struct (copy_name (yyvsp[0].sval),
1672 expression_context_block); ;
1673 break;}
1674case 113:
1675#line 833 "c-exp.y"
1676{ yyval.tval = lookup_union (copy_name (yyvsp[0].sval),
1677 expression_context_block); ;
1678 break;}
1679case 114:
1680#line 836 "c-exp.y"
1681{ yyval.tval = lookup_enum (copy_name (yyvsp[0].sval),
1682 expression_context_block); ;
1683 break;}
1684case 115:
1685#line 839 "c-exp.y"
1686{ yyval.tval = lookup_unsigned_typename (TYPE_NAME(yyvsp[0].tsym.type)); ;
1687 break;}
1688case 116:
1689#line 841 "c-exp.y"
1690{ yyval.tval = builtin_type_unsigned_int; ;
1691 break;}
1692case 117:
1693#line 843 "c-exp.y"
1694{ yyval.tval = lookup_signed_typename (TYPE_NAME(yyvsp[0].tsym.type)); ;
1695 break;}
1696case 118:
1697#line 845 "c-exp.y"
1698{ yyval.tval = builtin_type_int; ;
1699 break;}
1700case 119:
1701#line 850 "c-exp.y"
1702{ yyval.tval = lookup_template_type(copy_name(yyvsp[-3].sval), yyvsp[-1].tval,
1703 expression_context_block);
1704 ;
1705 break;}
1706case 120:
1707#line 856 "c-exp.y"
1708{ yyval.tval = yyvsp[0].tval; ;
1709 break;}
1710case 121:
1711#line 857 "c-exp.y"
1712{ yyval.tval = yyvsp[0].tval; ;
1713 break;}
1714case 123:
1715#line 862 "c-exp.y"
1716{
1717 yyval.tsym.stoken.ptr = "int";
1718 yyval.tsym.stoken.length = 3;
1719 yyval.tsym.type = builtin_type_int;
1720 ;
1721 break;}
1722case 124:
1723#line 868 "c-exp.y"
1724{
1725 yyval.tsym.stoken.ptr = "long";
1726 yyval.tsym.stoken.length = 4;
1727 yyval.tsym.type = builtin_type_long;
1728 ;
1729 break;}
1730case 125:
1731#line 874 "c-exp.y"
1732{
1733 yyval.tsym.stoken.ptr = "short";
1734 yyval.tsym.stoken.length = 5;
1735 yyval.tsym.type = builtin_type_short;
1736 ;
1737 break;}
1738case 126:
1739#line 883 "c-exp.y"
1740{ yyval.tvec = (struct type **) xmalloc (sizeof (struct type *) * 2);
1741 yyval.ivec[0] = 1; /* Number of types in vector */
1742 yyval.tvec[1] = yyvsp[0].tval;
1743 ;
1744 break;}
1745case 127:
1746#line 888 "c-exp.y"
1747{ int len = sizeof (struct type *) * (++(yyvsp[-2].ivec[0]) + 1);
1748 yyval.tvec = (struct type **) xrealloc ((char *) yyvsp[-2].tvec, len);
1749 yyval.tvec[yyval.ivec[0]] = yyvsp[0].tval;
1750 ;
1751 break;}
1752case 128:
1753#line 894 "c-exp.y"
1754{ yyval.sval = yyvsp[0].ssym.stoken; ;
1755 break;}
1756case 129:
1757#line 895 "c-exp.y"
1758{ yyval.sval = yyvsp[0].ssym.stoken; ;
1759 break;}
1760case 130:
1761#line 896 "c-exp.y"
1762{ yyval.sval = yyvsp[0].tsym.stoken; ;
1763 break;}
1764case 131:
1765#line 897 "c-exp.y"
1766{ yyval.sval = yyvsp[0].ssym.stoken; ;
1767 break;}
1768}
1769 /* the action file gets copied in in place of this dollarsign */
1770#line 498 "/stone/jimb/main-98r2/share/bison.simple"
1771\f
1772 yyvsp -= yylen;
1773 yyssp -= yylen;
1774#ifdef YYLSP_NEEDED
1775 yylsp -= yylen;
1776#endif
1777
1778#if YYDEBUG != 0
1779 if (yydebug)
1780 {
1781 short *ssp1 = yyss - 1;
1782 fprintf (stderr, "state stack now");
1783 while (ssp1 != yyssp)
1784 fprintf (stderr, " %d", *++ssp1);
1785 fprintf (stderr, "\n");
1786 }
1787#endif
1788
1789 *++yyvsp = yyval;
1790
1791#ifdef YYLSP_NEEDED
1792 yylsp++;
1793 if (yylen == 0)
1794 {
1795 yylsp->first_line = yylloc.first_line;
1796 yylsp->first_column = yylloc.first_column;
1797 yylsp->last_line = (yylsp-1)->last_line;
1798 yylsp->last_column = (yylsp-1)->last_column;
1799 yylsp->text = 0;
1800 }
1801 else
1802 {
1803 yylsp->last_line = (yylsp+yylen-1)->last_line;
1804 yylsp->last_column = (yylsp+yylen-1)->last_column;
1805 }
1806#endif
1807
1808 /* Now "shift" the result of the reduction.
1809 Determine what state that goes to,
1810 based on the state we popped back to
1811 and the rule number reduced by. */
1812
1813 yyn = yyr1[yyn];
1814
1815 yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
1816 if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1817 yystate = yytable[yystate];
1818 else
1819 yystate = yydefgoto[yyn - YYNTBASE];
1820
1821 goto yynewstate;
1822
1823yyerrlab: /* here on detecting error */
1824
1825 if (! yyerrstatus)
1826 /* If not already recovering from an error, report this error. */
1827 {
1828 ++yynerrs;
1829
1830#ifdef YYERROR_VERBOSE
1831 yyn = yypact[yystate];
1832
1833 if (yyn > YYFLAG && yyn < YYLAST)
1834 {
1835 int size = 0;
1836 char *msg;
1837 int x, count;
1838
1839 count = 0;
1840 /* Start X at -yyn if nec to avoid negative indexes in yycheck. */
1841 for (x = (yyn < 0 ? -yyn : 0);
1842 x < (sizeof(yytname) / sizeof(char *)); x++)
1843 if (yycheck[x + yyn] == x)
1844 size += strlen(yytname[x]) + 15, count++;
1845 msg = (char *) xmalloc(size + 15);
1846 if (msg != 0)
1847 {
1848 strcpy(msg, "parse error");
1849
1850 if (count < 5)
1851 {
1852 count = 0;
1853 for (x = (yyn < 0 ? -yyn : 0);
1854 x < (sizeof(yytname) / sizeof(char *)); x++)
1855 if (yycheck[x + yyn] == x)
1856 {
1857 strcat(msg, count == 0 ? ", expecting `" : " or `");
1858 strcat(msg, yytname[x]);
1859 strcat(msg, "'");
1860 count++;
1861 }
1862 }
1863 yyerror(msg);
1864 free(msg);
1865 }
1866 else
1867 yyerror ("parse error; also virtual memory exceeded");
1868 }
1869 else
1870#endif /* YYERROR_VERBOSE */
1871 yyerror("parse error");
1872 }
1873
1874 goto yyerrlab1;
1875yyerrlab1: /* here on error raised explicitly by an action */
1876
1877 if (yyerrstatus == 3)
1878 {
1879 /* if just tried and failed to reuse lookahead token after an error, discard it. */
1880
1881 /* return failure if at end of input */
1882 if (yychar == YYEOF)
1883 YYABORT;
1884
1885#if YYDEBUG != 0
1886 if (yydebug)
1887 fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
1888#endif
1889
1890 yychar = YYEMPTY;
1891 }
1892
1893 /* Else will try to reuse lookahead token
1894 after shifting the error token. */
1895
1896 yyerrstatus = 3; /* Each real token shifted decrements this */
1897
1898 goto yyerrhandle;
1899
1900yyerrdefault: /* current state does not do anything special for the error token. */
1901
1902#if 0
1903 /* This is wrong; only states that explicitly want error tokens
1904 should shift them. */
1905 yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
1906 if (yyn) goto yydefault;
1907#endif
1908
1909yyerrpop: /* pop the current state because it cannot handle the error token */
1910
1911 if (yyssp == yyss) YYABORT;
1912 yyvsp--;
1913 yystate = *--yyssp;
1914#ifdef YYLSP_NEEDED
1915 yylsp--;
1916#endif
1917
1918#if YYDEBUG != 0
1919 if (yydebug)
1920 {
1921 short *ssp1 = yyss - 1;
1922 fprintf (stderr, "Error: state stack now");
1923 while (ssp1 != yyssp)
1924 fprintf (stderr, " %d", *++ssp1);
1925 fprintf (stderr, "\n");
1926 }
1927#endif
1928
1929yyerrhandle:
1930
1931 yyn = yypact[yystate];
1932 if (yyn == YYFLAG)
1933 goto yyerrdefault;
1934
1935 yyn += YYTERROR;
1936 if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
1937 goto yyerrdefault;
1938
1939 yyn = yytable[yyn];
1940 if (yyn < 0)
1941 {
1942 if (yyn == YYFLAG)
1943 goto yyerrpop;
1944 yyn = -yyn;
1945 goto yyreduce;
1946 }
1947 else if (yyn == 0)
1948 goto yyerrpop;
1949
1950 if (yyn == YYFINAL)
1951 YYACCEPT;
1952
1953#if YYDEBUG != 0
1954 if (yydebug)
1955 fprintf(stderr, "Shifting error token, ");
1956#endif
1957
1958 *++yyvsp = yylval;
1959#ifdef YYLSP_NEEDED
1960 *++yylsp = yylloc;
1961#endif
1962
1963 yystate = yyn;
1964 goto yynewstate;
1965}
1966#line 911 "c-exp.y"
1967
1968
1969/* Take care of parsing a number (anything that starts with a digit).
1970 Set yylval and return the token type; update lexptr.
1971 LEN is the number of characters in it. */
1972
1973/*** Needs some error checking for the float case ***/
1974
1975static int
1976parse_number (p, len, parsed_float, putithere)
1977 register char *p;
1978 register int len;
1979 int parsed_float;
1980 YYSTYPE *putithere;
1981{
1982 /* FIXME: Shouldn't these be unsigned? We don't deal with negative values
1983 here, and we do kind of silly things like cast to unsigned. */
1984 register LONGEST n = 0;
1985 register LONGEST prevn = 0;
1986 ULONGEST un;
1987
1988 register int i = 0;
1989 register int c;
1990 register int base = input_radix;
1991 int unsigned_p = 0;
1992
1993 /* Number of "L" suffixes encountered. */
1994 int long_p = 0;
1995
1996 /* We have found a "L" or "U" suffix. */
1997 int found_suffix = 0;
1998
1999 ULONGEST high_bit;
2000 struct type *signed_type;
2001 struct type *unsigned_type;
2002
2003 if (parsed_float)
2004 {
2005 /* It's a float since it contains a point or an exponent. */
2006 char c;
2007 int num = 0; /* number of tokens scanned by scanf */
2008 char saved_char = p[len];
2009
2010 p[len] = 0; /* null-terminate the token */
2011 if (sizeof (putithere->typed_val_float.dval) <= sizeof (float))
2012 num = sscanf (p, "%g%c", (float *) &putithere->typed_val_float.dval,&c);
2013 else if (sizeof (putithere->typed_val_float.dval) <= sizeof (double))
2014 num = sscanf (p, "%lg%c", (double *) &putithere->typed_val_float.dval,&c);
2015 else
2016 {
2017#ifdef SCANF_HAS_LONG_DOUBLE
2018 num = sscanf (p, "%Lg%c", &putithere->typed_val_float.dval,&c);
2019#else
2020 /* Scan it into a double, then assign it to the long double.
2021 This at least wins with values representable in the range
2022 of doubles. */
2023 double temp;
2024 num = sscanf (p, "%lg%c", &temp,&c);
2025 putithere->typed_val_float.dval = temp;
2026#endif
2027 }
2028 p[len] = saved_char; /* restore the input stream */
2029 if (num != 1) /* check scanf found ONLY a float ... */
2030 return ERROR;
2031 /* See if it has `f' or `l' suffix (float or long double). */
2032
2033 c = tolower (p[len - 1]);
2034
2035 if (c == 'f')
2036 putithere->typed_val_float.type = builtin_type_float;
2037 else if (c == 'l')
2038 putithere->typed_val_float.type = builtin_type_long_double;
2039 else if (isdigit (c) || c == '.')
2040 putithere->typed_val_float.type = builtin_type_double;
2041 else
2042 return ERROR;
2043
2044 return FLOAT;
2045 }
2046
2047 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
2048 if (p[0] == '0')
2049 switch (p[1])
2050 {
2051 case 'x':
2052 case 'X':
2053 if (len >= 3)
2054 {
2055 p += 2;
2056 base = 16;
2057 len -= 2;
2058 }
2059 break;
2060
2061 case 't':
2062 case 'T':
2063 case 'd':
2064 case 'D':
2065 if (len >= 3)
2066 {
2067 p += 2;
2068 base = 10;
2069 len -= 2;
2070 }
2071 break;
2072
2073 default:
2074 base = 8;
2075 break;
2076 }
2077
2078 while (len-- > 0)
2079 {
2080 c = *p++;
2081 if (c >= 'A' && c <= 'Z')
2082 c += 'a' - 'A';
2083 if (c != 'l' && c != 'u')
2084 n *= base;
2085 if (c >= '0' && c <= '9')
2086 {
2087 if (found_suffix)
2088 return ERROR;
2089 n += i = c - '0';
2090 }
2091 else
2092 {
2093 if (base > 10 && c >= 'a' && c <= 'f')
2094 {
2095 if (found_suffix)
2096 return ERROR;
2097 n += i = c - 'a' + 10;
2098 }
2099 else if (c == 'l')
2100 {
2101 ++long_p;
2102 found_suffix = 1;
2103 }
2104 else if (c == 'u')
2105 {
2106 unsigned_p = 1;
2107 found_suffix = 1;
2108 }
2109 else
2110 return ERROR; /* Char not a digit */
2111 }
2112 if (i >= base)
2113 return ERROR; /* Invalid digit in this base */
2114
2115 /* Portably test for overflow (only works for nonzero values, so make
2116 a second check for zero). FIXME: Can't we just make n and prevn
2117 unsigned and avoid this? */
2118 if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
2119 unsigned_p = 1; /* Try something unsigned */
2120
2121 /* Portably test for unsigned overflow.
2122 FIXME: This check is wrong; for example it doesn't find overflow
2123 on 0x123456789 when LONGEST is 32 bits. */
2124 if (c != 'l' && c != 'u' && n != 0)
2125 {
2126 if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
2127 error ("Numeric constant too large.");
2128 }
2129 prevn = n;
2130 }
2131
2132 /* An integer constant is an int, a long, or a long long. An L
2133 suffix forces it to be long; an LL suffix forces it to be long
2134 long. If not forced to a larger size, it gets the first type of
2135 the above that it fits in. To figure out whether it fits, we
2136 shift it right and see whether anything remains. Note that we
2137 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
2138 operation, because many compilers will warn about such a shift
2139 (which always produces a zero result). Sometimes TARGET_INT_BIT
2140 or TARGET_LONG_BIT will be that big, sometimes not. To deal with
2141 the case where it is we just always shift the value more than
2142 once, with fewer bits each time. */
2143
2144 un = (ULONGEST)n >> 2;
2145 if (long_p == 0
2146 && (un >> (TARGET_INT_BIT - 2)) == 0)
2147 {
2148 high_bit = ((ULONGEST)1) << (TARGET_INT_BIT-1);
2149
2150 /* A large decimal (not hex or octal) constant (between INT_MAX
2151 and UINT_MAX) is a long or unsigned long, according to ANSI,
2152 never an unsigned int, but this code treats it as unsigned
2153 int. This probably should be fixed. GCC gives a warning on
2154 such constants. */
2155
2156 unsigned_type = builtin_type_unsigned_int;
2157 signed_type = builtin_type_int;
2158 }
2159 else if (long_p <= 1
2160 && (un >> (TARGET_LONG_BIT - 2)) == 0)
2161 {
2162 high_bit = ((ULONGEST)1) << (TARGET_LONG_BIT-1);
2163 unsigned_type = builtin_type_unsigned_long;
2164 signed_type = builtin_type_long;
2165 }
2166 else
2167 {
2168 int shift;
2169 if (sizeof (ULONGEST) * HOST_CHAR_BIT < TARGET_LONG_LONG_BIT)
2170 /* A long long does not fit in a LONGEST. */
2171 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
2172 else
2173 shift = (TARGET_LONG_LONG_BIT - 1);
2174 high_bit = (ULONGEST) 1 << shift;
2175 unsigned_type = builtin_type_unsigned_long_long;
2176 signed_type = builtin_type_long_long;
2177 }
2178
2179 putithere->typed_val_int.val = n;
2180
2181 /* If the high bit of the worked out type is set then this number
2182 has to be unsigned. */
2183
2184 if (unsigned_p || (n & high_bit))
2185 {
2186 putithere->typed_val_int.type = unsigned_type;
2187 }
2188 else
2189 {
2190 putithere->typed_val_int.type = signed_type;
2191 }
2192
2193 return INT;
2194}
2195
2196struct token
2197{
2198 char *operator;
2199 int token;
2200 enum exp_opcode opcode;
2201};
2202
2203static const struct token tokentab3[] =
2204 {
2205 {">>=", ASSIGN_MODIFY, BINOP_RSH},
2206 {"<<=", ASSIGN_MODIFY, BINOP_LSH}
2207 };
2208
2209static const struct token tokentab2[] =
2210 {
2211 {"+=", ASSIGN_MODIFY, BINOP_ADD},
2212 {"-=", ASSIGN_MODIFY, BINOP_SUB},
2213 {"*=", ASSIGN_MODIFY, BINOP_MUL},
2214 {"/=", ASSIGN_MODIFY, BINOP_DIV},
2215 {"%=", ASSIGN_MODIFY, BINOP_REM},
2216 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
2217 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
2218 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
2219 {"++", INCREMENT, BINOP_END},
2220 {"--", DECREMENT, BINOP_END},
2221 {"->", ARROW, BINOP_END},
2222 {"&&", ANDAND, BINOP_END},
2223 {"||", OROR, BINOP_END},
2224 {"::", COLONCOLON, BINOP_END},
2225 {"<<", LSH, BINOP_END},
2226 {">>", RSH, BINOP_END},
2227 {"==", EQUAL, BINOP_END},
2228 {"!=", NOTEQUAL, BINOP_END},
2229 {"<=", LEQ, BINOP_END},
2230 {">=", GEQ, BINOP_END}
2231 };
2232
2233/* Read one token, getting characters through lexptr. */
2234
2235static int
2236yylex ()
2237{
2238 int c;
2239 int namelen;
2240 unsigned int i;
2241 char *tokstart;
2242 char *tokptr;
2243 int tempbufindex;
2244 static char *tempbuf;
2245 static int tempbufsize;
2246 struct symbol * sym_class = NULL;
2247 char * token_string = NULL;
2248 int class_prefix = 0;
2249 int unquoted_expr;
2250
2251 retry:
2252
2253 unquoted_expr = 1;
2254
2255 tokstart = lexptr;
2256 /* See if it is a special token of length 3. */
2257 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
2258 if (STREQN (tokstart, tokentab3[i].operator, 3))
2259 {
2260 lexptr += 3;
2261 yylval.opcode = tokentab3[i].opcode;
2262 return tokentab3[i].token;
2263 }
2264
2265 /* See if it is a special token of length 2. */
2266 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
2267 if (STREQN (tokstart, tokentab2[i].operator, 2))
2268 {
2269 lexptr += 2;
2270 yylval.opcode = tokentab2[i].opcode;
2271 return tokentab2[i].token;
2272 }
2273
2274 switch (c = *tokstart)
2275 {
2276 case 0:
2277 return 0;
2278
2279 case ' ':
2280 case '\t':
2281 case '\n':
2282 lexptr++;
2283 goto retry;
2284
2285 case '\'':
2286 /* We either have a character constant ('0' or '\177' for example)
2287 or we have a quoted symbol reference ('foo(int,int)' in C++
2288 for example). */
2289 lexptr++;
2290 c = *lexptr++;
2291 if (c == '\\')
2292 c = parse_escape (&lexptr);
2293 else if (c == '\'')
2294 error ("Empty character constant.");
2295
2296 yylval.typed_val_int.val = c;
2297 yylval.typed_val_int.type = builtin_type_char;
2298
2299 c = *lexptr++;
2300 if (c != '\'')
2301 {
2302 namelen = skip_quoted (tokstart) - tokstart;
2303 if (namelen > 2)
2304 {
2305 lexptr = tokstart + namelen;
2306 unquoted_expr = 0;
2307 if (lexptr[-1] != '\'')
2308 error ("Unmatched single quote.");
2309 namelen -= 2;
2310 tokstart++;
2311 goto tryname;
2312 }
2313 error ("Invalid character constant.");
2314 }
2315 return INT;
2316
2317 case '(':
2318 paren_depth++;
2319 lexptr++;
2320 return c;
2321
2322 case ')':
2323 if (paren_depth == 0)
2324 return 0;
2325 paren_depth--;
2326 lexptr++;
2327 return c;
2328
2329 case ',':
2330 if (comma_terminates && paren_depth == 0)
2331 return 0;
2332 lexptr++;
2333 return c;
2334
2335 case '.':
2336 /* Might be a floating point number. */
2337 if (lexptr[1] < '0' || lexptr[1] > '9')
2338 goto symbol; /* Nope, must be a symbol. */
2339 /* FALL THRU into number case. */
2340
2341 case '0':
2342 case '1':
2343 case '2':
2344 case '3':
2345 case '4':
2346 case '5':
2347 case '6':
2348 case '7':
2349 case '8':
2350 case '9':
2351 {
2352 /* It's a number. */
2353 int got_dot = 0, got_e = 0, toktype;
2354 register char *p = tokstart;
2355 int hex = input_radix > 10;
2356
2357 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
2358 {
2359 p += 2;
2360 hex = 1;
2361 }
2362 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
2363 {
2364 p += 2;
2365 hex = 0;
2366 }
2367
2368 for (;; ++p)
2369 {
2370 /* This test includes !hex because 'e' is a valid hex digit
2371 and thus does not indicate a floating point number when
2372 the radix is hex. */
2373 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
2374 got_dot = got_e = 1;
2375 /* This test does not include !hex, because a '.' always indicates
2376 a decimal floating point number regardless of the radix. */
2377 else if (!got_dot && *p == '.')
2378 got_dot = 1;
2379 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
2380 && (*p == '-' || *p == '+'))
2381 /* This is the sign of the exponent, not the end of the
2382 number. */
2383 continue;
2384 /* We will take any letters or digits. parse_number will
2385 complain if past the radix, or if L or U are not final. */
2386 else if ((*p < '0' || *p > '9')
2387 && ((*p < 'a' || *p > 'z')
2388 && (*p < 'A' || *p > 'Z')))
2389 break;
2390 }
2391 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
2392 if (toktype == ERROR)
2393 {
2394 char *err_copy = (char *) alloca (p - tokstart + 1);
2395
2396 memcpy (err_copy, tokstart, p - tokstart);
2397 err_copy[p - tokstart] = 0;
2398 error ("Invalid number \"%s\".", err_copy);
2399 }
2400 lexptr = p;
2401 return toktype;
2402 }
2403
2404 case '+':
2405 case '-':
2406 case '*':
2407 case '/':
2408 case '%':
2409 case '|':
2410 case '&':
2411 case '^':
2412 case '~':
2413 case '!':
2414 case '@':
2415 case '<':
2416 case '>':
2417 case '[':
2418 case ']':
2419 case '?':
2420 case ':':
2421 case '=':
2422 case '{':
2423 case '}':
2424 symbol:
2425 lexptr++;
2426 return c;
2427
2428 case '"':
2429
2430 /* Build the gdb internal form of the input string in tempbuf,
2431 translating any standard C escape forms seen. Note that the
2432 buffer is null byte terminated *only* for the convenience of
2433 debugging gdb itself and printing the buffer contents when
2434 the buffer contains no embedded nulls. Gdb does not depend
2435 upon the buffer being null byte terminated, it uses the length
2436 string instead. This allows gdb to handle C strings (as well
2437 as strings in other languages) with embedded null bytes */
2438
2439 tokptr = ++tokstart;
2440 tempbufindex = 0;
2441
2442 do {
2443 /* Grow the static temp buffer if necessary, including allocating
2444 the first one on demand. */
2445 if (tempbufindex + 1 >= tempbufsize)
2446 {
2447 tempbuf = (char *) xrealloc (tempbuf, tempbufsize += 64);
2448 }
2449 switch (*tokptr)
2450 {
2451 case '\0':
2452 case '"':
2453 /* Do nothing, loop will terminate. */
2454 break;
2455 case '\\':
2456 tokptr++;
2457 c = parse_escape (&tokptr);
2458 if (c == -1)
2459 {
2460 continue;
2461 }
2462 tempbuf[tempbufindex++] = c;
2463 break;
2464 default:
2465 tempbuf[tempbufindex++] = *tokptr++;
2466 break;
2467 }
2468 } while ((*tokptr != '"') && (*tokptr != '\0'));
2469 if (*tokptr++ != '"')
2470 {
2471 error ("Unterminated string in expression.");
2472 }
2473 tempbuf[tempbufindex] = '\0'; /* See note above */
2474 yylval.sval.ptr = tempbuf;
2475 yylval.sval.length = tempbufindex;
2476 lexptr = tokptr;
2477 return (STRING);
2478 }
2479
2480 if (!(c == '_' || c == '$'
2481 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
2482 /* We must have come across a bad character (e.g. ';'). */
2483 error ("Invalid character '%c' in expression.", c);
2484
2485 /* It's a name. See how long it is. */
2486 namelen = 0;
2487 for (c = tokstart[namelen];
2488 (c == '_' || c == '$' || (c >= '0' && c <= '9')
2489 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
2490 {
2491 /* Template parameter lists are part of the name.
2492 FIXME: This mishandles `print $a<4&&$a>3'. */
2493
2494 if (c == '<')
2495 {
2496 if (hp_som_som_object_present)
2497 {
2498 /* Scan ahead to get rest of the template specification. Note
2499 that we look ahead only when the '<' adjoins non-whitespace
2500 characters; for comparison expressions, e.g. "a < b > c",
2501 there must be spaces before the '<', etc. */
2502
2503 char * p = find_template_name_end (tokstart + namelen);
2504 if (p)
2505 namelen = p - tokstart;
2506 break;
2507 }
2508 else
2509 {
2510 int i = namelen;
2511 int nesting_level = 1;
2512 while (tokstart[++i])
2513 {
2514 if (tokstart[i] == '<')
2515 nesting_level++;
2516 else if (tokstart[i] == '>')
2517 {
2518 if (--nesting_level == 0)
2519 break;
2520 }
2521 }
2522 if (tokstart[i] == '>')
2523 namelen = i;
2524 else
2525 break;
2526 }
2527 }
2528 c = tokstart[++namelen];
2529 }
2530
2531 /* The token "if" terminates the expression and is NOT
2532 removed from the input stream. */
2533 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
2534 {
2535 return 0;
2536 }
2537
2538 lexptr += namelen;
2539
2540 tryname:
2541
2542 /* Catch specific keywords. Should be done with a data structure. */
2543 switch (namelen)
2544 {
2545 case 8:
2546 if (STREQN (tokstart, "unsigned", 8))
2547 return UNSIGNED;
2548 if (current_language->la_language == language_cplus
2549 && STREQN (tokstart, "template", 8))
2550 return TEMPLATE;
2551 if (STREQN (tokstart, "volatile", 8))
2552 return VOLATILE_KEYWORD;
2553 break;
2554 case 6:
2555 if (STREQN (tokstart, "struct", 6))
2556 return STRUCT;
2557 if (STREQN (tokstart, "signed", 6))
2558 return SIGNED_KEYWORD;
2559 if (STREQN (tokstart, "sizeof", 6))
2560 return SIZEOF;
2561 if (STREQN (tokstart, "double", 6))
2562 return DOUBLE_KEYWORD;
2563 break;
2564 case 5:
2565 if (current_language->la_language == language_cplus)
2566 {
2567 if (STREQN (tokstart, "false", 5))
2568 return FALSEKEYWORD;
2569 if (STREQN (tokstart, "class", 5))
2570 return CLASS;
2571 }
2572 if (STREQN (tokstart, "union", 5))
2573 return UNION;
2574 if (STREQN (tokstart, "short", 5))
2575 return SHORT;
2576 if (STREQN (tokstart, "const", 5))
2577 return CONST_KEYWORD;
2578 break;
2579 case 4:
2580 if (STREQN (tokstart, "enum", 4))
2581 return ENUM;
2582 if (STREQN (tokstart, "long", 4))
2583 return LONG;
2584 if (current_language->la_language == language_cplus)
2585 {
2586 if (STREQN (tokstart, "true", 4))
2587 return TRUEKEYWORD;
2588
2589 if (STREQN (tokstart, "this", 4))
2590 {
2591 static const char this_name[] =
2592 { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' };
2593
2594 if (lookup_symbol (this_name, expression_context_block,
2595 VAR_NAMESPACE, (int *) NULL,
2596 (struct symtab **) NULL))
2597 return THIS;
2598 }
2599 }
2600 break;
2601 case 3:
2602 if (STREQN (tokstart, "int", 3))
2603 return INT_KEYWORD;
2604 break;
2605 default:
2606 break;
2607 }
2608
2609 yylval.sval.ptr = tokstart;
2610 yylval.sval.length = namelen;
2611
2612 if (*tokstart == '$')
2613 {
2614 write_dollar_variable (yylval.sval);
2615 return VARIABLE;
2616 }
2617
2618 /* Look ahead and see if we can consume more of the input
2619 string to get a reasonable class/namespace spec or a
2620 fully-qualified name. This is a kludge to get around the
2621 HP aCC compiler's generation of symbol names with embedded
2622 colons for namespace and nested classes. */
2623 if (unquoted_expr)
2624 {
2625 /* Only do it if not inside single quotes */
2626 sym_class = parse_nested_classes_for_hpacc (yylval.sval.ptr, yylval.sval.length,
2627 &token_string, &class_prefix, &lexptr);
2628 if (sym_class)
2629 {
2630 /* Replace the current token with the bigger one we found */
2631 yylval.sval.ptr = token_string;
2632 yylval.sval.length = strlen (token_string);
2633 }
2634 }
2635
2636 /* Use token-type BLOCKNAME for symbols that happen to be defined as
2637 functions or symtabs. If this is not so, then ...
2638 Use token-type TYPENAME for symbols that happen to be defined
2639 currently as names of types; NAME for other symbols.
2640 The caller is not constrained to care about the distinction. */
2641 {
2642 char *tmp = copy_name (yylval.sval);
2643 struct symbol *sym;
2644 int is_a_field_of_this = 0;
2645 int hextype;
2646
2647 sym = lookup_symbol (tmp, expression_context_block,
2648 VAR_NAMESPACE,
2649 current_language->la_language == language_cplus
2650 ? &is_a_field_of_this : (int *) NULL,
2651 (struct symtab **) NULL);
2652 /* Call lookup_symtab, not lookup_partial_symtab, in case there are
2653 no psymtabs (coff, xcoff, or some future change to blow away the
2654 psymtabs once once symbols are read). */
2655 if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
2656 {
2657 yylval.ssym.sym = sym;
2658 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
2659 return BLOCKNAME;
2660 }
2661 else if (!sym)
2662 { /* See if it's a file name. */
2663 struct symtab *symtab;
2664
2665 symtab = lookup_symtab (tmp);
2666
2667 if (symtab)
2668 {
2669 yylval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
2670 return FILENAME;
2671 }
2672 }
2673
2674 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
2675 {
2676#if 1
2677 /* Despite the following flaw, we need to keep this code enabled.
2678 Because we can get called from check_stub_method, if we don't
2679 handle nested types then it screws many operations in any
2680 program which uses nested types. */
2681 /* In "A::x", if x is a member function of A and there happens
2682 to be a type (nested or not, since the stabs don't make that
2683 distinction) named x, then this code incorrectly thinks we
2684 are dealing with nested types rather than a member function. */
2685
2686 char *p;
2687 char *namestart;
2688 struct symbol *best_sym;
2689
2690 /* Look ahead to detect nested types. This probably should be
2691 done in the grammar, but trying seemed to introduce a lot
2692 of shift/reduce and reduce/reduce conflicts. It's possible
2693 that it could be done, though. Or perhaps a non-grammar, but
2694 less ad hoc, approach would work well. */
2695
2696 /* Since we do not currently have any way of distinguishing
2697 a nested type from a non-nested one (the stabs don't tell
2698 us whether a type is nested), we just ignore the
2699 containing type. */
2700
2701 p = lexptr;
2702 best_sym = sym;
2703 while (1)
2704 {
2705 /* Skip whitespace. */
2706 while (*p == ' ' || *p == '\t' || *p == '\n')
2707 ++p;
2708 if (*p == ':' && p[1] == ':')
2709 {
2710 /* Skip the `::'. */
2711 p += 2;
2712 /* Skip whitespace. */
2713 while (*p == ' ' || *p == '\t' || *p == '\n')
2714 ++p;
2715 namestart = p;
2716 while (*p == '_' || *p == '$' || (*p >= '0' && *p <= '9')
2717 || (*p >= 'a' && *p <= 'z')
2718 || (*p >= 'A' && *p <= 'Z'))
2719 ++p;
2720 if (p != namestart)
2721 {
2722 struct symbol *cur_sym;
2723 /* As big as the whole rest of the expression, which is
2724 at least big enough. */
2725 char *ncopy = alloca (strlen (tmp)+strlen (namestart)+3);
2726 char *tmp1;
2727
2728 tmp1 = ncopy;
2729 memcpy (tmp1, tmp, strlen (tmp));
2730 tmp1 += strlen (tmp);
2731 memcpy (tmp1, "::", 2);
2732 tmp1 += 2;
2733 memcpy (tmp1, namestart, p - namestart);
2734 tmp1[p - namestart] = '\0';
2735 cur_sym = lookup_symbol (ncopy, expression_context_block,
2736 VAR_NAMESPACE, (int *) NULL,
2737 (struct symtab **) NULL);
2738 if (cur_sym)
2739 {
2740 if (SYMBOL_CLASS (cur_sym) == LOC_TYPEDEF)
2741 {
2742 best_sym = cur_sym;
2743 lexptr = p;
2744 }
2745 else
2746 break;
2747 }
2748 else
2749 break;
2750 }
2751 else
2752 break;
2753 }
2754 else
2755 break;
2756 }
2757
2758 yylval.tsym.type = SYMBOL_TYPE (best_sym);
2759#else /* not 0 */
2760 yylval.tsym.type = SYMBOL_TYPE (sym);
2761#endif /* not 0 */
2762 return TYPENAME;
2763 }
2764 if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)
2765 return TYPENAME;
2766
2767 /* Input names that aren't symbols but ARE valid hex numbers,
2768 when the input radix permits them, can be names or numbers
2769 depending on the parse. Note we support radixes > 16 here. */
2770 if (!sym &&
2771 ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
2772 (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
2773 {
2774 YYSTYPE newlval; /* Its value is ignored. */
2775 hextype = parse_number (tokstart, namelen, 0, &newlval);
2776 if (hextype == INT)
2777 {
2778 yylval.ssym.sym = sym;
2779 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
2780 return NAME_OR_INT;
2781 }
2782 }
2783
2784 /* Any other kind of symbol */
2785 yylval.ssym.sym = sym;
2786 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
2787 return NAME;
2788 }
2789}
2790
2791void
2792yyerror (msg)
2793 char *msg;
2794{
2795 error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);
2796}
GDB Binutils - Deliverables
This page took 0.124073 seconds and 4 git commands to generate.