projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
import gdb-19990422 snapshot
[deliverable/binutils-gdb.git] / gdb / m2-exp.tab.c
CommitLineData
9733ab3f
SS		 1
2/* A Bison parser, made from m2-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 HEX 259
10#define ERROR 260
11#define UINT 261
12#define M2_TRUE 262
13#define M2_FALSE 263
14#define CHAR 264
15#define FLOAT 265
16#define STRING 266
17#define NAME 267
18#define BLOCKNAME 268
19#define IDENT 269
20#define VARNAME 270
21#define TYPENAME 271
22#define SIZE 272
23#define CAP 273
24#define ORD 274
25#define HIGH 275
26#define ABS 276
27#define MIN_FUNC 277
28#define MAX_FUNC 278
29#define FLOAT_FUNC 279
30#define VAL 280
31#define CHR 281
32#define ODD 282
33#define TRUNC 283
34#define INC 284
35#define DEC 285
36#define INCL 286
37#define EXCL 287
38#define COLONCOLON 288
39#define INTERNAL_VAR 289
40#define ABOVE_COMMA 290
41#define ASSIGN 291
42#define LEQ 292
43#define GEQ 293
44#define NOTEQUAL 294
45#define IN 295
46#define OROR 296
47#define LOGICAL_AND 297
48#define DIV 298
49#define MOD 299
50#define UNARY 300
51#define DOT 301
52#define NOT 302
53#define QID 303
54
55#line 40 "m2-exp.y"
56
57
58#include "defs.h"
59#include "gdb_string.h"
60#include "expression.h"
61#include "language.h"
62#include "value.h"
63#include "parser-defs.h"
64#include "m2-lang.h"
65#include "bfd.h" /* Required by objfiles.h. */
66#include "symfile.h" /* Required by objfiles.h. */
67#include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
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 m2_maxdepth
77#define yyparse m2_parse
78#define yylex m2_lex
79#define yyerror m2_error
80#define yylval m2_lval
81#define yychar m2_char
82#define yydebug m2_debug
83#define yypact m2_pact
84#define yyr1 m2_r1
85#define yyr2 m2_r2
86#define yydef m2_def
87#define yychk m2_chk
88#define yypgo m2_pgo
89#define yyact m2_act
90#define yyexca m2_exca
91#define yyerrflag m2_errflag
92#define yynerrs m2_nerrs
93#define yyps m2_ps
94#define yypv m2_pv
95#define yys m2_s
96#define yy_yys m2_yys
97#define yystate m2_state
98#define yytmp m2_tmp
99#define yyv m2_v
100#define yy_yyv m2_yyv
101#define yyval m2_val
102#define yylloc m2_lloc
103#define yyreds m2_reds /* With YYDEBUG defined */
104#define yytoks m2_toks /* With YYDEBUG defined */
105#define yylhs m2_yylhs
106#define yylen m2_yylen
107#define yydefred m2_yydefred
108#define yydgoto m2_yydgoto
109#define yysindex m2_yysindex
110#define yyrindex m2_yyrindex
111#define yygindex m2_yygindex
112#define yytable m2_yytable
113#define yycheck m2_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#if 0
129static char *
130make_qualname PARAMS ((char *, char *));
131#endif
132
133static int
134parse_number PARAMS ((int));
135
136/* The sign of the number being parsed. */
137static int number_sign = 1;
138
139/* The block that the module specified by the qualifer on an identifer is
140 contained in, */
141#if 0
142static struct block *modblock=0;
143#endif
144
145
146#line 135 "m2-exp.y"
147typedef union
148 {
149 LONGEST lval;
150 ULONGEST ulval;
151 DOUBLEST dval;
152 struct symbol *sym;
153 struct type *tval;
154 struct stoken sval;
155 int voidval;
156 struct block *bval;
157 enum exp_opcode opcode;
158 struct internalvar *ivar;
159
160 struct type **tvec;
161 int *ivec;
162 } YYSTYPE;
163#include <stdio.h>
164
165#ifndef __cplusplus
166#ifndef __STDC__
167#define const
168#endif
169#endif
170
171
172
173#define YYFINAL 181
174#define YYFLAG -32768
175#define YYNTBASE 68
176
177#define YYTRANSLATE(x) ((unsigned)(x) <= 303 ? yytranslate[x] : 82)
178
179static const char yytranslate[] = { 0,
180 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
181 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
182 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
183 2, 2, 2, 2, 44, 2, 2, 48, 2, 60,
184 64, 52, 50, 35, 51, 2, 53, 2, 2, 2,
185 2, 2, 2, 2, 2, 2, 2, 2, 2, 38,
186 42, 39, 2, 49, 2, 2, 2, 2, 2, 2,
187 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
188 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
189 59, 2, 67, 57, 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, 65, 2, 66, 62, 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, 2, 2, 2, 2, 2,
202 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
203 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
204 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
205 2, 2, 2, 2, 2, 1, 2, 3, 4, 5,
206 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
207 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
208 26, 27, 28, 29, 30, 31, 32, 33, 34, 36,
209 37, 40, 41, 43, 45, 46, 47, 54, 55, 56,
210 58, 61, 63
211};
212
213#if YYDEBUG != 0
214static const short yyprhs[] = { 0,
215 0, 2, 4, 6, 9, 10, 14, 17, 20, 22,
216 24, 29, 34, 39, 44, 49, 54, 59, 66, 71,
217 76, 81, 84, 89, 96, 101, 108, 112, 114, 118,
218 125, 132, 136, 141, 142, 148, 149, 155, 156, 158,
219 162, 164, 168, 173, 178, 182, 186, 190, 194, 198,
220 202, 206, 210, 214, 218, 222, 226, 230, 234, 238,
221 242, 246, 250, 252, 254, 256, 258, 260, 262, 264,
222 269, 271, 273, 275, 279, 281, 283, 287, 289
223};
224
225static const short yyrhs[] = { 70,
226 0, 69, 0, 81, 0, 70, 57, 0, 0, 51,
227 71, 70, 0, 50, 70, 0, 72, 70, 0, 61,
228 0, 62, 0, 18, 60, 70, 64, 0, 19, 60,
229 70, 64, 0, 21, 60, 70, 64, 0, 20, 60,
230 70, 64, 0, 22, 60, 81, 64, 0, 23, 60,
231 81, 64, 0, 24, 60, 70, 64, 0, 25, 60,
232 81, 35, 70, 64, 0, 26, 60, 70, 64, 0,
233 27, 60, 70, 64, 0, 28, 60, 70, 64, 0,
234 17, 70, 0, 29, 60, 70, 64, 0, 29, 60,
235 70, 35, 70, 64, 0, 30, 60, 70, 64, 0,
236 30, 60, 70, 35, 70, 64, 0, 70, 58, 12,
237 0, 73, 0, 70, 45, 73, 0, 31, 60, 70,
238 35, 70, 64, 0, 32, 60, 70, 35, 70, 64,
239 0, 65, 76, 66, 0, 81, 65, 76, 66, 0,
240 0, 70, 59, 74, 77, 67, 0, 0, 70, 60,
241 75, 76, 64, 0, 0, 70, 0, 76, 35, 70,
242 0, 70, 0, 77, 35, 70, 0, 65, 81, 66,
243 70, 0, 81, 60, 70, 64, 0, 60, 70, 64,
244 0, 70, 49, 70, 0, 70, 52, 70, 0, 70,
245 53, 70, 0, 70, 54, 70, 0, 70, 55, 70,
246 0, 70, 50, 70, 0, 70, 51, 70, 0, 70,
247 42, 70, 0, 70, 43, 70, 0, 70, 44, 70,
248 0, 70, 40, 70, 0, 70, 41, 70, 0, 70,
249 38, 70, 0, 70, 39, 70, 0, 70, 47, 70,
250 0, 70, 46, 70, 0, 70, 37, 70, 0, 7,
251 0, 8, 0, 3, 0, 6, 0, 9, 0, 10,
252 0, 80, 0, 17, 60, 81, 64, 0, 11, 0,
253 79, 0, 13, 0, 78, 33, 13, 0, 79, 0,
254 34, 0, 78, 33, 12, 0, 12, 0, 16, 0
255};
256
257#endif
258
259#if YYDEBUG != 0
260static const short yyrline[] = { 0,
261 204, 205, 208, 217, 220, 222, 227, 231, 235, 236,
262 239, 243, 247, 251, 255, 261, 267, 271, 277, 281,
263 285, 289, 294, 298, 304, 308, 314, 320, 323, 327,
264 331, 334, 336, 342, 347, 353, 357, 363, 366, 370,
265 375, 380, 385, 391, 397, 405, 409, 413, 417, 421,
266 425, 429, 433, 437, 439, 443, 447, 451, 455, 459,
267 463, 467, 474, 480, 486, 493, 502, 510, 517, 520,
268 527, 534, 538, 547, 559, 567, 571, 587, 638
269};
270#endif
271
272
273#if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
274
275static const char * const yytname[] = { "$","error","$undefined.","INT","HEX",
276"ERROR","UINT","M2_TRUE","M2_FALSE","CHAR","FLOAT","STRING","NAME","BLOCKNAME",
277"IDENT","VARNAME","TYPENAME","SIZE","CAP","ORD","HIGH","ABS","MIN_FUNC","MAX_FUNC",
278"FLOAT_FUNC","VAL","CHR","ODD","TRUNC","INC","DEC","INCL","EXCL","COLONCOLON",
279"INTERNAL_VAR","','","ABOVE_COMMA","ASSIGN","'<'","'>'","LEQ","GEQ","'='","NOTEQUAL",
280"'#'","IN","OROR","LOGICAL_AND","'&'","'@'","'+'","'-'","'*'","'/'","DIV","MOD",
281"UNARY","'^'","DOT","'['","'('","NOT","'~'","QID","')'","'{'","'}'","']'","start",
282"type_exp","exp","@1","not_exp","set","@2","@3","arglist","non_empty_arglist",
283"block","fblock","variable","type", NULL
284};
285#endif
286
287static const short yyr1[] = { 0,
288 68, 68, 69, 70, 71, 70, 70, 70, 72, 72,
289 70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
290 70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
291 70, 73, 73, 74, 70, 75, 70, 76, 76, 76,
292 77, 77, 70, 70, 70, 70, 70, 70, 70, 70,
293 70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
294 70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
295 70, 78, 79, 79, 80, 80, 80, 80, 81
296};
297
298static const short yyr2[] = { 0,
299 1, 1, 1, 2, 0, 3, 2, 2, 1, 1,
300 4, 4, 4, 4, 4, 4, 4, 6, 4, 4,
301 4, 2, 4, 6, 4, 6, 3, 1, 3, 6,
302 6, 3, 4, 0, 5, 0, 5, 0, 1, 3,
303 1, 3, 4, 4, 3, 3, 3, 3, 3, 3,
304 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
305 3, 3, 1, 1, 1, 1, 1, 1, 1, 4,
306 1, 1, 1, 3, 1, 1, 3, 1, 1
307};
308
309static const short yydefact[] = { 0,
310 65, 66, 63, 64, 67, 68, 71, 78, 73, 79,
311 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
312 0, 0, 0, 0, 0, 0, 76, 0, 5, 0,
313 9, 10, 38, 2, 1, 0, 28, 0, 75, 69,
314 3, 0, 22, 0, 0, 0, 0, 0, 0, 0,
315 0, 0, 0, 0, 0, 0, 0, 0, 0, 7,
316 0, 0, 39, 0, 0, 0, 0, 0, 0, 0,
317 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
318 0, 0, 0, 4, 0, 34, 36, 8, 0, 0,
319 38, 0, 0, 0, 0, 0, 0, 0, 0, 0,
320 0, 0, 0, 0, 0, 0, 0, 6, 45, 0,
321 32, 0, 62, 58, 59, 56, 57, 53, 54, 55,
322 38, 29, 0, 61, 60, 46, 51, 52, 47, 48,
323 49, 50, 27, 0, 38, 77, 74, 0, 0, 70,
324 11, 12, 14, 13, 15, 16, 17, 0, 19, 20,
325 21, 0, 23, 0, 25, 0, 0, 40, 43, 41,
326 0, 0, 44, 33, 0, 0, 0, 0, 0, 0,
327 35, 37, 18, 24, 26, 30, 31, 42, 0, 0,
328 0
329};
330
331static const short yydefgoto[] = { 179,
332 34, 63, 61, 36, 37, 134, 135, 64, 161, 38,
333 39, 40, 44
334};
335
336static const short yypact[] = { 155,
337-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
338 215, -27, -22, -20, -19, 14, 24, 26, 27, 28,
339 29, 31, 32, 33, 35, 36,-32768, 155,-32768, 155,
340-32768,-32768, 155,-32768, 742, 155,-32768, -6, -4,-32768,
341 -34, 155, 5, -34, 155, 155, 155, 155, 44, 44,
342 155, 44, 155, 155, 155, 155, 155, 155, 155, 5,
343 155, 272, 742, -31, -41, 155, 155, 155, 155, 155,
344 155, 155, 155, -15, 155, 155, 155, 155, 155, 155,
345 155, 155, 155,-32768, 85,-32768,-32768, 5, -5, 155,
346 155, -21, 300, 328, 356, 384, 34, 39, 412, 64,
347 440, 468, 496, 78, 244, 692, 718, 5,-32768, 155,
348-32768, 155, 766, -37, -37, -37, -37, -37, -37, -37,
349 155,-32768, 40, 141, 201, 777, 786, 786, 5, 5,
350 5, 5,-32768, 155, 155,-32768,-32768, 524, -29,-32768,
351-32768,-32768,-32768,-32768,-32768,-32768,-32768, 155,-32768,-32768,
352-32768, 155,-32768, 155,-32768, 155, 155, 742, 5, 742,
353 -33, -32,-32768,-32768, 552, 580, 608, 636, 664, 155,
354-32768,-32768,-32768,-32768,-32768,-32768,-32768, 742, 100, 106,
355-32768
356};
357
358static const short yypgoto[] = {-32768,
359-32768, 0,-32768,-32768, 37,-32768,-32768, -86,-32768,-32768,
360-32768,-32768, 52
361};
362
363
364#define YYLAST 846
365
366
367static const short yytable[] = { 35,
368 10, 170, 110, 110, 139, 110, 136, 137, 75, 76,
369 43, 77, 78, 79, 80, 81, 82, 83, 90, 84,
370 85, 86, 87, 91, 112, 90, 89, 60, -72, 62,
371 91, 172, 45, 171, 111, 88, 164, 46, 90, 47,
372 48, 62, 140, 91, 93, 94, 95, 96, 162, 121,
373 99, 41, 101, 102, 103, 104, 105, 106, 107, 10,
374 108, 84, 85, 86, 87, 113, 114, 115, 116, 117,
375 118, 119, 120, 49, 124, 125, 126, 127, 128, 129,
376 130, 131, 132, 50, 65, 51, 52, 53, 54, 138,
377 55, 56, 57, 92, 58, 59, 133, 145, 148, 180,
378 97, 98, 146, 100, 91, 181, 0, 0, 0, 158,
379 122, 159, 152, 0, 66, 67, 68, 69, 70, 71,
380 72, 73, 74, 75, 76, 123, 77, 78, 79, 80,
381 81, 82, 83, 160, 84, 85, 86, 87, 0, 0,
382 0, 153, 0, 0, 0, 0, 0, 165, 0, 0,
383 0, 166, 0, 167, 0, 168, 169, 1, 0, 0,
384 2, 3, 4, 5, 6, 7, 8, 9, 0, 178,
385 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
386 20, 21, 22, 23, 24, 25, 26, 76, 27, 77,
387 78, 79, 80, 81, 82, 83, 0, 84, 85, 86,
388 87, 0, 0, 0, 28, 29, 0, 0, 0, 0,
389 0, 0, 0, 0, 30, 31, 32, 1, 0, 33,
390 2, 3, 4, 5, 6, 7, 8, 9, 0, 0,
391 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
392 20, 21, 22, 23, 24, 25, 26, 0, 27, 77,
393 78, 79, 80, 81, 82, 83, 0, 84, 85, 86,
394 87, 0, 0, 0, 28, 29, 0, 0, 0, 0,
395 0, 0, 0, 0, 42, 31, 32, 0, 154, 33,
396 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
397 76, 0, 77, 78, 79, 80, 81, 82, 83, 0,
398 84, 85, 86, 87, 0, 0, 0, 155, 66, 67,
399 68, 69, 70, 71, 72, 73, 74, 75, 76, 0,
400 77, 78, 79, 80, 81, 82, 83, 0, 84, 85,
401 86, 87, 0, 0, 0, 109, 66, 67, 68, 69,
402 70, 71, 72, 73, 74, 75, 76, 0, 77, 78,
403 79, 80, 81, 82, 83, 0, 84, 85, 86, 87,
404 0, 0, 0, 141, 66, 67, 68, 69, 70, 71,
405 72, 73, 74, 75, 76, 0, 77, 78, 79, 80,
406 81, 82, 83, 0, 84, 85, 86, 87, 0, 0,
407 0, 142, 66, 67, 68, 69, 70, 71, 72, 73,
408 74, 75, 76, 0, 77, 78, 79, 80, 81, 82,
409 83, 0, 84, 85, 86, 87, 0, 0, 0, 143,
410 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
411 76, 0, 77, 78, 79, 80, 81, 82, 83, 0,
412 84, 85, 86, 87, 0, 0, 0, 144, 66, 67,
413 68, 69, 70, 71, 72, 73, 74, 75, 76, 0,
414 77, 78, 79, 80, 81, 82, 83, 0, 84, 85,
415 86, 87, 0, 0, 0, 147, 66, 67, 68, 69,
416 70, 71, 72, 73, 74, 75, 76, 0, 77, 78,
417 79, 80, 81, 82, 83, 0, 84, 85, 86, 87,
418 0, 0, 0, 149, 66, 67, 68, 69, 70, 71,
419 72, 73, 74, 75, 76, 0, 77, 78, 79, 80,
420 81, 82, 83, 0, 84, 85, 86, 87, 0, 0,
421 0, 150, 66, 67, 68, 69, 70, 71, 72, 73,
422 74, 75, 76, 0, 77, 78, 79, 80, 81, 82,
423 83, 0, 84, 85, 86, 87, 0, 0, 0, 151,
424 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
425 76, 0, 77, 78, 79, 80, 81, 82, 83, 0,
426 84, 85, 86, 87, 0, 0, 0, 163, 66, 67,
427 68, 69, 70, 71, 72, 73, 74, 75, 76, 0,
428 77, 78, 79, 80, 81, 82, 83, 0, 84, 85,
429 86, 87, 0, 0, 0, 173, 66, 67, 68, 69,
430 70, 71, 72, 73, 74, 75, 76, 0, 77, 78,
431 79, 80, 81, 82, 83, 0, 84, 85, 86, 87,
432 0, 0, 0, 174, 66, 67, 68, 69, 70, 71,
433 72, 73, 74, 75, 76, 0, 77, 78, 79, 80,
434 81, 82, 83, 0, 84, 85, 86, 87, 0, 0,
435 0, 175, 66, 67, 68, 69, 70, 71, 72, 73,
436 74, 75, 76, 0, 77, 78, 79, 80, 81, 82,
437 83, 0, 84, 85, 86, 87, 0, 0, 0, 176,
438 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
439 76, 0, 77, 78, 79, 80, 81, 82, 83, 0,
440 84, 85, 86, 87, 0, 0, 156, 177, 66, 67,
441 68, 69, 70, 71, 72, 73, 74, 75, 76, 0,
442 77, 78, 79, 80, 81, 82, 83, 0, 84, 85,
443 86, 87, 157, 0, 66, 67, 68, 69, 70, 71,
444 72, 73, 74, 75, 76, 0, 77, 78, 79, 80,
445 81, 82, 83, 0, 84, 85, 86, 87, 66, 67,
446 68, 69, 70, 71, 72, 73, 74, 75, 76, 0,
447 77, 78, 79, 80, 81, 82, 83, 0, 84, 85,
448 86, 87,-32768, 67, 68, 69, 70, 71, 72, 73,
449 74, 75, 76, 0, 77, 78, 79, 80, 81, 82,
450 83, 0, 84, 85, 86, 87, 78, 79, 80, 81,
451 82, 83, 0, 84, 85, 86, 87, 80, 81, 82,
452 83, 0, 84, 85, 86, 87
453};
454
455static const short yycheck[] = { 0,
456 16, 35, 35, 35, 91, 35, 12, 13, 46, 47,
457 11, 49, 50, 51, 52, 53, 54, 55, 60, 57,
458 58, 59, 60, 65, 66, 60, 33, 28, 33, 30,
459 65, 64, 60, 67, 66, 36, 66, 60, 60, 60,
460 60, 42, 64, 65, 45, 46, 47, 48, 135, 65,
461 51, 0, 53, 54, 55, 56, 57, 58, 59, 16,
462 61, 57, 58, 59, 60, 66, 67, 68, 69, 70,
463 71, 72, 73, 60, 75, 76, 77, 78, 79, 80,
464 81, 82, 83, 60, 33, 60, 60, 60, 60, 90,
465 60, 60, 60, 42, 60, 60, 12, 64, 35, 0,
466 49, 50, 64, 52, 65, 0, -1, -1, -1, 110,
467 74, 112, 35, -1, 37, 38, 39, 40, 41, 42,
468 43, 44, 45, 46, 47, 74, 49, 50, 51, 52,
469 53, 54, 55, 134, 57, 58, 59, 60, -1, -1,
470 -1, 64, -1, -1, -1, -1, -1, 148, -1, -1,
471 -1, 152, -1, 154, -1, 156, 157, 3, -1, -1,
472 6, 7, 8, 9, 10, 11, 12, 13, -1, 170,
473 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
474 26, 27, 28, 29, 30, 31, 32, 47, 34, 49,
475 50, 51, 52, 53, 54, 55, -1, 57, 58, 59,
476 60, -1, -1, -1, 50, 51, -1, -1, -1, -1,
477 -1, -1, -1, -1, 60, 61, 62, 3, -1, 65,
478 6, 7, 8, 9, 10, 11, 12, 13, -1, -1,
479 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
480 26, 27, 28, 29, 30, 31, 32, -1, 34, 49,
481 50, 51, 52, 53, 54, 55, -1, 57, 58, 59,
482 60, -1, -1, -1, 50, 51, -1, -1, -1, -1,
483 -1, -1, -1, -1, 60, 61, 62, -1, 35, 65,
484 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
485 47, -1, 49, 50, 51, 52, 53, 54, 55, -1,
486 57, 58, 59, 60, -1, -1, -1, 64, 37, 38,
487 39, 40, 41, 42, 43, 44, 45, 46, 47, -1,
488 49, 50, 51, 52, 53, 54, 55, -1, 57, 58,
489 59, 60, -1, -1, -1, 64, 37, 38, 39, 40,
490 41, 42, 43, 44, 45, 46, 47, -1, 49, 50,
491 51, 52, 53, 54, 55, -1, 57, 58, 59, 60,
492 -1, -1, -1, 64, 37, 38, 39, 40, 41, 42,
493 43, 44, 45, 46, 47, -1, 49, 50, 51, 52,
494 53, 54, 55, -1, 57, 58, 59, 60, -1, -1,
495 -1, 64, 37, 38, 39, 40, 41, 42, 43, 44,
496 45, 46, 47, -1, 49, 50, 51, 52, 53, 54,
497 55, -1, 57, 58, 59, 60, -1, -1, -1, 64,
498 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
499 47, -1, 49, 50, 51, 52, 53, 54, 55, -1,
500 57, 58, 59, 60, -1, -1, -1, 64, 37, 38,
501 39, 40, 41, 42, 43, 44, 45, 46, 47, -1,
502 49, 50, 51, 52, 53, 54, 55, -1, 57, 58,
503 59, 60, -1, -1, -1, 64, 37, 38, 39, 40,
504 41, 42, 43, 44, 45, 46, 47, -1, 49, 50,
505 51, 52, 53, 54, 55, -1, 57, 58, 59, 60,
506 -1, -1, -1, 64, 37, 38, 39, 40, 41, 42,
507 43, 44, 45, 46, 47, -1, 49, 50, 51, 52,
508 53, 54, 55, -1, 57, 58, 59, 60, -1, -1,
509 -1, 64, 37, 38, 39, 40, 41, 42, 43, 44,
510 45, 46, 47, -1, 49, 50, 51, 52, 53, 54,
511 55, -1, 57, 58, 59, 60, -1, -1, -1, 64,
512 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
513 47, -1, 49, 50, 51, 52, 53, 54, 55, -1,
514 57, 58, 59, 60, -1, -1, -1, 64, 37, 38,
515 39, 40, 41, 42, 43, 44, 45, 46, 47, -1,
516 49, 50, 51, 52, 53, 54, 55, -1, 57, 58,
517 59, 60, -1, -1, -1, 64, 37, 38, 39, 40,
518 41, 42, 43, 44, 45, 46, 47, -1, 49, 50,
519 51, 52, 53, 54, 55, -1, 57, 58, 59, 60,
520 -1, -1, -1, 64, 37, 38, 39, 40, 41, 42,
521 43, 44, 45, 46, 47, -1, 49, 50, 51, 52,
522 53, 54, 55, -1, 57, 58, 59, 60, -1, -1,
523 -1, 64, 37, 38, 39, 40, 41, 42, 43, 44,
524 45, 46, 47, -1, 49, 50, 51, 52, 53, 54,
525 55, -1, 57, 58, 59, 60, -1, -1, -1, 64,
526 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
527 47, -1, 49, 50, 51, 52, 53, 54, 55, -1,
528 57, 58, 59, 60, -1, -1, 35, 64, 37, 38,
529 39, 40, 41, 42, 43, 44, 45, 46, 47, -1,
530 49, 50, 51, 52, 53, 54, 55, -1, 57, 58,
531 59, 60, 35, -1, 37, 38, 39, 40, 41, 42,
532 43, 44, 45, 46, 47, -1, 49, 50, 51, 52,
533 53, 54, 55, -1, 57, 58, 59, 60, 37, 38,
534 39, 40, 41, 42, 43, 44, 45, 46, 47, -1,
535 49, 50, 51, 52, 53, 54, 55, -1, 57, 58,
536 59, 60, 37, 38, 39, 40, 41, 42, 43, 44,
537 45, 46, 47, -1, 49, 50, 51, 52, 53, 54,
538 55, -1, 57, 58, 59, 60, 50, 51, 52, 53,
539 54, 55, -1, 57, 58, 59, 60, 52, 53, 54,
540 55, -1, 57, 58, 59, 60
541};
542/* -*-C-*- Note some compilers choke on comments on `#line' lines. */
543#line 3 "/stone/jimb/main-98r2/share/bison.simple"
544
545/* Skeleton output parser for bison,
546 Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
547
548 This program is free software; you can redistribute it and/or modify
549 it under the terms of the GNU General Public License as published by
550 the Free Software Foundation; either version 2, or (at your option)
551 any later version.
552
553 This program is distributed in the hope that it will be useful,
554 but WITHOUT ANY WARRANTY; without even the implied warranty of
555 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
556 GNU General Public License for more details.
557
558 You should have received a copy of the GNU General Public License
559 along with this program; if not, write to the Free Software
560 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
561
562/* As a special exception, when this file is copied by Bison into a
563 Bison output file, you may use that output file without restriction.
564 This special exception was added by the Free Software Foundation
565 in version 1.24 of Bison. */
566
567#ifndef alloca
568#ifdef __GNUC__
569#define alloca __builtin_alloca
570#else /* not GNU C. */
571#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi)
572#include <alloca.h>
573#else /* not sparc */
574#if defined (MSDOS) && !defined (__TURBOC__)
575#else /* not MSDOS, or __TURBOC__ */
576#if defined(_AIX)
577 #pragma alloca
578#else /* not MSDOS, __TURBOC__, or _AIX */
579#ifdef __hpux
580#ifdef __cplusplus
581extern "C" {
582void *alloca (unsigned int);
583};
584#else /* not __cplusplus */
585void *alloca ();
586#endif /* not __cplusplus */
587#endif /* __hpux */
588#endif /* not _AIX */
589#endif /* not MSDOS, or __TURBOC__ */
590#endif /* not sparc. */
591#endif /* not GNU C. */
592#endif /* alloca not defined. */
593
594/* This is the parser code that is written into each bison parser
595 when the %semantic_parser declaration is not specified in the grammar.
596 It was written by Richard Stallman by simplifying the hairy parser
597 used when %semantic_parser is specified. */
598
599/* Note: there must be only one dollar sign in this file.
600 It is replaced by the list of actions, each action
601 as one case of the switch. */
602
603#define yyerrok (yyerrstatus = 0)
604#define yyclearin (yychar = YYEMPTY)
605#define YYEMPTY -2
606#define YYEOF 0
607#define YYACCEPT return(0)
608#define YYABORT return(1)
609#define YYERROR goto yyerrlab1
610/* Like YYERROR except do call yyerror.
611 This remains here temporarily to ease the
612 transition to the new meaning of YYERROR, for GCC.
613 Once GCC version 2 has supplanted version 1, this can go. */
614#define YYFAIL goto yyerrlab
615#define YYRECOVERING() (!!yyerrstatus)
616#define YYBACKUP(token, value) \
617do \
618 if (yychar == YYEMPTY && yylen == 1) \
619 { yychar = (token), yylval = (value); \
620 yychar1 = YYTRANSLATE (yychar); \
621 YYPOPSTACK; \
622 goto yybackup; \
623 } \
624 else \
625 { yyerror ("syntax error: cannot back up"); YYERROR; } \
626while (0)
627
628#define YYTERROR 1
629#define YYERRCODE 256
630
631#ifndef YYPURE
632#define YYLEX yylex()
633#endif
634
635#ifdef YYPURE
636#ifdef YYLSP_NEEDED
637#ifdef YYLEX_PARAM
638#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM)
639#else
640#define YYLEX yylex(&yylval, &yylloc)
641#endif
642#else /* not YYLSP_NEEDED */
643#ifdef YYLEX_PARAM
644#define YYLEX yylex(&yylval, YYLEX_PARAM)
645#else
646#define YYLEX yylex(&yylval)
647#endif
648#endif /* not YYLSP_NEEDED */
649#endif
650
651/* If nonreentrant, generate the variables here */
652
653#ifndef YYPURE
654
655int yychar; /* the lookahead symbol */
656YYSTYPE yylval; /* the semantic value of the */
657 /* lookahead symbol */
658
659#ifdef YYLSP_NEEDED
660YYLTYPE yylloc; /* location data for the lookahead */
661 /* symbol */
662#endif
663
664int yynerrs; /* number of parse errors so far */
665#endif /* not YYPURE */
666
667#if YYDEBUG != 0
668int yydebug; /* nonzero means print parse trace */
669/* Since this is uninitialized, it does not stop multiple parsers
670 from coexisting. */
671#endif
672
673/* YYINITDEPTH indicates the initial size of the parser's stacks */
674
675#ifndef YYINITDEPTH
676#define YYINITDEPTH 200
677#endif
678
679/* YYMAXDEPTH is the maximum size the stacks can grow to
680 (effective only if the built-in stack extension method is used). */
681
682#if YYMAXDEPTH == 0
683#undef YYMAXDEPTH
684#endif
685
686#ifndef YYMAXDEPTH
687#define YYMAXDEPTH 10000
688#endif
689
690/* Prevent warning if -Wstrict-prototypes. */
691#ifdef __GNUC__
692int yyparse (void);
693#endif
694\f
695#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
696#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT)
697#else /* not GNU C or C++ */
698#ifndef __cplusplus
699
700/* This is the most reliable way to avoid incompatibilities
701 in available built-in functions on various systems. */
702static void
703__yy_memcpy (to, from, count)
704 char *to;
705 char *from;
706 int count;
707{
708 register char *f = from;
709 register char *t = to;
710 register int i = count;
711
712 while (i-- > 0)
713 *t++ = *f++;
714}
715
716#else /* __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 (char *to, char *from, int count)
722{
723 register char *f = from;
724 register char *t = to;
725 register int i = count;
726
727 while (i-- > 0)
728 *t++ = *f++;
729}
730
731#endif
732#endif
733\f
734#line 196 "/stone/jimb/main-98r2/share/bison.simple"
735
736/* The user can define YYPARSE_PARAM as the name of an argument to be passed
737 into yyparse. The argument should have type void *.
738 It should actually point to an object.
739 Grammar actions can access the variable by casting it
740 to the proper pointer type. */
741
742#ifdef YYPARSE_PARAM
743#ifdef __cplusplus
744#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
745#define YYPARSE_PARAM_DECL
746#else /* not __cplusplus */
747#define YYPARSE_PARAM_ARG YYPARSE_PARAM
748#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
749#endif /* not __cplusplus */
750#else /* not YYPARSE_PARAM */
751#define YYPARSE_PARAM_ARG
752#define YYPARSE_PARAM_DECL
753#endif /* not YYPARSE_PARAM */
754
755int
756yyparse(YYPARSE_PARAM_ARG)
757 YYPARSE_PARAM_DECL
758{
759 register int yystate;
760 register int yyn;
761 register short *yyssp;
762 register YYSTYPE *yyvsp;
763 int yyerrstatus; /* number of tokens to shift before error messages enabled */
764 int yychar1 = 0; /* lookahead token as an internal (translated) token number */
765
766 short yyssa[YYINITDEPTH]; /* the state stack */
767 YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */
768
769 short *yyss = yyssa; /* refer to the stacks thru separate pointers */
770 YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to xreallocate them elsewhere */
771
772#ifdef YYLSP_NEEDED
773 YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */
774 YYLTYPE *yyls = yylsa;
775 YYLTYPE *yylsp;
776
777#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
778#else
779#define YYPOPSTACK (yyvsp--, yyssp--)
780#endif
781
782 int yystacksize = YYINITDEPTH;
783
784#ifdef YYPURE
785 int yychar;
786 YYSTYPE yylval;
787 int yynerrs;
788#ifdef YYLSP_NEEDED
789 YYLTYPE yylloc;
790#endif
791#endif
792
793 YYSTYPE yyval; /* the variable used to return */
794 /* semantic values from the action */
795 /* routines */
796
797 int yylen;
798
799#if YYDEBUG != 0
800 if (yydebug)
801 fprintf(stderr, "Starting parse\n");
802#endif
803
804 yystate = 0;
805 yyerrstatus = 0;
806 yynerrs = 0;
807 yychar = YYEMPTY; /* Cause a token to be read. */
808
809 /* Initialize stack pointers.
810 Waste one element of value and location stack
811 so that they stay on the same level as the state stack.
812 The wasted elements are never initialized. */
813
814 yyssp = yyss - 1;
815 yyvsp = yyvs;
816#ifdef YYLSP_NEEDED
817 yylsp = yyls;
818#endif
819
820/* Push a new state, which is found in yystate . */
821/* In all cases, when you get here, the value and location stacks
822 have just been pushed. so pushing a state here evens the stacks. */
823yynewstate:
824
825 *++yyssp = yystate;
826
827 if (yyssp >= yyss + yystacksize - 1)
828 {
829 /* Give user a chance to xreallocate the stack */
830 /* Use copies of these so that the &'s don't force the real ones into memory. */
831 YYSTYPE *yyvs1 = yyvs;
832 short *yyss1 = yyss;
833#ifdef YYLSP_NEEDED
834 YYLTYPE *yyls1 = yyls;
835#endif
836
837 /* Get the current used size of the three stacks, in elements. */
838 int size = yyssp - yyss + 1;
839
840#ifdef yyoverflow
841 /* Each stack pointer address is followed by the size of
842 the data in use in that stack, in bytes. */
843#ifdef YYLSP_NEEDED
844 /* This used to be a conditional around just the two extra args,
845 but that might be undefined if yyoverflow is a macro. */
846 yyoverflow("parser stack overflow",
847 &yyss1, size * sizeof (*yyssp),
848 &yyvs1, size * sizeof (*yyvsp),
849 &yyls1, size * sizeof (*yylsp),
850 &yystacksize);
851#else
852 yyoverflow("parser stack overflow",
853 &yyss1, size * sizeof (*yyssp),
854 &yyvs1, size * sizeof (*yyvsp),
855 &yystacksize);
856#endif
857
858 yyss = yyss1; yyvs = yyvs1;
859#ifdef YYLSP_NEEDED
860 yyls = yyls1;
861#endif
862#else /* no yyoverflow */
863 /* Extend the stack our own way. */
864 if (yystacksize >= YYMAXDEPTH)
865 {
866 yyerror("parser stack overflow");
867 return 2;
868 }
869 yystacksize *= 2;
870 if (yystacksize > YYMAXDEPTH)
871 yystacksize = YYMAXDEPTH;
872 yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
873 __yy_memcpy ((char *)yyss, (char *)yyss1, size * sizeof (*yyssp));
874 yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
875 __yy_memcpy ((char *)yyvs, (char *)yyvs1, size * sizeof (*yyvsp));
876#ifdef YYLSP_NEEDED
877 yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
878 __yy_memcpy ((char *)yyls, (char *)yyls1, size * sizeof (*yylsp));
879#endif
880#endif /* no yyoverflow */
881
882 yyssp = yyss + size - 1;
883 yyvsp = yyvs + size - 1;
884#ifdef YYLSP_NEEDED
885 yylsp = yyls + size - 1;
886#endif
887
888#if YYDEBUG != 0
889 if (yydebug)
890 fprintf(stderr, "Stack size increased to %d\n", yystacksize);
891#endif
892
893 if (yyssp >= yyss + yystacksize - 1)
894 YYABORT;
895 }
896
897#if YYDEBUG != 0
898 if (yydebug)
899 fprintf(stderr, "Entering state %d\n", yystate);
900#endif
901
902 goto yybackup;
903 yybackup:
904
905/* Do appropriate processing given the current state. */
906/* Read a lookahead token if we need one and don't already have one. */
907/* yyresume: */
908
909 /* First try to decide what to do without reference to lookahead token. */
910
911 yyn = yypact[yystate];
912 if (yyn == YYFLAG)
913 goto yydefault;
914
915 /* Not known => get a lookahead token if don't already have one. */
916
917 /* yychar is either YYEMPTY or YYEOF
918 or a valid token in external form. */
919
920 if (yychar == YYEMPTY)
921 {
922#if YYDEBUG != 0
923 if (yydebug)
924 fprintf(stderr, "Reading a token: ");
925#endif
926 yychar = YYLEX;
927 }
928
929 /* Convert token to internal form (in yychar1) for indexing tables with */
930
931 if (yychar <= 0) /* This means end of input. */
932 {
933 yychar1 = 0;
934 yychar = YYEOF; /* Don't call YYLEX any more */
935
936#if YYDEBUG != 0
937 if (yydebug)
938 fprintf(stderr, "Now at end of input.\n");
939#endif
940 }
941 else
942 {
943 yychar1 = YYTRANSLATE(yychar);
944
945#if YYDEBUG != 0
946 if (yydebug)
947 {
948 fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
949 /* Give the individual parser a way to print the precise meaning
950 of a token, for further debugging info. */
951#ifdef YYPRINT
952 YYPRINT (stderr, yychar, yylval);
953#endif
954 fprintf (stderr, ")\n");
955 }
956#endif
957 }
958
959 yyn += yychar1;
960 if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
961 goto yydefault;
962
963 yyn = yytable[yyn];
964
965 /* yyn is what to do for this token type in this state.
966 Negative => reduce, -yyn is rule number.
967 Positive => shift, yyn is new state.
968 New state is final state => don't bother to shift,
969 just return success.
970 0, or most negative number => error. */
971
972 if (yyn < 0)
973 {
974 if (yyn == YYFLAG)
975 goto yyerrlab;
976 yyn = -yyn;
977 goto yyreduce;
978 }
979 else if (yyn == 0)
980 goto yyerrlab;
981
982 if (yyn == YYFINAL)
983 YYACCEPT;
984
985 /* Shift the lookahead token. */
986
987#if YYDEBUG != 0
988 if (yydebug)
989 fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
990#endif
991
992 /* Discard the token being shifted unless it is eof. */
993 if (yychar != YYEOF)
994 yychar = YYEMPTY;
995
996 *++yyvsp = yylval;
997#ifdef YYLSP_NEEDED
998 *++yylsp = yylloc;
999#endif
1000
1001 /* count tokens shifted since error; after three, turn off error status. */
1002 if (yyerrstatus) yyerrstatus--;
1003
1004 yystate = yyn;
1005 goto yynewstate;
1006
1007/* Do the default action for the current state. */
1008yydefault:
1009
1010 yyn = yydefact[yystate];
1011 if (yyn == 0)
1012 goto yyerrlab;
1013
1014/* Do a reduction. yyn is the number of a rule to reduce with. */
1015yyreduce:
1016 yylen = yyr2[yyn];
1017 if (yylen > 0)
1018 yyval = yyvsp[1-yylen]; /* implement default value of the action */
1019
1020#if YYDEBUG != 0
1021 if (yydebug)
1022 {
1023 int i;
1024
1025 fprintf (stderr, "Reducing via rule %d (line %d), ",
1026 yyn, yyrline[yyn]);
1027
1028 /* Print the symbols being reduced, and their result. */
1029 for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
1030 fprintf (stderr, "%s ", yytname[yyrhs[i]]);
1031 fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
1032 }
1033#endif
1034
1035
1036 switch (yyn) {
1037
1038case 3:
1039#line 209 "m2-exp.y"
1040{ write_exp_elt_opcode(OP_TYPE);
1041 write_exp_elt_type(yyvsp[0].tval);
1042 write_exp_elt_opcode(OP_TYPE);
1043 ;
1044 break;}
1045case 4:
1046#line 218 "m2-exp.y"
1047{ write_exp_elt_opcode (UNOP_IND); ;
1048 break;}
1049case 5:
1050#line 221 "m2-exp.y"
1051{ number_sign = -1; ;
1052 break;}
1053case 6:
1054#line 223 "m2-exp.y"
1055{ number_sign = 1;
1056 write_exp_elt_opcode (UNOP_NEG); ;
1057 break;}
1058case 7:
1059#line 228 "m2-exp.y"
1060{ write_exp_elt_opcode(UNOP_PLUS); ;
1061 break;}
1062case 8:
1063#line 232 "m2-exp.y"
1064{ write_exp_elt_opcode (UNOP_LOGICAL_NOT); ;
1065 break;}
1066case 11:
1067#line 240 "m2-exp.y"
1068{ write_exp_elt_opcode (UNOP_CAP); ;
1069 break;}
1070case 12:
1071#line 244 "m2-exp.y"
1072{ write_exp_elt_opcode (UNOP_ORD); ;
1073 break;}
1074case 13:
1075#line 248 "m2-exp.y"
1076{ write_exp_elt_opcode (UNOP_ABS); ;
1077 break;}
1078case 14:
1079#line 252 "m2-exp.y"
1080{ write_exp_elt_opcode (UNOP_HIGH); ;
1081 break;}
1082case 15:
1083#line 256 "m2-exp.y"
1084{ write_exp_elt_opcode (UNOP_MIN);
1085 write_exp_elt_type (yyvsp[-1].tval);
1086 write_exp_elt_opcode (UNOP_MIN); ;
1087 break;}
1088case 16:
1089#line 262 "m2-exp.y"
1090{ write_exp_elt_opcode (UNOP_MAX);
1091 write_exp_elt_type (yyvsp[-1].tval);
1092 write_exp_elt_opcode (UNOP_MIN); ;
1093 break;}
1094case 17:
1095#line 268 "m2-exp.y"
1096{ write_exp_elt_opcode (UNOP_FLOAT); ;
1097 break;}
1098case 18:
1099#line 272 "m2-exp.y"
1100{ write_exp_elt_opcode (BINOP_VAL);
1101 write_exp_elt_type (yyvsp[-3].tval);
1102 write_exp_elt_opcode (BINOP_VAL); ;
1103 break;}
1104case 19:
1105#line 278 "m2-exp.y"
1106{ write_exp_elt_opcode (UNOP_CHR); ;
1107 break;}
1108case 20:
1109#line 282 "m2-exp.y"
1110{ write_exp_elt_opcode (UNOP_ODD); ;
1111 break;}
1112case 21:
1113#line 286 "m2-exp.y"
1114{ write_exp_elt_opcode (UNOP_TRUNC); ;
1115 break;}
1116case 22:
1117#line 290 "m2-exp.y"
1118{ write_exp_elt_opcode (UNOP_SIZEOF); ;
1119 break;}
1120case 23:
1121#line 295 "m2-exp.y"
1122{ write_exp_elt_opcode(UNOP_PREINCREMENT); ;
1123 break;}
1124case 24:
1125#line 299 "m2-exp.y"
1126{ write_exp_elt_opcode(BINOP_ASSIGN_MODIFY);
1127 write_exp_elt_opcode(BINOP_ADD);
1128 write_exp_elt_opcode(BINOP_ASSIGN_MODIFY); ;
1129 break;}
1130case 25:
1131#line 305 "m2-exp.y"
1132{ write_exp_elt_opcode(UNOP_PREDECREMENT);;
1133 break;}
1134case 26:
1135#line 309 "m2-exp.y"
1136{ write_exp_elt_opcode(BINOP_ASSIGN_MODIFY);
1137 write_exp_elt_opcode(BINOP_SUB);
1138 write_exp_elt_opcode(BINOP_ASSIGN_MODIFY); ;
1139 break;}
1140case 27:
1141#line 315 "m2-exp.y"
1142{ write_exp_elt_opcode (STRUCTOP_STRUCT);
1143 write_exp_string (yyvsp[0].sval);
1144 write_exp_elt_opcode (STRUCTOP_STRUCT); ;
1145 break;}
1146case 29:
1147#line 324 "m2-exp.y"
1148{ error("Sets are not implemented.");;
1149 break;}
1150case 30:
1151#line 328 "m2-exp.y"
1152{ error("Sets are not implemented.");;
1153 break;}
1154case 31:
1155#line 332 "m2-exp.y"
1156{ error("Sets are not implemented.");;
1157 break;}
1158case 32:
1159#line 335 "m2-exp.y"
1160{ error("Sets are not implemented.");;
1161 break;}
1162case 33:
1163#line 337 "m2-exp.y"
1164{ error("Sets are not implemented.");;
1165 break;}
1166case 34:
1167#line 346 "m2-exp.y"
1168{ start_arglist(); ;
1169 break;}
1170case 35:
1171#line 348 "m2-exp.y"
1172{ write_exp_elt_opcode (MULTI_SUBSCRIPT);
1173 write_exp_elt_longcst ((LONGEST) end_arglist());
1174 write_exp_elt_opcode (MULTI_SUBSCRIPT); ;
1175 break;}
1176case 36:
1177#line 356 "m2-exp.y"
1178{ start_arglist (); ;
1179 break;}
1180case 37:
1181#line 358 "m2-exp.y"
1182{ write_exp_elt_opcode (OP_FUNCALL);
1183 write_exp_elt_longcst ((LONGEST) end_arglist ());
1184 write_exp_elt_opcode (OP_FUNCALL); ;
1185 break;}
1186case 39:
1187#line 367 "m2-exp.y"
1188{ arglist_len = 1; ;
1189 break;}
1190case 40:
1191#line 371 "m2-exp.y"
1192{ arglist_len++; ;
1193 break;}
1194case 41:
1195#line 376 "m2-exp.y"
1196{ arglist_len = 1; ;
1197 break;}
1198case 42:
1199#line 381 "m2-exp.y"
1200{ arglist_len++; ;
1201 break;}
1202case 43:
1203#line 386 "m2-exp.y"
1204{ write_exp_elt_opcode (UNOP_MEMVAL);
1205 write_exp_elt_type (yyvsp[-2].tval);
1206 write_exp_elt_opcode (UNOP_MEMVAL); ;
1207 break;}
1208case 44:
1209#line 392 "m2-exp.y"
1210{ write_exp_elt_opcode (UNOP_CAST);
1211 write_exp_elt_type (yyvsp[-3].tval);
1212 write_exp_elt_opcode (UNOP_CAST); ;
1213 break;}
1214case 45:
1215#line 398 "m2-exp.y"
1216{ ;
1217 break;}
1218case 46:
1219#line 406 "m2-exp.y"
1220{ write_exp_elt_opcode (BINOP_REPEAT); ;
1221 break;}
1222case 47:
1223#line 410 "m2-exp.y"
1224{ write_exp_elt_opcode (BINOP_MUL); ;
1225 break;}
1226case 48:
1227#line 414 "m2-exp.y"
1228{ write_exp_elt_opcode (BINOP_DIV); ;
1229 break;}
1230case 49:
1231#line 418 "m2-exp.y"
1232{ write_exp_elt_opcode (BINOP_INTDIV); ;
1233 break;}
1234case 50:
1235#line 422 "m2-exp.y"
1236{ write_exp_elt_opcode (BINOP_REM); ;
1237 break;}
1238case 51:
1239#line 426 "m2-exp.y"
1240{ write_exp_elt_opcode (BINOP_ADD); ;
1241 break;}
1242case 52:
1243#line 430 "m2-exp.y"
1244{ write_exp_elt_opcode (BINOP_SUB); ;
1245 break;}
1246case 53:
1247#line 434 "m2-exp.y"
1248{ write_exp_elt_opcode (BINOP_EQUAL); ;
1249 break;}
1250case 54:
1251#line 438 "m2-exp.y"
1252{ write_exp_elt_opcode (BINOP_NOTEQUAL); ;
1253 break;}
1254case 55:
1255#line 440 "m2-exp.y"
1256{ write_exp_elt_opcode (BINOP_NOTEQUAL); ;
1257 break;}
1258case 56:
1259#line 444 "m2-exp.y"
1260{ write_exp_elt_opcode (BINOP_LEQ); ;
1261 break;}
1262case 57:
1263#line 448 "m2-exp.y"
1264{ write_exp_elt_opcode (BINOP_GEQ); ;
1265 break;}
1266case 58:
1267#line 452 "m2-exp.y"
1268{ write_exp_elt_opcode (BINOP_LESS); ;
1269 break;}
1270case 59:
1271#line 456 "m2-exp.y"
1272{ write_exp_elt_opcode (BINOP_GTR); ;
1273 break;}
1274case 60:
1275#line 460 "m2-exp.y"
1276{ write_exp_elt_opcode (BINOP_LOGICAL_AND); ;
1277 break;}
1278case 61:
1279#line 464 "m2-exp.y"
1280{ write_exp_elt_opcode (BINOP_LOGICAL_OR); ;
1281 break;}
1282case 62:
1283#line 468 "m2-exp.y"
1284{ write_exp_elt_opcode (BINOP_ASSIGN); ;
1285 break;}
1286case 63:
1287#line 475 "m2-exp.y"
1288{ write_exp_elt_opcode (OP_BOOL);
1289 write_exp_elt_longcst ((LONGEST) yyvsp[0].ulval);
1290 write_exp_elt_opcode (OP_BOOL); ;
1291 break;}
1292case 64:
1293#line 481 "m2-exp.y"
1294{ write_exp_elt_opcode (OP_BOOL);
1295 write_exp_elt_longcst ((LONGEST) yyvsp[0].ulval);
1296 write_exp_elt_opcode (OP_BOOL); ;
1297 break;}
1298case 65:
1299#line 487 "m2-exp.y"
1300{ write_exp_elt_opcode (OP_LONG);
1301 write_exp_elt_type (builtin_type_m2_int);
1302 write_exp_elt_longcst ((LONGEST) yyvsp[0].lval);
1303 write_exp_elt_opcode (OP_LONG); ;
1304 break;}
1305case 66:
1306#line 494 "m2-exp.y"
1307{
1308 write_exp_elt_opcode (OP_LONG);
1309 write_exp_elt_type (builtin_type_m2_card);
1310 write_exp_elt_longcst ((LONGEST) yyvsp[0].ulval);
1311 write_exp_elt_opcode (OP_LONG);
1312 ;
1313 break;}
1314case 67:
1315#line 503 "m2-exp.y"
1316{ write_exp_elt_opcode (OP_LONG);
1317 write_exp_elt_type (builtin_type_m2_char);
1318 write_exp_elt_longcst ((LONGEST) yyvsp[0].ulval);
1319 write_exp_elt_opcode (OP_LONG); ;
1320 break;}
1321case 68:
1322#line 511 "m2-exp.y"
1323{ write_exp_elt_opcode (OP_DOUBLE);
1324 write_exp_elt_type (builtin_type_m2_real);
1325 write_exp_elt_dblcst (yyvsp[0].dval);
1326 write_exp_elt_opcode (OP_DOUBLE); ;
1327 break;}
1328case 70:
1329#line 521 "m2-exp.y"
1330{ write_exp_elt_opcode (OP_LONG);
1331 write_exp_elt_type (builtin_type_int);
1332 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH (yyvsp[-1].tval));
1333 write_exp_elt_opcode (OP_LONG); ;
1334 break;}
1335case 71:
1336#line 528 "m2-exp.y"
1337{ write_exp_elt_opcode (OP_M2_STRING);
1338 write_exp_string (yyvsp[0].sval);
1339 write_exp_elt_opcode (OP_M2_STRING); ;
1340 break;}
1341case 72:
1342#line 535 "m2-exp.y"
1343{ yyval.bval = SYMBOL_BLOCK_VALUE(yyvsp[0].sym); ;
1344 break;}
1345case 73:
1346#line 539 "m2-exp.y"
1347{ struct symbol *sym
1348 = lookup_symbol (copy_name (yyvsp[0].sval), expression_context_block,
1349 VAR_NAMESPACE, 0, NULL);
1350 yyval.sym = sym;;
1351 break;}
1352case 74:
1353#line 548 "m2-exp.y"
1354{ struct symbol *tem
1355 = lookup_symbol (copy_name (yyvsp[0].sval), yyvsp[-2].bval,
1356 VAR_NAMESPACE, 0, NULL);
1357 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
1358 error ("No function \"%s\" in specified context.",
1359 copy_name (yyvsp[0].sval));
1360 yyval.sym = tem;
1361 ;
1362 break;}
1363case 75:
1364#line 560 "m2-exp.y"
1365{ write_exp_elt_opcode(OP_VAR_VALUE);
1366 write_exp_elt_block (NULL);
1367 write_exp_elt_sym (yyvsp[0].sym);
1368 write_exp_elt_opcode (OP_VAR_VALUE); ;
1369 break;}
1370case 77:
1371#line 572 "m2-exp.y"
1372{ struct symbol *sym;
1373 sym = lookup_symbol (copy_name (yyvsp[0].sval), yyvsp[-2].bval,
1374 VAR_NAMESPACE, 0, NULL);
1375 if (sym == 0)
1376 error ("No symbol \"%s\" in specified context.",
1377 copy_name (yyvsp[0].sval));
1378
1379 write_exp_elt_opcode (OP_VAR_VALUE);
1380 /* block_found is set by lookup_symbol. */
1381 write_exp_elt_block (block_found);
1382 write_exp_elt_sym (sym);
1383 write_exp_elt_opcode (OP_VAR_VALUE); ;
1384 break;}
1385case 78:
1386#line 588 "m2-exp.y"
1387{ struct symbol *sym;
1388 int is_a_field_of_this;
1389
1390 sym = lookup_symbol (copy_name (yyvsp[0].sval),
1391 expression_context_block,
1392 VAR_NAMESPACE,
1393 &is_a_field_of_this,
1394 NULL);
1395 if (sym)
1396 {
1397 if (symbol_read_needs_frame (sym))
1398 {
1399 if (innermost_block == 0 ||
1400 contained_in (block_found,
1401 innermost_block))
1402 innermost_block = block_found;
1403 }
1404
1405 write_exp_elt_opcode (OP_VAR_VALUE);
1406 /* We want to use the selected frame, not
1407 another more inner frame which happens to
1408 be in the same block. */
1409 write_exp_elt_block (NULL);
1410 write_exp_elt_sym (sym);
1411 write_exp_elt_opcode (OP_VAR_VALUE);
1412 }
1413 else
1414 {
1415 struct minimal_symbol *msymbol;
1416 register char *arg = copy_name (yyvsp[0].sval);
1417
1418 msymbol =
1419 lookup_minimal_symbol (arg, NULL, NULL);
1420 if (msymbol != NULL)
1421 {
1422 write_exp_msymbol
1423 (msymbol,
1424 lookup_function_type (builtin_type_int),
1425 builtin_type_int);
1426 }
1427 else if (!have_full_symbols () && !have_partial_symbols ())
1428 error ("No symbol table is loaded. Use the \"symbol-file\" command.");
1429 else
1430 error ("No symbol \"%s\" in current context.",
1431 copy_name (yyvsp[0].sval));
1432 }
1433 ;
1434 break;}
1435case 79:
1436#line 639 "m2-exp.y"
1437{ yyval.tval = lookup_typename (copy_name (yyvsp[0].sval),
1438 expression_context_block, 0); ;
1439 break;}
1440}
1441 /* the action file gets copied in in place of this dollarsign */
1442#line 498 "/stone/jimb/main-98r2/share/bison.simple"
1443\f
1444 yyvsp -= yylen;
1445 yyssp -= yylen;
1446#ifdef YYLSP_NEEDED
1447 yylsp -= yylen;
1448#endif
1449
1450#if YYDEBUG != 0
1451 if (yydebug)
1452 {
1453 short *ssp1 = yyss - 1;
1454 fprintf (stderr, "state stack now");
1455 while (ssp1 != yyssp)
1456 fprintf (stderr, " %d", *++ssp1);
1457 fprintf (stderr, "\n");
1458 }
1459#endif
1460
1461 *++yyvsp = yyval;
1462
1463#ifdef YYLSP_NEEDED
1464 yylsp++;
1465 if (yylen == 0)
1466 {
1467 yylsp->first_line = yylloc.first_line;
1468 yylsp->first_column = yylloc.first_column;
1469 yylsp->last_line = (yylsp-1)->last_line;
1470 yylsp->last_column = (yylsp-1)->last_column;
1471 yylsp->text = 0;
1472 }
1473 else
1474 {
1475 yylsp->last_line = (yylsp+yylen-1)->last_line;
1476 yylsp->last_column = (yylsp+yylen-1)->last_column;
1477 }
1478#endif
1479
1480 /* Now "shift" the result of the reduction.
1481 Determine what state that goes to,
1482 based on the state we popped back to
1483 and the rule number reduced by. */
1484
1485 yyn = yyr1[yyn];
1486
1487 yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
1488 if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1489 yystate = yytable[yystate];
1490 else
1491 yystate = yydefgoto[yyn - YYNTBASE];
1492
1493 goto yynewstate;
1494
1495yyerrlab: /* here on detecting error */
1496
1497 if (! yyerrstatus)
1498 /* If not already recovering from an error, report this error. */
1499 {
1500 ++yynerrs;
1501
1502#ifdef YYERROR_VERBOSE
1503 yyn = yypact[yystate];
1504
1505 if (yyn > YYFLAG && yyn < YYLAST)
1506 {
1507 int size = 0;
1508 char *msg;
1509 int x, count;
1510
1511 count = 0;
1512 /* Start X at -yyn if nec to avoid negative indexes in yycheck. */
1513 for (x = (yyn < 0 ? -yyn : 0);
1514 x < (sizeof(yytname) / sizeof(char *)); x++)
1515 if (yycheck[x + yyn] == x)
1516 size += strlen(yytname[x]) + 15, count++;
1517 msg = (char *) xmalloc(size + 15);
1518 if (msg != 0)
1519 {
1520 strcpy(msg, "parse error");
1521
1522 if (count < 5)
1523 {
1524 count = 0;
1525 for (x = (yyn < 0 ? -yyn : 0);
1526 x < (sizeof(yytname) / sizeof(char *)); x++)
1527 if (yycheck[x + yyn] == x)
1528 {
1529 strcat(msg, count == 0 ? ", expecting `" : " or `");
1530 strcat(msg, yytname[x]);
1531 strcat(msg, "'");
1532 count++;
1533 }
1534 }
1535 yyerror(msg);
1536 free(msg);
1537 }
1538 else
1539 yyerror ("parse error; also virtual memory exceeded");
1540 }
1541 else
1542#endif /* YYERROR_VERBOSE */
1543 yyerror("parse error");
1544 }
1545
1546 goto yyerrlab1;
1547yyerrlab1: /* here on error raised explicitly by an action */
1548
1549 if (yyerrstatus == 3)
1550 {
1551 /* if just tried and failed to reuse lookahead token after an error, discard it. */
1552
1553 /* return failure if at end of input */
1554 if (yychar == YYEOF)
1555 YYABORT;
1556
1557#if YYDEBUG != 0
1558 if (yydebug)
1559 fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
1560#endif
1561
1562 yychar = YYEMPTY;
1563 }
1564
1565 /* Else will try to reuse lookahead token
1566 after shifting the error token. */
1567
1568 yyerrstatus = 3; /* Each real token shifted decrements this */
1569
1570 goto yyerrhandle;
1571
1572yyerrdefault: /* current state does not do anything special for the error token. */
1573
1574#if 0
1575 /* This is wrong; only states that explicitly want error tokens
1576 should shift them. */
1577 yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
1578 if (yyn) goto yydefault;
1579#endif
1580
1581yyerrpop: /* pop the current state because it cannot handle the error token */
1582
1583 if (yyssp == yyss) YYABORT;
1584 yyvsp--;
1585 yystate = *--yyssp;
1586#ifdef YYLSP_NEEDED
1587 yylsp--;
1588#endif
1589
1590#if YYDEBUG != 0
1591 if (yydebug)
1592 {
1593 short *ssp1 = yyss - 1;
1594 fprintf (stderr, "Error: state stack now");
1595 while (ssp1 != yyssp)
1596 fprintf (stderr, " %d", *++ssp1);
1597 fprintf (stderr, "\n");
1598 }
1599#endif
1600
1601yyerrhandle:
1602
1603 yyn = yypact[yystate];
1604 if (yyn == YYFLAG)
1605 goto yyerrdefault;
1606
1607 yyn += YYTERROR;
1608 if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
1609 goto yyerrdefault;
1610
1611 yyn = yytable[yyn];
1612 if (yyn < 0)
1613 {
1614 if (yyn == YYFLAG)
1615 goto yyerrpop;
1616 yyn = -yyn;
1617 goto yyreduce;
1618 }
1619 else if (yyn == 0)
1620 goto yyerrpop;
1621
1622 if (yyn == YYFINAL)
1623 YYACCEPT;
1624
1625#if YYDEBUG != 0
1626 if (yydebug)
1627 fprintf(stderr, "Shifting error token, ");
1628#endif
1629
1630 *++yyvsp = yylval;
1631#ifdef YYLSP_NEEDED
1632 *++yylsp = yylloc;
1633#endif
1634
1635 yystate = yyn;
1636 goto yynewstate;
1637}
1638#line 644 "m2-exp.y"
1639
1640
1641#if 0 /* FIXME! */
1642int
1643overflow(a,b)
1644 long a,b;
1645{
1646 return (MAX_OF_TYPE(builtin_type_m2_int) - b) < a;
1647}
1648
1649int
1650uoverflow(a,b)
1651 unsigned long a,b;
1652{
1653 return (MAX_OF_TYPE(builtin_type_m2_card) - b) < a;
1654}
1655#endif /* FIXME */
1656
1657/* Take care of parsing a number (anything that starts with a digit).
1658 Set yylval and return the token type; update lexptr.
1659 LEN is the number of characters in it. */
1660
1661/*** Needs some error checking for the float case ***/
1662
1663static int
1664parse_number (olen)
1665 int olen;
1666{
1667 register char *p = lexptr;
1668 register LONGEST n = 0;
1669 register LONGEST prevn = 0;
1670 register int c,i,ischar=0;
1671 register int base = input_radix;
1672 register int len = olen;
1673 int unsigned_p = number_sign == 1 ? 1 : 0;
1674
1675 if(p[len-1] == 'H')
1676 {
1677 base = 16;
1678 len--;
1679 }
1680 else if(p[len-1] == 'C' || p[len-1] == 'B')
1681 {
1682 base = 8;
1683 ischar = p[len-1] == 'C';
1684 len--;
1685 }
1686
1687 /* Scan the number */
1688 for (c = 0; c < len; c++)
1689 {
1690 if (p[c] == '.' && base == 10)
1691 {
1692 /* It's a float since it contains a point. */
1693 yylval.dval = atof (p);
1694 lexptr += len;
1695 return FLOAT;
1696 }
1697 if (p[c] == '.' && base != 10)
1698 error("Floating point numbers must be base 10.");
1699 if (base == 10 && (p[c] < '0' || p[c] > '9'))
1700 error("Invalid digit \'%c\' in number.",p[c]);
1701 }
1702
1703 while (len-- > 0)
1704 {
1705 c = *p++;
1706 n *= base;
1707 if( base == 8 && (c == '8' || c == '9'))
1708 error("Invalid digit \'%c\' in octal number.",c);
1709 if (c >= '0' && c <= '9')
1710 i = c - '0';
1711 else
1712 {
1713 if (base == 16 && c >= 'A' && c <= 'F')
1714 i = c - 'A' + 10;
1715 else
1716 return ERROR;
1717 }
1718 n+=i;
1719 if(i >= base)
1720 return ERROR;
1721 if(!unsigned_p && number_sign == 1 && (prevn >= n))
1722 unsigned_p=1; /* Try something unsigned */
1723 /* Don't do the range check if n==i and i==0, since that special
1724 case will give an overflow error. */
1725 if(RANGE_CHECK && n!=i && i)
1726 {
1727 if((unsigned_p && (unsigned)prevn >= (unsigned)n) ||
1728 ((!unsigned_p && number_sign==-1) && -prevn <= -n))
1729 range_error("Overflow on numeric constant.");
1730 }
1731 prevn=n;
1732 }
1733
1734 lexptr = p;
1735 if(*p == 'B' || *p == 'C' || *p == 'H')
1736 lexptr++; /* Advance past B,C or H */
1737
1738 if (ischar)
1739 {
1740 yylval.ulval = n;
1741 return CHAR;
1742 }
1743 else if ( unsigned_p && number_sign == 1)
1744 {
1745 yylval.ulval = n;
1746 return UINT;
1747 }
1748 else if((unsigned_p && (n<0))) {
1749 range_error("Overflow on numeric constant -- number too large.");
1750 /* But, this can return if range_check == range_warn. */
1751 }
1752 yylval.lval = n;
1753 return INT;
1754}
1755
1756
1757/* Some tokens */
1758
1759static struct
1760{
1761 char name[2];
1762 int token;
1763} tokentab2[] =
1764{
1765 { {'<', '>'}, NOTEQUAL },
1766 { {':', '='}, ASSIGN },
1767 { {'<', '='}, LEQ },
1768 { {'>', '='}, GEQ },
1769 { {':', ':'}, COLONCOLON },
1770
1771};
1772
1773/* Some specific keywords */
1774
1775struct keyword {
1776 char keyw[10];
1777 int token;
1778};
1779
1780static struct keyword keytab[] =
1781{
1782 {"OR" , OROR },
1783 {"IN", IN },/* Note space after IN */
1784 {"AND", LOGICAL_AND},
1785 {"ABS", ABS },
1786 {"CHR", CHR },
1787 {"DEC", DEC },
1788 {"NOT", NOT },
1789 {"DIV", DIV },
1790 {"INC", INC },
1791 {"MAX", MAX_FUNC },
1792 {"MIN", MIN_FUNC },
1793 {"MOD", MOD },
1794 {"ODD", ODD },
1795 {"CAP", CAP },
1796 {"ORD", ORD },
1797 {"VAL", VAL },
1798 {"EXCL", EXCL },
1799 {"HIGH", HIGH },
1800 {"INCL", INCL },
1801 {"SIZE", SIZE },
1802 {"FLOAT", FLOAT_FUNC },
1803 {"TRUNC", TRUNC },
1804};
1805
1806
1807/* Read one token, getting characters through lexptr. */
1808
1809/* This is where we will check to make sure that the language and the operators used are
1810 compatible */
1811
1812static int
1813yylex ()
1814{
1815 register int c;
1816 register int namelen;
1817 register int i;
1818 register char *tokstart;
1819 register char quote;
1820
1821 retry:
1822
1823 tokstart = lexptr;
1824
1825
1826 /* See if it is a special token of length 2 */
1827 for( i = 0 ; i < (int) (sizeof tokentab2 / sizeof tokentab2[0]) ; i++)
1828 if(STREQN(tokentab2[i].name, tokstart, 2))
1829 {
1830 lexptr += 2;
1831 return tokentab2[i].token;
1832 }
1833
1834 switch (c = *tokstart)
1835 {
1836 case 0:
1837 return 0;
1838
1839 case ' ':
1840 case '\t':
1841 case '\n':
1842 lexptr++;
1843 goto retry;
1844
1845 case '(':
1846 paren_depth++;
1847 lexptr++;
1848 return c;
1849
1850 case ')':
1851 if (paren_depth == 0)
1852 return 0;
1853 paren_depth--;
1854 lexptr++;
1855 return c;
1856
1857 case ',':
1858 if (comma_terminates && paren_depth == 0)
1859 return 0;
1860 lexptr++;
1861 return c;
1862
1863 case '.':
1864 /* Might be a floating point number. */
1865 if (lexptr[1] >= '0' && lexptr[1] <= '9')
1866 break; /* Falls into number code. */
1867 else
1868 {
1869 lexptr++;
1870 return DOT;
1871 }
1872
1873/* These are character tokens that appear as-is in the YACC grammar */
1874 case '+':
1875 case '-':
1876 case '*':
1877 case '/':
1878 case '^':
1879 case '<':
1880 case '>':
1881 case '[':
1882 case ']':
1883 case '=':
1884 case '{':
1885 case '}':
1886 case '#':
1887 case '@':
1888 case '~':
1889 case '&':
1890 lexptr++;
1891 return c;
1892
1893 case '\'' :
1894 case '"':
1895 quote = c;
1896 for (namelen = 1; (c = tokstart[namelen]) != quote && c != '\0'; namelen++)
1897 if (c == '\\')
1898 {
1899 c = tokstart[++namelen];
1900 if (c >= '0' && c <= '9')
1901 {
1902 c = tokstart[++namelen];
1903 if (c >= '0' && c <= '9')
1904 c = tokstart[++namelen];
1905 }
1906 }
1907 if(c != quote)
1908 error("Unterminated string or character constant.");
1909 yylval.sval.ptr = tokstart + 1;
1910 yylval.sval.length = namelen - 1;
1911 lexptr += namelen + 1;
1912
1913 if(namelen == 2) /* Single character */
1914 {
1915 yylval.ulval = tokstart[1];
1916 return CHAR;
1917 }
1918 else
1919 return STRING;
1920 }
1921
1922 /* Is it a number? */
1923 /* Note: We have already dealt with the case of the token '.'.
1924 See case '.' above. */
1925 if ((c >= '0' && c <= '9'))
1926 {
1927 /* It's a number. */
1928 int got_dot = 0, got_e = 0;
1929 register char *p = tokstart;
1930 int toktype;
1931
1932 for (++p ;; ++p)
1933 {
1934 if (!got_e && (*p == 'e' || *p == 'E'))
1935 got_dot = got_e = 1;
1936 else if (!got_dot && *p == '.')
1937 got_dot = 1;
1938 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1939 && (*p == '-' || *p == '+'))
1940 /* This is the sign of the exponent, not the end of the
1941 number. */
1942 continue;
1943 else if ((*p < '0' || *p > '9') &&
1944 (*p < 'A' || *p > 'F') &&
1945 (*p != 'H')) /* Modula-2 hexadecimal number */
1946 break;
1947 }
1948 toktype = parse_number (p - tokstart);
1949 if (toktype == ERROR)
1950 {
1951 char *err_copy = (char *) alloca (p - tokstart + 1);
1952
1953 memcpy (err_copy, tokstart, p - tokstart);
1954 err_copy[p - tokstart] = 0;
1955 error ("Invalid number \"%s\".", err_copy);
1956 }
1957 lexptr = p;
1958 return toktype;
1959 }
1960
1961 if (!(c == '_' || c == '$'
1962 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1963 /* We must have come across a bad character (e.g. ';'). */
1964 error ("Invalid character '%c' in expression.", c);
1965
1966 /* It's a name. See how long it is. */
1967 namelen = 0;
1968 for (c = tokstart[namelen];
1969 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1970 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
1971 c = tokstart[++namelen])
1972 ;
1973
1974 /* The token "if" terminates the expression and is NOT
1975 removed from the input stream. */
1976 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1977 {
1978 return 0;
1979 }
1980
1981 lexptr += namelen;
1982
1983 /* Lookup special keywords */
1984 for(i = 0 ; i < (int) (sizeof(keytab) / sizeof(keytab[0])) ; i++)
1985 if(namelen == strlen(keytab[i].keyw) && STREQN(tokstart,keytab[i].keyw,namelen))
1986 return keytab[i].token;
1987
1988 yylval.sval.ptr = tokstart;
1989 yylval.sval.length = namelen;
1990
1991 if (*tokstart == '$')
1992 {
1993 write_dollar_variable (yylval.sval);
1994 return INTERNAL_VAR;
1995 }
1996
1997 /* Use token-type BLOCKNAME for symbols that happen to be defined as
1998 functions. If this is not so, then ...
1999 Use token-type TYPENAME for symbols that happen to be defined
2000 currently as names of types; NAME for other symbols.
2001 The caller is not constrained to care about the distinction. */
2002 {
2003
2004
2005 char *tmp = copy_name (yylval.sval);
2006 struct symbol *sym;
2007
2008 if (lookup_partial_symtab (tmp))
2009 return BLOCKNAME;
2010 sym = lookup_symbol (tmp, expression_context_block,
2011 VAR_NAMESPACE, 0, NULL);
2012 if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
2013 return BLOCKNAME;
2014 if (lookup_typename (copy_name (yylval.sval), expression_context_block, 1))
2015 return TYPENAME;
2016
2017 if(sym)
2018 {
2019 switch(sym->aclass)
2020 {
2021 case LOC_STATIC:
2022 case LOC_REGISTER:
2023 case LOC_ARG:
2024 case LOC_REF_ARG:
2025 case LOC_REGPARM:
2026 case LOC_REGPARM_ADDR:
2027 case LOC_LOCAL:
2028 case LOC_LOCAL_ARG:
2029 case LOC_BASEREG:
2030 case LOC_BASEREG_ARG:
2031 case LOC_CONST:
2032 case LOC_CONST_BYTES:
2033 case LOC_OPTIMIZED_OUT:
2034 return NAME;
2035
2036 case LOC_TYPEDEF:
2037 return TYPENAME;
2038
2039 case LOC_BLOCK:
2040 return BLOCKNAME;
2041
2042 case LOC_UNDEF:
2043 error("internal: Undefined class in m2lex()");
2044
2045 case LOC_LABEL:
2046 case LOC_UNRESOLVED:
2047 error("internal: Unforseen case in m2lex()");
2048 }
2049 }
2050 else
2051 {
2052 /* Built-in BOOLEAN type. This is sort of a hack. */
2053 if(STREQN(tokstart,"TRUE",4))
2054 {
2055 yylval.ulval = 1;
2056 return M2_TRUE;
2057 }
2058 else if(STREQN(tokstart,"FALSE",5))
2059 {
2060 yylval.ulval = 0;
2061 return M2_FALSE;
2062 }
2063 }
2064
2065 /* Must be another type of name... */
2066 return NAME;
2067 }
2068}
2069
2070#if 0 /* Unused */
2071static char *
2072make_qualname(mod,ident)
2073 char *mod, *ident;
2074{
2075 char *new = xmalloc(strlen(mod)+strlen(ident)+2);
2076
2077 strcpy(new,mod);
2078 strcat(new,".");
2079 strcat(new,ident);
2080 return new;
2081}
2082#endif /* 0 */
2083
2084void
2085yyerror (msg)
2086 char *msg;
2087{
2088 error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);
2089}
GDB Binutils - Deliverables
This page took 0.114104 seconds and 4 git commands to generate.