?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel - cleanup vfs_cache debugging
[dragonfly.git] / contrib / gdb-7 / gdb / go-exp.c
blobf76dea66c364630d25e12f5b8c4e19eca7538dec
1
2 /* A Bison parser, made by GNU Bison 2.4.1. */
3
4 /* Skeleton implementation for Bison's Yacc-like parsers in C
5
6 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
7 Free Software Foundation, Inc.
8
9 This program is free software: you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation, either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21
22 /* As a special exception, you may create a larger work that contains
23 part or all of the Bison parser skeleton and distribute that work
24 under terms of your choice, so long as that work isn't itself a
25 parser generator using the skeleton or a modified version thereof
26 as a parser skeleton. Alternatively, if you modify or redistribute
27 the parser skeleton itself, you may (at your option) remove this
28 special exception, which will cause the skeleton and the resulting
29 Bison output files to be licensed under the GNU General Public
30 License without this special exception.
31
32 This special exception was added by the Free Software Foundation in
33 version 2.2 of Bison. */
34
35 /* C LALR(1) parser skeleton written by Richard Stallman, by
36 simplifying the original so-called "semantic" parser. */
37
38 /* All symbols defined below should begin with yy or YY, to avoid
39 infringing on user name space. This should be done even for local
40 variables, as they might otherwise be expanded by user macros.
41 There are some unavoidable exceptions within include files to
42 define necessary library symbols; they are noted "INFRINGES ON
43 USER NAME SPACE" below. */
44
45 /* Identify Bison output. */
46 #define YYBISON 1
47
48 /* Bison version. */
49 #define YYBISON_VERSION "2.4.1"
50
51 /* Skeleton name. */
52 #define YYSKELETON_NAME "yacc.c"
53
54 /* Pure parsers. */
55 #define YYPURE 0
56
57 /* Push parsers. */
58 #define YYPUSH 0
59
60 /* Pull parsers. */
61 #define YYPULL 1
62
63 /* Using locations. */
64 #define YYLSP_NEEDED 0
65
66
67
68 /* Copy the first part of user declarations. */
69
70 /* Line 189 of yacc.c */
71 #line 52 "go-exp.y"
72
73
74 #include "defs.h"
75 #include "gdb_string.h"
76 #include <ctype.h>
77 #include "expression.h"
78 #include "value.h"
79 #include "parser-defs.h"
80 #include "language.h"
81 #include "c-lang.h"
82 #include "go-lang.h"
83 #include "bfd.h" /* Required by objfiles.h. */
84 #include "symfile.h" /* Required by objfiles.h. */
85 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
86 #include "charset.h"
87 #include "block.h"
88
89 #define parse_type builtin_type (parse_gdbarch)
90
91 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
92 as well as gratuitiously global symbol names, so we can have multiple
93 yacc generated parsers in gdb. Note that these are only the variables
94 produced by yacc. If other parser generators (bison, byacc, etc) produce
95 additional global names that conflict at link time, then those parser
96 generators need to be fixed instead of adding those names to this list. */
97
98 #define yymaxdepth go_maxdepth
99 #define yyparse go_parse_internal
100 #define yylex go_lex
101 #define yyerror go_error
102 #define yylval go_lval
103 #define yychar go_char
104 #define yydebug go_debug
105 #define yypact go_pact
106 #define yyr1 go_r1
107 #define yyr2 go_r2
108 #define yydef go_def
109 #define yychk go_chk
110 #define yypgo go_pgo
111 #define yyact go_act
112 #define yyexca go_exca
113 #define yyerrflag go_errflag
114 #define yynerrs go_nerrs
115 #define yyps go_ps
116 #define yypv go_pv
117 #define yys go_s
118 #define yy_yys go_yys
119 #define yystate go_state
120 #define yytmp go_tmp
121 #define yyv go_v
122 #define yy_yyv go_yyv
123 #define yyval go_val
124 #define yylloc go_lloc
125 #define yyreds go_reds /* With YYDEBUG defined */
126 #define yytoks go_toks /* With YYDEBUG defined */
127 #define yyname go_name /* With YYDEBUG defined */
128 #define yyrule go_rule /* With YYDEBUG defined */
129 #define yylhs go_yylhs
130 #define yylen go_yylen
131 #define yydefred go_yydefred
132 #define yydgoto go_yydgoto
133 #define yysindex go_yysindex
134 #define yyrindex go_yyrindex
135 #define yygindex go_yygindex
136 #define yytable go_yytable
137 #define yycheck go_yycheck
138
139 #ifndef YYDEBUG
140 #define YYDEBUG 1 /* Default to yydebug support */
141 #endif
142
143 #define YYFPRINTF parser_fprintf
144
145 int yyparse (void);
146
147 static int yylex (void);
148
149 void yyerror (char *);
150
151
152
153 /* Line 189 of yacc.c */
154 #line 155 "go-exp.c"
155
156 /* Enabling traces. */
157 #ifndef YYDEBUG
158 # define YYDEBUG 0
159 #endif
160
161 /* Enabling verbose error messages. */
162 #ifdef YYERROR_VERBOSE
163 # undef YYERROR_VERBOSE
164 # define YYERROR_VERBOSE 1
165 #else
166 # define YYERROR_VERBOSE 0
167 #endif
168
169 /* Enabling the token table. */
170 #ifndef YYTOKEN_TABLE
171 # define YYTOKEN_TABLE 0
172 #endif
173
174
175 /* Tokens. */
176 #ifndef YYTOKENTYPE
177 # define YYTOKENTYPE
178 /* Put the tokens into the symbol table, so that GDB and other debuggers
179 know about them. */
180 enum yytokentype {
181 INT = 258,
182 FLOAT = 259,
183 RAW_STRING = 260,
184 STRING = 261,
185 CHAR = 262,
186 NAME = 263,
187 TYPENAME = 264,
188 COMPLETE = 265,
189 NAME_OR_INT = 266,
190 TRUE_KEYWORD = 267,
191 FALSE_KEYWORD = 268,
192 STRUCT_KEYWORD = 269,
193 INTERFACE_KEYWORD = 270,
194 TYPE_KEYWORD = 271,
195 CHAN_KEYWORD = 272,
196 SIZEOF_KEYWORD = 273,
197 LEN_KEYWORD = 274,
198 CAP_KEYWORD = 275,
199 NEW_KEYWORD = 276,
200 IOTA_KEYWORD = 277,
201 NIL_KEYWORD = 278,
202 CONST_KEYWORD = 279,
203 DOTDOTDOT = 280,
204 ENTRY = 281,
205 ERROR = 282,
206 BYTE_KEYWORD = 283,
207 DOLLAR_VARIABLE = 284,
208 ASSIGN_MODIFY = 285,
209 ABOVE_COMMA = 286,
210 OROR = 287,
211 ANDAND = 288,
212 ANDNOT = 289,
213 NOTEQUAL = 290,
214 EQUAL = 291,
215 GEQ = 292,
216 LEQ = 293,
217 RSH = 294,
218 LSH = 295,
219 DECREMENT = 296,
220 INCREMENT = 297,
221 UNARY = 298,
222 LEFT_ARROW = 299
223 };
224 #endif
225 /* Tokens. */
226 #define INT 258
227 #define FLOAT 259
228 #define RAW_STRING 260
229 #define STRING 261
230 #define CHAR 262
231 #define NAME 263
232 #define TYPENAME 264
233 #define COMPLETE 265
234 #define NAME_OR_INT 266
235 #define TRUE_KEYWORD 267
236 #define FALSE_KEYWORD 268
237 #define STRUCT_KEYWORD 269
238 #define INTERFACE_KEYWORD 270
239 #define TYPE_KEYWORD 271
240 #define CHAN_KEYWORD 272
241 #define SIZEOF_KEYWORD 273
242 #define LEN_KEYWORD 274
243 #define CAP_KEYWORD 275
244 #define NEW_KEYWORD 276
245 #define IOTA_KEYWORD 277
246 #define NIL_KEYWORD 278
247 #define CONST_KEYWORD 279
248 #define DOTDOTDOT 280
249 #define ENTRY 281
250 #define ERROR 282
251 #define BYTE_KEYWORD 283
252 #define DOLLAR_VARIABLE 284
253 #define ASSIGN_MODIFY 285
254 #define ABOVE_COMMA 286
255 #define OROR 287
256 #define ANDAND 288
257 #define ANDNOT 289
258 #define NOTEQUAL 290
259 #define EQUAL 291
260 #define GEQ 292
261 #define LEQ 293
262 #define RSH 294
263 #define LSH 295
264 #define DECREMENT 296
265 #define INCREMENT 297
266 #define UNARY 298
267 #define LEFT_ARROW 299
268
269
270
271
272 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
273 typedef union YYSTYPE
274 {
275
276 /* Line 214 of yacc.c */
277 #line 138 "go-exp.y"
278
279 LONGEST lval;
280 struct {
281 LONGEST val;
282 struct type *type;
283 } typed_val_int;
284 struct {
285 DOUBLEST dval;
286 struct type *type;
287 } typed_val_float;
288 struct stoken sval;
289 struct symtoken ssym;
290 struct type *tval;
291 struct typed_stoken tsval;
292 struct ttype tsym;
293 int voidval;
294 enum exp_opcode opcode;
295 struct internalvar *ivar;
296 struct stoken_vector svec;
297
298
299
300 /* Line 214 of yacc.c */
301 #line 302 "go-exp.c"
302 } YYSTYPE;
303 # define YYSTYPE_IS_TRIVIAL 1
304 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
305 # define YYSTYPE_IS_DECLARED 1
306 #endif
307
308
309 /* Copy the second part of user declarations. */
310
311 /* Line 264 of yacc.c */
312 #line 159 "go-exp.y"
313
314 /* YYSTYPE gets defined by %union. */
315 static int parse_number (char *, int, int, YYSTYPE *);
316 static int parse_go_float (struct gdbarch *gdbarch, const char *p, int len,
317 DOUBLEST *d, struct type **t);
318
319
320 /* Line 264 of yacc.c */
321 #line 322 "go-exp.c"
322
323 #ifdef short
324 # undef short
325 #endif
326
327 #ifdef YYTYPE_UINT8
328 typedef YYTYPE_UINT8 yytype_uint8;
329 #else
330 typedef unsigned char yytype_uint8;
331 #endif
332
333 #ifdef YYTYPE_INT8
334 typedef YYTYPE_INT8 yytype_int8;
335 #elif (defined __STDC__ || defined __C99__FUNC__ \
336 || defined __cplusplus || defined _MSC_VER)
337 typedef signed char yytype_int8;
338 #else
339 typedef short int yytype_int8;
340 #endif
341
342 #ifdef YYTYPE_UINT16
343 typedef YYTYPE_UINT16 yytype_uint16;
344 #else
345 typedef unsigned short int yytype_uint16;
346 #endif
347
348 #ifdef YYTYPE_INT16
349 typedef YYTYPE_INT16 yytype_int16;
350 #else
351 typedef short int yytype_int16;
352 #endif
353
354 #ifndef YYSIZE_T
355 # ifdef __SIZE_TYPE__
356 # define YYSIZE_T __SIZE_TYPE__
357 # elif defined size_t
358 # define YYSIZE_T size_t
359 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
360 || defined __cplusplus || defined _MSC_VER)
361 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
362 # define YYSIZE_T size_t
363 # else
364 # define YYSIZE_T unsigned int
365 # endif
366 #endif
367
368 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
369
370 #ifndef YY_
371 # if YYENABLE_NLS
372 # if ENABLE_NLS
373 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
374 # define YY_(msgid) dgettext ("bison-runtime", msgid)
375 # endif
376 # endif
377 # ifndef YY_
378 # define YY_(msgid) msgid
379 # endif
380 #endif
381
382 /* Suppress unused-variable warnings by "using" E. */
383 #if ! defined lint || defined __GNUC__
384 # define YYUSE(e) ((void) (e))
385 #else
386 # define YYUSE(e) /* empty */
387 #endif
388
389 /* Identity function, used to suppress warnings about constant conditions. */
390 #ifndef lint
391 # define YYID(n) (n)
392 #else
393 #if (defined __STDC__ || defined __C99__FUNC__ \
394 || defined __cplusplus || defined _MSC_VER)
395 static int
396 YYID (int yyi)
397 #else
398 static int
399 YYID (yyi)
400 int yyi;
401 #endif
402 {
403 return yyi;
404 }
405 #endif
406
407 #if ! defined yyoverflow || YYERROR_VERBOSE
408
409 /* The parser invokes alloca or xmalloc; define the necessary symbols. */
410
411 # ifdef YYSTACK_USE_ALLOCA
412 # if YYSTACK_USE_ALLOCA
413 # ifdef __GNUC__
414 # define YYSTACK_ALLOC __builtin_alloca
415 # elif defined __BUILTIN_VA_ARG_INCR
416 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
417 # elif defined _AIX
418 # define YYSTACK_ALLOC __alloca
419 # elif defined _MSC_VER
420 # define alloca _alloca
421 # else
422 # define YYSTACK_ALLOC alloca
423 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
424 || defined __cplusplus || defined _MSC_VER)
425 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
426 # ifndef _STDLIB_H
427 # define _STDLIB_H 1
428 # endif
429 # endif
430 # endif
431 # endif
432 # endif
433
434 # ifdef YYSTACK_ALLOC
435 /* Pacify GCC's `empty if-body' warning. */
436 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
437 # ifndef YYSTACK_ALLOC_MAXIMUM
438 /* The OS might guarantee only one guard page at the bottom of the stack,
439 and a page size can be as small as 4096 bytes. So we cannot safely
440 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
441 to allow for a few compiler-allocated temporary stack slots. */
442 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
443 # endif
444 # else
445 # define YYSTACK_ALLOC YYMALLOC
446 # define YYSTACK_FREE YYFREE
447 # ifndef YYSTACK_ALLOC_MAXIMUM
448 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
449 # endif
450 # if (defined __cplusplus && ! defined _STDLIB_H \
451 && ! ((defined YYMALLOC || defined xmalloc) \
452 && (defined YYFREE || defined xfree)))
453 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
454 # ifndef _STDLIB_H
455 # define _STDLIB_H 1
456 # endif
457 # endif
458 # ifndef YYMALLOC
459 # define YYMALLOC xmalloc
460 # if ! defined xmalloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
461 || defined __cplusplus || defined _MSC_VER)
462 void *xmalloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
463 # endif
464 # endif
465 # ifndef YYFREE
466 # define YYFREE xfree
467 # if ! defined xfree && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
468 || defined __cplusplus || defined _MSC_VER)
469 void xfree (void *); /* INFRINGES ON USER NAME SPACE */
470 # endif
471 # endif
472 # endif
473 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
474
475
476 #if (! defined yyoverflow \
477 && (! defined __cplusplus \
478 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
479
480 /* A type that is properly aligned for any stack member. */
481 union yyalloc
482 {
483 yytype_int16 yyss_alloc;
484 YYSTYPE yyvs_alloc;
485 };
486
487 /* The size of the maximum gap between one aligned stack and the next. */
488 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
489
490 /* The size of an array large to enough to hold all stacks, each with
491 N elements. */
492 # define YYSTACK_BYTES(N) \
493 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
494 + YYSTACK_GAP_MAXIMUM)
495
496 /* Copy COUNT objects from FROM to TO. The source and destination do
497 not overlap. */
498 # ifndef YYCOPY
499 # if defined __GNUC__ && 1 < __GNUC__
500 # define YYCOPY(To, From, Count) \
501 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
502 # else
503 # define YYCOPY(To, From, Count) \
504 do \
505 { \
506 YYSIZE_T yyi; \
507 for (yyi = 0; yyi < (Count); yyi++) \
508 (To)[yyi] = (From)[yyi]; \
509 } \
510 while (YYID (0))
511 # endif
512 # endif
513
514 /* Relocate STACK from its old location to the new one. The
515 local variables YYSIZE and YYSTACKSIZE give the old and new number of
516 elements in the stack, and YYPTR gives the new location of the
517 stack. Advance YYPTR to a properly aligned location for the next
518 stack. */
519 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
520 do \
521 { \
522 YYSIZE_T yynewbytes; \
523 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
524 Stack = &yyptr->Stack_alloc; \
525 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
526 yyptr += yynewbytes / sizeof (*yyptr); \
527 } \
528 while (YYID (0))
529
530 #endif
531
532 /* YYFINAL -- State number of the termination state. */
533 #define YYFINAL 40
534 /* YYLAST -- Last index in YYTABLE. */
535 #define YYLAST 443
536
537 /* YYNTOKENS -- Number of terminals. */
538 #define YYNTOKENS 68
539 /* YYNNTS -- Number of nonterminals. */
540 #define YYNNTS 13
541 /* YYNRULES -- Number of rules. */
542 #define YYNRULES 69
543 /* YYNRULES -- Number of states. */
544 #define YYNSTATES 122
545
546 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
547 #define YYUNDEFTOK 2
548 #define YYMAXUTOK 299
549
550 #define YYTRANSLATE(YYX) \
551 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
552
553 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
554 static const yytype_uint8 yytranslate[] =
555 {
556 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
557 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
558 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
559 2, 2, 2, 62, 2, 2, 2, 54, 39, 2,
560 60, 64, 52, 50, 31, 51, 58, 53, 2, 2,
561 2, 2, 2, 2, 2, 2, 2, 2, 67, 2,
562 43, 33, 44, 34, 49, 2, 2, 2, 2, 2,
563 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
564 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
565 2, 59, 2, 63, 38, 2, 2, 2, 2, 2,
566 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
567 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
568 2, 2, 2, 65, 37, 66, 2, 2, 2, 2,
569 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
570 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
571 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
572 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
573 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
574 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
575 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
576 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
577 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
578 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
579 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
580 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
581 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
582 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
583 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
584 25, 26, 27, 28, 29, 30, 32, 35, 36, 40,
585 41, 42, 45, 46, 47, 48, 55, 56, 57, 61
586 };
587
588 #if YYDEBUG
589 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
590 YYRHS. */
591 static const yytype_uint8 yyprhs[] =
592 {
593 0, 0, 3, 5, 7, 9, 11, 15, 18, 21,
594 24, 27, 30, 33, 36, 39, 43, 48, 52, 57,
595 58, 64, 66, 67, 69, 73, 75, 80, 85, 89,
596 93, 97, 101, 105, 109, 113, 117, 121, 125, 129,
597 133, 137, 141, 145, 149, 153, 157, 161, 165, 171,
598 175, 179, 181, 183, 185, 187, 189, 191, 196, 201,
599 203, 207, 209, 211, 213, 216, 218, 221, 223, 225
600 };
601
602 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
603 static const yytype_int8 yyrhs[] =
604 {
605 69, 0, -1, 71, -1, 70, -1, 79, -1, 72,
606 -1, 71, 31, 72, -1, 52, 72, -1, 39, 72,
607 -1, 51, 72, -1, 50, 72, -1, 62, 72, -1,
608 38, 72, -1, 72, 56, -1, 72, 55, -1, 72,
609 58, 80, -1, 72, 58, 80, 10, -1, 72, 58,
610 10, -1, 72, 59, 71, 63, -1, -1, 72, 60,
611 73, 75, 64, -1, 65, -1, -1, 72, -1, 75,
612 31, 72, -1, 66, -1, 74, 79, 76, 72, -1,
613 79, 60, 72, 64, -1, 60, 71, 64, -1, 72,
614 49, 72, -1, 72, 52, 72, -1, 72, 53, 72,
615 -1, 72, 54, 72, -1, 72, 50, 72, -1, 72,
616 51, 72, -1, 72, 48, 72, -1, 72, 47, 72,
617 -1, 72, 42, 72, -1, 72, 41, 72, -1, 72,
618 46, 72, -1, 72, 45, 72, -1, 72, 43, 72,
619 -1, 72, 44, 72, -1, 72, 39, 72, -1, 72,
620 38, 72, -1, 72, 37, 72, -1, 72, 36, 72,
621 -1, 72, 35, 72, -1, 72, 34, 72, 67, 72,
622 -1, 72, 33, 72, -1, 72, 30, 72, -1, 3,
623 -1, 7, -1, 11, -1, 4, -1, 78, -1, 29,
624 -1, 18, 60, 79, 64, -1, 18, 60, 72, 64,
625 -1, 6, -1, 77, 50, 6, -1, 77, -1, 12,
626 -1, 13, -1, 80, 26, -1, 80, -1, 52, 79,
627 -1, 9, -1, 28, -1, 8, -1
628 };
629
630 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
631 static const yytype_uint16 yyrline[] =
632 {
633 0, 237, 237, 238, 241, 248, 249, 254, 258, 262,
634 266, 270, 274, 278, 282, 288, 294, 301, 311, 318,
635 315, 325, 329, 332, 336, 340, 344, 350, 356, 362,
636 366, 370, 374, 378, 382, 386, 390, 394, 398, 402,
637 406, 410, 414, 418, 422, 426, 430, 434, 438, 442,
638 446, 452, 459, 468, 481, 488, 491, 497, 509, 516,
639 533, 551, 562, 568, 574, 590, 645, 647, 654, 667
640 };
641 #endif
642
643 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
644 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
645 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
646 static const char *const yytname[] =
647 {
648 "$end", "error", "$undefined", "INT", "FLOAT", "RAW_STRING", "STRING",
649 "CHAR", "NAME", "TYPENAME", "COMPLETE", "NAME_OR_INT", "TRUE_KEYWORD",
650 "FALSE_KEYWORD", "STRUCT_KEYWORD", "INTERFACE_KEYWORD", "TYPE_KEYWORD",
651 "CHAN_KEYWORD", "SIZEOF_KEYWORD", "LEN_KEYWORD", "CAP_KEYWORD",
652 "NEW_KEYWORD", "IOTA_KEYWORD", "NIL_KEYWORD", "CONST_KEYWORD",
653 "DOTDOTDOT", "ENTRY", "ERROR", "BYTE_KEYWORD", "DOLLAR_VARIABLE",
654 "ASSIGN_MODIFY", "','", "ABOVE_COMMA", "'='", "'?'", "OROR", "ANDAND",
655 "'|'", "'^'", "'&'", "ANDNOT", "NOTEQUAL", "EQUAL", "'<'", "'>'", "GEQ",
656 "LEQ", "RSH", "LSH", "'@'", "'+'", "'-'", "'*'", "'/'", "'%'",
657 "DECREMENT", "INCREMENT", "UNARY", "'.'", "'['", "'('", "LEFT_ARROW",
658 "'!'", "']'", "')'", "'{'", "'}'", "':'", "$accept", "start", "type_exp",
659 "exp1", "exp", "$@1", "lcurly", "arglist", "rcurly", "string_exp",
660 "variable", "type", "name_not_typename", 0
661 };
662 #endif
663
664 # ifdef YYPRINT
665 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
666 token YYLEX-NUM. */
667 static const yytype_uint16 yytoknum[] =
668 {
669 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
670 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
671 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
672 285, 44, 286, 61, 63, 287, 288, 124, 94, 38,
673 289, 290, 291, 60, 62, 292, 293, 294, 295, 64,
674 43, 45, 42, 47, 37, 296, 297, 298, 46, 91,
675 40, 299, 33, 93, 41, 123, 125, 58
676 };
677 # endif
678
679 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
680 static const yytype_uint8 yyr1[] =
681 {
682 0, 68, 69, 69, 70, 71, 71, 72, 72, 72,
683 72, 72, 72, 72, 72, 72, 72, 72, 72, 73,
684 72, 74, 75, 75, 75, 76, 72, 72, 72, 72,
685 72, 72, 72, 72, 72, 72, 72, 72, 72, 72,
686 72, 72, 72, 72, 72, 72, 72, 72, 72, 72,
687 72, 72, 72, 72, 72, 72, 72, 72, 72, 77,
688 77, 72, 72, 72, 78, 78, 79, 79, 79, 80
689 };
690
691 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
692 static const yytype_uint8 yyr2[] =
693 {
694 0, 2, 1, 1, 1, 1, 3, 2, 2, 2,
695 2, 2, 2, 2, 2, 3, 4, 3, 4, 0,
696 5, 1, 0, 1, 3, 1, 4, 4, 3, 3,
697 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
698 3, 3, 3, 3, 3, 3, 3, 3, 5, 3,
699 3, 1, 1, 1, 1, 1, 1, 4, 4, 1,
700 3, 1, 1, 1, 2, 1, 2, 1, 1, 1
701 };
702
703 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
704 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
705 means the default is an error. */
706 static const yytype_uint8 yydefact[] =
707 {
708 0, 51, 54, 59, 52, 69, 67, 53, 62, 63,
709 0, 68, 56, 0, 0, 0, 0, 0, 0, 0,
710 21, 0, 3, 2, 5, 0, 61, 55, 4, 65,
711 0, 12, 0, 8, 10, 9, 7, 66, 0, 11,
712 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
713 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
714 0, 0, 0, 0, 14, 13, 0, 0, 19, 0,
715 0, 0, 0, 64, 0, 0, 28, 6, 50, 49,
716 0, 47, 46, 45, 44, 43, 38, 37, 41, 42,
717 40, 39, 36, 35, 29, 33, 34, 30, 31, 32,
718 17, 15, 0, 22, 66, 25, 0, 60, 0, 58,
719 57, 0, 16, 18, 23, 0, 26, 27, 48, 0,
720 20, 24
721 };
722
723 /* YYDEFGOTO[NTERM-NUM]. */
724 static const yytype_int8 yydefgoto[] =
725 {
726 -1, 21, 22, 23, 24, 103, 25, 115, 106, 26,
727 27, 32, 29
728 };
729
730 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
731 STATE-NUM. */
732 #define YYPACT_NINF -56
733 static const yytype_int16 yypact[] =
734 {
735 49, -56, -56, -56, -56, -56, -56, -56, -56, -56,
736 -44, -56, -56, 49, 49, 49, 49, 49, 49, 49,
737 -56, 23, -56, 34, 187, 45, -23, -56, 6, 46,
738 49, -48, 6, -48, -48, -48, -48, 6, 38, -48,
739 -56, 49, 49, 49, 49, 49, 49, 49, 49, 49,
740 49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
741 49, 49, 49, 49, -56, -56, 5, 49, -56, 45,
742 8, 65, 49, -56, 123, -55, -56, 187, 187, 187,
743 88, 239, 263, 286, 308, 328, 346, 346, 360, 360,
744 360, 360, 372, 372, 383, -34, -34, -48, -48, -48,
745 -56, 69, 33, 49, -56, -56, 49, -56, 155, -56,
746 -56, 49, -56, -56, 187, 39, -48, -56, 214, 49,
747 -56, 187
748 };
749
750 /* YYPGOTO[NTERM-NUM]. */
751 static const yytype_int8 yypgoto[] =
752 {
753 -56, -56, -56, -4, -13, -56, -56, -56, -56, -56,
754 -56, 51, 9
755 };
756
757 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
758 positive, shift that token. If negative, reduce the rule which
759 number is the opposite. If zero, do what YYDEFACT says.
760 If YYTABLE_NINF, syntax error. */
761 #define YYTABLE_NINF -1
762 static const yytype_uint8 yytable[] =
763 {
764 31, 33, 34, 35, 36, 72, 39, 64, 65, 110,
765 66, 67, 68, 5, 38, 100, 30, 74, 61, 62,
766 63, 64, 65, 40, 66, 67, 68, 71, 77, 78,
767 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
768 89, 90, 91, 92, 93, 94, 95, 96, 97, 98,
769 99, 28, 1, 2, 6, 3, 4, 5, 6, 108,
770 7, 8, 9, 102, 41, 41, 72, 10, 37, 41,
771 119, 107, 73, 11, 105, 101, 70, 11, 12, 112,
772 0, 75, 0, 0, 0, 0, 0, 13, 14, 0,
773 114, 0, 0, 116, 0, 0, 113, 69, 118, 15,
774 16, 17, 76, 120, 0, 0, 121, 0, 0, 18,
775 0, 19, 0, 0, 20, 0, 0, 0, 42, 0,
776 104, 43, 44, 45, 46, 47, 48, 49, 0, 50,
777 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
778 61, 62, 63, 64, 65, 0, 66, 67, 68, 0,
779 0, 0, 0, 42, 0, 111, 43, 44, 45, 46,
780 47, 48, 49, 0, 50, 51, 52, 53, 54, 55,
781 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
782 0, 66, 67, 68, 0, 42, 0, 109, 43, 44,
783 45, 46, 47, 48, 49, 0, 50, 51, 52, 53,
784 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
785 64, 65, 0, 66, 67, 68, 0, 42, 0, 117,
786 43, 44, 45, 46, 47, 48, 49, 0, 50, 51,
787 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
788 62, 63, 64, 65, 0, 66, 67, 68, 44, 45,
789 46, 47, 48, 49, 0, 50, 51, 52, 53, 54,
790 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
791 65, 0, 66, 67, 68, 46, 47, 48, 49, 0,
792 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
793 60, 61, 62, 63, 64, 65, 0, 66, 67, 68,
794 47, 48, 49, 0, 50, 51, 52, 53, 54, 55,
795 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
796 0, 66, 67, 68, 48, 49, 0, 50, 51, 52,
797 53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
798 63, 64, 65, 0, 66, 67, 68, 49, 0, 50,
799 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
800 61, 62, 63, 64, 65, 0, 66, 67, 68, 50,
801 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
802 61, 62, 63, 64, 65, 0, 66, 67, 68, 52,
803 53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
804 63, 64, 65, 0, 66, 67, 68, 56, 57, 58,
805 59, 60, 61, 62, 63, 64, 65, 0, 66, 67,
806 68, 58, 59, 60, 61, 62, 63, 64, 65, 0,
807 66, 67, 68, 59, 60, 61, 62, 63, 64, 65,
808 0, 66, 67, 68
809 };
810
811 static const yytype_int8 yycheck[] =
812 {
813 13, 14, 15, 16, 17, 60, 19, 55, 56, 64,
814 58, 59, 60, 8, 18, 10, 60, 30, 52, 53,
815 54, 55, 56, 0, 58, 59, 60, 50, 41, 42,
816 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
817 53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
818 63, 0, 3, 4, 9, 6, 7, 8, 9, 72,
819 11, 12, 13, 67, 31, 31, 60, 18, 17, 31,
820 31, 6, 26, 28, 66, 66, 25, 28, 29, 10,
821 -1, 30, -1, -1, -1, -1, -1, 38, 39, -1,
822 103, -1, -1, 106, -1, -1, 63, 52, 111, 50,
823 51, 52, 64, 64, -1, -1, 119, -1, -1, 60,
824 -1, 62, -1, -1, 65, -1, -1, -1, 30, -1,
825 69, 33, 34, 35, 36, 37, 38, 39, -1, 41,
826 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
827 52, 53, 54, 55, 56, -1, 58, 59, 60, -1,
828 -1, -1, -1, 30, -1, 67, 33, 34, 35, 36,
829 37, 38, 39, -1, 41, 42, 43, 44, 45, 46,
830 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
831 -1, 58, 59, 60, -1, 30, -1, 64, 33, 34,
832 35, 36, 37, 38, 39, -1, 41, 42, 43, 44,
833 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
834 55, 56, -1, 58, 59, 60, -1, 30, -1, 64,
835 33, 34, 35, 36, 37, 38, 39, -1, 41, 42,
836 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
837 53, 54, 55, 56, -1, 58, 59, 60, 34, 35,
838 36, 37, 38, 39, -1, 41, 42, 43, 44, 45,
839 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
840 56, -1, 58, 59, 60, 36, 37, 38, 39, -1,
841 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
842 51, 52, 53, 54, 55, 56, -1, 58, 59, 60,
843 37, 38, 39, -1, 41, 42, 43, 44, 45, 46,
844 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
845 -1, 58, 59, 60, 38, 39, -1, 41, 42, 43,
846 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
847 54, 55, 56, -1, 58, 59, 60, 39, -1, 41,
848 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
849 52, 53, 54, 55, 56, -1, 58, 59, 60, 41,
850 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
851 52, 53, 54, 55, 56, -1, 58, 59, 60, 43,
852 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
853 54, 55, 56, -1, 58, 59, 60, 47, 48, 49,
854 50, 51, 52, 53, 54, 55, 56, -1, 58, 59,
855 60, 49, 50, 51, 52, 53, 54, 55, 56, -1,
856 58, 59, 60, 50, 51, 52, 53, 54, 55, 56,
857 -1, 58, 59, 60
858 };
859
860 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
861 symbol of state STATE-NUM. */
862 static const yytype_uint8 yystos[] =
863 {
864 0, 3, 4, 6, 7, 8, 9, 11, 12, 13,
865 18, 28, 29, 38, 39, 50, 51, 52, 60, 62,
866 65, 69, 70, 71, 72, 74, 77, 78, 79, 80,
867 60, 72, 79, 72, 72, 72, 72, 79, 71, 72,
868 0, 31, 30, 33, 34, 35, 36, 37, 38, 39,
869 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
870 51, 52, 53, 54, 55, 56, 58, 59, 60, 52,
871 79, 50, 60, 26, 72, 79, 64, 72, 72, 72,
872 72, 72, 72, 72, 72, 72, 72, 72, 72, 72,
873 72, 72, 72, 72, 72, 72, 72, 72, 72, 72,
874 10, 80, 71, 73, 79, 66, 76, 6, 72, 64,
875 64, 67, 10, 63, 72, 75, 72, 64, 72, 31,
876 64, 72
877 };
878
879 #define yyerrok (yyerrstatus = 0)
880 #define yyclearin (yychar = YYEMPTY)
881 #define YYEMPTY (-2)
882 #define YYEOF 0
883
884 #define YYACCEPT goto yyacceptlab
885 #define YYABORT goto yyabortlab
886 #define YYERROR goto yyerrorlab
887
888
889 /* Like YYERROR except do call yyerror. This remains here temporarily
890 to ease the transition to the new meaning of YYERROR, for GCC.
891 Once GCC version 2 has supplanted version 1, this can go. */
892
893 #define YYFAIL goto yyerrlab
894
895 #define YYRECOVERING() (!!yyerrstatus)
896
897 #define YYBACKUP(Token, Value) \
898 do \
899 if (yychar == YYEMPTY && yylen == 1) \
900 { \
901 yychar = (Token); \
902 yylval = (Value); \
903 yytoken = YYTRANSLATE (yychar); \
904 YYPOPSTACK (1); \
905 goto yybackup; \
906 } \
907 else \
908 { \
909 yyerror (YY_("syntax error: cannot back up")); \
910 YYERROR; \
911 } \
912 while (YYID (0))
913
914
915 #define YYTERROR 1
916 #define YYERRCODE 256
917
918
919 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
920 If N is 0, then set CURRENT to the empty location which ends
921 the previous symbol: RHS[0] (always defined). */
922
923 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
924 #ifndef YYLLOC_DEFAULT
925 # define YYLLOC_DEFAULT(Current, Rhs, N) \
926 do \
927 if (YYID (N)) \
928 { \
929 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
930 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
931 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
932 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
933 } \
934 else \
935 { \
936 (Current).first_line = (Current).last_line = \
937 YYRHSLOC (Rhs, 0).last_line; \
938 (Current).first_column = (Current).last_column = \
939 YYRHSLOC (Rhs, 0).last_column; \
940 } \
941 while (YYID (0))
942 #endif
943
944
945 /* YY_LOCATION_PRINT -- Print the location on the stream.
946 This macro was not mandated originally: define only if we know
947 we won't break user code: when these are the locations we know. */
948
949 #ifndef YY_LOCATION_PRINT
950 # if YYLTYPE_IS_TRIVIAL
951 # define YY_LOCATION_PRINT(File, Loc) \
952 fprintf (File, "%d.%d-%d.%d", \
953 (Loc).first_line, (Loc).first_column, \
954 (Loc).last_line, (Loc).last_column)
955 # else
956 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
957 # endif
958 #endif
959
960
961 /* YYLEX -- calling `yylex' with the right arguments. */
962
963 #ifdef YYLEX_PARAM
964 # define YYLEX yylex (YYLEX_PARAM)
965 #else
966 # define YYLEX yylex ()
967 #endif
968
969 /* Enable debugging if requested. */
970 #if YYDEBUG
971
972 # ifndef YYFPRINTF
973 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
974 # define YYFPRINTF fprintf
975 # endif
976
977 # define YYDPRINTF(Args) \
978 do { \
979 if (yydebug) \
980 YYFPRINTF Args; \
981 } while (YYID (0))
982
983 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
984 do { \
985 if (yydebug) \
986 { \
987 YYFPRINTF (stderr, "%s ", Title); \
988 yy_symbol_print (stderr, \
989 Type, Value); \
990 YYFPRINTF (stderr, "\n"); \
991 } \
992 } while (YYID (0))
993
994
995 /*--------------------------------.
996 | Print this symbol on YYOUTPUT. |
997 `--------------------------------*/
998
999 /*ARGSUSED*/
1000 #if (defined __STDC__ || defined __C99__FUNC__ \
1001 || defined __cplusplus || defined _MSC_VER)
1002 static void
1003 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1004 #else
1005 static void
1006 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
1007 FILE *yyoutput;
1008 int yytype;
1009 YYSTYPE const * const yyvaluep;
1010 #endif
1011 {
1012 if (!yyvaluep)
1013 return;
1014 # ifdef YYPRINT
1015 if (yytype < YYNTOKENS)
1016 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1017 # else
1018 YYUSE (yyoutput);
1019 # endif
1020 switch (yytype)
1021 {
1022 default:
1023 break;
1024 }
1025 }
1026
1027
1028 /*--------------------------------.
1029 | Print this symbol on YYOUTPUT. |
1030 `--------------------------------*/
1031
1032 #if (defined __STDC__ || defined __C99__FUNC__ \
1033 || defined __cplusplus || defined _MSC_VER)
1034 static void
1035 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1036 #else
1037 static void
1038 yy_symbol_print (yyoutput, yytype, yyvaluep)
1039 FILE *yyoutput;
1040 int yytype;
1041 YYSTYPE const * const yyvaluep;
1042 #endif
1043 {
1044 if (yytype < YYNTOKENS)
1045 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1046 else
1047 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1048
1049 yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1050 YYFPRINTF (yyoutput, ")");
1051 }
1052
1053 /*------------------------------------------------------------------.
1054 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1055 | TOP (included). |
1056 `------------------------------------------------------------------*/
1057
1058 #if (defined __STDC__ || defined __C99__FUNC__ \
1059 || defined __cplusplus || defined _MSC_VER)
1060 static void
1061 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1062 #else
1063 static void
1064 yy_stack_print (yybottom, yytop)
1065 yytype_int16 *yybottom;
1066 yytype_int16 *yytop;
1067 #endif
1068 {
1069 YYFPRINTF (stderr, "Stack now");
1070 for (; yybottom <= yytop; yybottom++)
1071 {
1072 int yybot = *yybottom;
1073 YYFPRINTF (stderr, " %d", yybot);
1074 }
1075 YYFPRINTF (stderr, "\n");
1076 }
1077
1078 # define YY_STACK_PRINT(Bottom, Top) \
1079 do { \
1080 if (yydebug) \
1081 yy_stack_print ((Bottom), (Top)); \
1082 } while (YYID (0))
1083
1084
1085 /*------------------------------------------------.
1086 | Report that the YYRULE is going to be reduced. |
1087 `------------------------------------------------*/
1088
1089 #if (defined __STDC__ || defined __C99__FUNC__ \
1090 || defined __cplusplus || defined _MSC_VER)
1091 static void
1092 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1093 #else
1094 static void
1095 yy_reduce_print (yyvsp, yyrule)
1096 YYSTYPE *yyvsp;
1097 int yyrule;
1098 #endif
1099 {
1100 int yynrhs = yyr2[yyrule];
1101 int yyi;
1102 unsigned long int yylno = yyrline[yyrule];
1103 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1104 yyrule - 1, yylno);
1105 /* The symbols being reduced. */
1106 for (yyi = 0; yyi < yynrhs; yyi++)
1107 {
1108 YYFPRINTF (stderr, " $%d = ", yyi + 1);
1109 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1110 &(yyvsp[(yyi + 1) - (yynrhs)])
1111 );
1112 YYFPRINTF (stderr, "\n");
1113 }
1114 }
1115
1116 # define YY_REDUCE_PRINT(Rule) \
1117 do { \
1118 if (yydebug) \
1119 yy_reduce_print (yyvsp, Rule); \
1120 } while (YYID (0))
1121
1122 /* Nonzero means print parse trace. It is left uninitialized so that
1123 multiple parsers can coexist. */
1124 int yydebug;
1125 #else /* !YYDEBUG */
1126 # define YYDPRINTF(Args)
1127 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1128 # define YY_STACK_PRINT(Bottom, Top)
1129 # define YY_REDUCE_PRINT(Rule)
1130 #endif /* !YYDEBUG */
1131
1132
1133 /* YYINITDEPTH -- initial size of the parser's stacks. */
1134 #ifndef YYINITDEPTH
1135 # define YYINITDEPTH 200
1136 #endif
1137
1138 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1139 if the built-in stack extension method is used).
1140
1141 Do not make this value too large; the results are undefined if
1142 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1143 evaluated with infinite-precision integer arithmetic. */
1144
1145 #ifndef YYMAXDEPTH
1146 # define YYMAXDEPTH 10000
1147 #endif
1148
1149 \f
1150
1151 #if YYERROR_VERBOSE
1152
1153 # ifndef yystrlen
1154 # if defined __GLIBC__ && defined _STRING_H
1155 # define yystrlen strlen
1156 # else
1157 /* Return the length of YYSTR. */
1158 #if (defined __STDC__ || defined __C99__FUNC__ \
1159 || defined __cplusplus || defined _MSC_VER)
1160 static YYSIZE_T
1161 yystrlen (const char *yystr)
1162 #else
1163 static YYSIZE_T
1164 yystrlen (yystr)
1165 const char *yystr;
1166 #endif
1167 {
1168 YYSIZE_T yylen;
1169 for (yylen = 0; yystr[yylen]; yylen++)
1170 continue;
1171 return yylen;
1172 }
1173 # endif
1174 # endif
1175
1176 # ifndef yystpcpy
1177 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1178 # define yystpcpy stpcpy
1179 # else
1180 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1181 YYDEST. */
1182 #if (defined __STDC__ || defined __C99__FUNC__ \
1183 || defined __cplusplus || defined _MSC_VER)
1184 static char *
1185 yystpcpy (char *yydest, const char *yysrc)
1186 #else
1187 static char *
1188 yystpcpy (yydest, yysrc)
1189 char *yydest;
1190 const char *yysrc;
1191 #endif
1192 {
1193 char *yyd = yydest;
1194 const char *yys = yysrc;
1195
1196 while ((*yyd++ = *yys++) != '\0')
1197 continue;
1198
1199 return yyd - 1;
1200 }
1201 # endif
1202 # endif
1203
1204 # ifndef yytnamerr
1205 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1206 quotes and backslashes, so that it's suitable for yyerror. The
1207 heuristic is that double-quoting is unnecessary unless the string
1208 contains an apostrophe, a comma, or backslash (other than
1209 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1210 null, do not copy; instead, return the length of what the result
1211 would have been. */
1212 static YYSIZE_T
1213 yytnamerr (char *yyres, const char *yystr)
1214 {
1215 if (*yystr == '"')
1216 {
1217 YYSIZE_T yyn = 0;
1218 char const *yyp = yystr;
1219
1220 for (;;)
1221 switch (*++yyp)
1222 {
1223 case '\'':
1224 case ',':
1225 goto do_not_strip_quotes;
1226
1227 case '\\':
1228 if (*++yyp != '\\')
1229 goto do_not_strip_quotes;
1230 /* Fall through. */
1231 default:
1232 if (yyres)
1233 yyres[yyn] = *yyp;
1234 yyn++;
1235 break;
1236
1237 case '"':
1238 if (yyres)
1239 yyres[yyn] = '\0';
1240 return yyn;
1241 }
1242 do_not_strip_quotes: ;
1243 }
1244
1245 if (! yyres)
1246 return yystrlen (yystr);
1247
1248 return yystpcpy (yyres, yystr) - yyres;
1249 }
1250 # endif
1251
1252 /* Copy into YYRESULT an error message about the unexpected token
1253 YYCHAR while in state YYSTATE. Return the number of bytes copied,
1254 including the terminating null byte. If YYRESULT is null, do not
1255 copy anything; just return the number of bytes that would be
1256 copied. As a special case, return 0 if an ordinary "syntax error"
1257 message will do. Return YYSIZE_MAXIMUM if overflow occurs during
1258 size calculation. */
1259 static YYSIZE_T
1260 yysyntax_error (char *yyresult, int yystate, int yychar)
1261 {
1262 int yyn = yypact[yystate];
1263
1264 if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
1265 return 0;
1266 else
1267 {
1268 int yytype = YYTRANSLATE (yychar);
1269 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1270 YYSIZE_T yysize = yysize0;
1271 YYSIZE_T yysize1;
1272 int yysize_overflow = 0;
1273 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1274 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1275 int yyx;
1276
1277 # if 0
1278 /* This is so xgettext sees the translatable formats that are
1279 constructed on the fly. */
1280 YY_("syntax error, unexpected %s");
1281 YY_("syntax error, unexpected %s, expecting %s");
1282 YY_("syntax error, unexpected %s, expecting %s or %s");
1283 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1284 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1285 # endif
1286 char *yyfmt;
1287 char const *yyf;
1288 static char const yyunexpected[] = "syntax error, unexpected %s";
1289 static char const yyexpecting[] = ", expecting %s";
1290 static char const yyor[] = " or %s";
1291 char yyformat[sizeof yyunexpected
1292 + sizeof yyexpecting - 1
1293 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1294 * (sizeof yyor - 1))];
1295 char const *yyprefix = yyexpecting;
1296
1297 /* Start YYX at -YYN if negative to avoid negative indexes in
1298 YYCHECK. */
1299 int yyxbegin = yyn < 0 ? -yyn : 0;
1300
1301 /* Stay within bounds of both yycheck and yytname. */
1302 int yychecklim = YYLAST - yyn + 1;
1303 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1304 int yycount = 1;
1305
1306 yyarg[0] = yytname[yytype];
1307 yyfmt = yystpcpy (yyformat, yyunexpected);
1308
1309 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1310 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1311 {
1312 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1313 {
1314 yycount = 1;
1315 yysize = yysize0;
1316 yyformat[sizeof yyunexpected - 1] = '\0';
1317 break;
1318 }
1319 yyarg[yycount++] = yytname[yyx];
1320 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1321 yysize_overflow |= (yysize1 < yysize);
1322 yysize = yysize1;
1323 yyfmt = yystpcpy (yyfmt, yyprefix);
1324 yyprefix = yyor;
1325 }
1326
1327 yyf = YY_(yyformat);
1328 yysize1 = yysize + yystrlen (yyf);
1329 yysize_overflow |= (yysize1 < yysize);
1330 yysize = yysize1;
1331
1332 if (yysize_overflow)
1333 return YYSIZE_MAXIMUM;
1334
1335 if (yyresult)
1336 {
1337 /* Avoid sprintf, as that infringes on the user's name space.
1338 Don't have undefined behavior even if the translation
1339 produced a string with the wrong number of "%s"s. */
1340 char *yyp = yyresult;
1341 int yyi = 0;
1342 while ((*yyp = *yyf) != '\0')
1343 {
1344 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1345 {
1346 yyp += yytnamerr (yyp, yyarg[yyi++]);
1347 yyf += 2;
1348 }
1349 else
1350 {
1351 yyp++;
1352 yyf++;
1353 }
1354 }
1355 }
1356 return yysize;
1357 }
1358 }
1359 #endif /* YYERROR_VERBOSE */
1360 \f
1361
1362 /*-----------------------------------------------.
1363 | Release the memory associated to this symbol. |
1364 `-----------------------------------------------*/
1365
1366 /*ARGSUSED*/
1367 #if (defined __STDC__ || defined __C99__FUNC__ \
1368 || defined __cplusplus || defined _MSC_VER)
1369 static void
1370 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1371 #else
1372 static void
1373 yydestruct (yymsg, yytype, yyvaluep)
1374 const char *yymsg;
1375 int yytype;
1376 YYSTYPE *yyvaluep;
1377 #endif
1378 {
1379 YYUSE (yyvaluep);
1380
1381 if (!yymsg)
1382 yymsg = "Deleting";
1383 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1384
1385 switch (yytype)
1386 {
1387
1388 default:
1389 break;
1390 }
1391 }
1392
1393 /* Prevent warnings from -Wmissing-prototypes. */
1394 #ifdef YYPARSE_PARAM
1395 #if defined __STDC__ || defined __cplusplus
1396 int yyparse (void *YYPARSE_PARAM);
1397 #else
1398 int yyparse ();
1399 #endif
1400 #else /* ! YYPARSE_PARAM */
1401 #if defined __STDC__ || defined __cplusplus
1402 int yyparse (void);
1403 #else
1404 int yyparse ();
1405 #endif
1406 #endif /* ! YYPARSE_PARAM */
1407
1408
1409 /* The lookahead symbol. */
1410 int yychar;
1411
1412 /* The semantic value of the lookahead symbol. */
1413 YYSTYPE yylval;
1414
1415 /* Number of syntax errors so far. */
1416 int yynerrs;
1417
1418
1419
1420 /*-------------------------.
1421 | yyparse or yypush_parse. |
1422 `-------------------------*/
1423
1424 #ifdef YYPARSE_PARAM
1425 #if (defined __STDC__ || defined __C99__FUNC__ \
1426 || defined __cplusplus || defined _MSC_VER)
1427 int
1428 yyparse (void *YYPARSE_PARAM)
1429 #else
1430 int
1431 yyparse (YYPARSE_PARAM)
1432 void *YYPARSE_PARAM;
1433 #endif
1434 #else /* ! YYPARSE_PARAM */
1435 #if (defined __STDC__ || defined __C99__FUNC__ \
1436 || defined __cplusplus || defined _MSC_VER)
1437 int
1438 yyparse (void)
1439 #else
1440 int
1441 yyparse ()
1442
1443 #endif
1444 #endif
1445 {
1446
1447
1448 int yystate;
1449 /* Number of tokens to shift before error messages enabled. */
1450 int yyerrstatus;
1451
1452 /* The stacks and their tools:
1453 `yyss': related to states.
1454 `yyvs': related to semantic values.
1455
1456 Refer to the stacks thru separate pointers, to allow yyoverflow
1457 to xreallocate them elsewhere. */
1458
1459 /* The state stack. */
1460 yytype_int16 yyssa[YYINITDEPTH];
1461 yytype_int16 *yyss;
1462 yytype_int16 *yyssp;
1463
1464 /* The semantic value stack. */
1465 YYSTYPE yyvsa[YYINITDEPTH];
1466 YYSTYPE *yyvs;
1467 YYSTYPE *yyvsp;
1468
1469 YYSIZE_T yystacksize;
1470
1471 int yyn;
1472 int yyresult;
1473 /* Lookahead token as an internal (translated) token number. */
1474 int yytoken;
1475 /* The variables used to return semantic value and location from the
1476 action routines. */
1477 YYSTYPE yyval;
1478
1479 #if YYERROR_VERBOSE
1480 /* Buffer for error messages, and its allocated size. */
1481 char yymsgbuf[128];
1482 char *yymsg = yymsgbuf;
1483 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1484 #endif
1485
1486 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1487
1488 /* The number of symbols on the RHS of the reduced rule.
1489 Keep to zero when no symbol should be popped. */
1490 int yylen = 0;
1491
1492 yytoken = 0;
1493 yyss = yyssa;
1494 yyvs = yyvsa;
1495 yystacksize = YYINITDEPTH;
1496
1497 YYDPRINTF ((stderr, "Starting parse\n"));
1498
1499 yystate = 0;
1500 yyerrstatus = 0;
1501 yynerrs = 0;
1502 yychar = YYEMPTY; /* Cause a token to be read. */
1503
1504 /* Initialize stack pointers.
1505 Waste one element of value and location stack
1506 so that they stay on the same level as the state stack.
1507 The wasted elements are never initialized. */
1508 yyssp = yyss;
1509 yyvsp = yyvs;
1510
1511 goto yysetstate;
1512
1513 /*------------------------------------------------------------.
1514 | yynewstate -- Push a new state, which is found in yystate. |
1515 `------------------------------------------------------------*/
1516 yynewstate:
1517 /* In all cases, when you get here, the value and location stacks
1518 have just been pushed. So pushing a state here evens the stacks. */
1519 yyssp++;
1520
1521 yysetstate:
1522 *yyssp = yystate;
1523
1524 if (yyss + yystacksize - 1 <= yyssp)
1525 {
1526 /* Get the current used size of the three stacks, in elements. */
1527 YYSIZE_T yysize = yyssp - yyss + 1;
1528
1529 #ifdef yyoverflow
1530 {
1531 /* Give user a chance to xreallocate the stack. Use copies of
1532 these so that the &'s don't force the real ones into
1533 memory. */
1534 YYSTYPE *yyvs1 = yyvs;
1535 yytype_int16 *yyss1 = yyss;
1536
1537 /* Each stack pointer address is followed by the size of the
1538 data in use in that stack, in bytes. This used to be a
1539 conditional around just the two extra args, but that might
1540 be undefined if yyoverflow is a macro. */
1541 yyoverflow (YY_("memory exhausted"),
1542 &yyss1, yysize * sizeof (*yyssp),
1543 &yyvs1, yysize * sizeof (*yyvsp),
1544 &yystacksize);
1545
1546 yyss = yyss1;
1547 yyvs = yyvs1;
1548 }
1549 #else /* no yyoverflow */
1550 # ifndef YYSTACK_RELOCATE
1551 goto yyexhaustedlab;
1552 # else
1553 /* Extend the stack our own way. */
1554 if (YYMAXDEPTH <= yystacksize)
1555 goto yyexhaustedlab;
1556 yystacksize *= 2;
1557 if (YYMAXDEPTH < yystacksize)
1558 yystacksize = YYMAXDEPTH;
1559
1560 {
1561 yytype_int16 *yyss1 = yyss;
1562 union yyalloc *yyptr =
1563 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1564 if (! yyptr)
1565 goto yyexhaustedlab;
1566 YYSTACK_RELOCATE (yyss_alloc, yyss);
1567 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1568 # undef YYSTACK_RELOCATE
1569 if (yyss1 != yyssa)
1570 YYSTACK_FREE (yyss1);
1571 }
1572 # endif
1573 #endif /* no yyoverflow */
1574
1575 yyssp = yyss + yysize - 1;
1576 yyvsp = yyvs + yysize - 1;
1577
1578 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1579 (unsigned long int) yystacksize));
1580
1581 if (yyss + yystacksize - 1 <= yyssp)
1582 YYABORT;
1583 }
1584
1585 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1586
1587 if (yystate == YYFINAL)
1588 YYACCEPT;
1589
1590 goto yybackup;
1591
1592 /*-----------.
1593 | yybackup. |
1594 `-----------*/
1595 yybackup:
1596
1597 /* Do appropriate processing given the current state. Read a
1598 lookahead token if we need one and don't already have one. */
1599
1600 /* First try to decide what to do without reference to lookahead token. */
1601 yyn = yypact[yystate];
1602 if (yyn == YYPACT_NINF)
1603 goto yydefault;
1604
1605 /* Not known => get a lookahead token if don't already have one. */
1606
1607 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1608 if (yychar == YYEMPTY)
1609 {
1610 YYDPRINTF ((stderr, "Reading a token: "));
1611 yychar = YYLEX;
1612 }
1613
1614 if (yychar <= YYEOF)
1615 {
1616 yychar = yytoken = YYEOF;
1617 YYDPRINTF ((stderr, "Now at end of input.\n"));
1618 }
1619 else
1620 {
1621 yytoken = YYTRANSLATE (yychar);
1622 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1623 }
1624
1625 /* If the proper action on seeing token YYTOKEN is to reduce or to
1626 detect an error, take that action. */
1627 yyn += yytoken;
1628 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1629 goto yydefault;
1630 yyn = yytable[yyn];
1631 if (yyn <= 0)
1632 {
1633 if (yyn == 0 || yyn == YYTABLE_NINF)
1634 goto yyerrlab;
1635 yyn = -yyn;
1636 goto yyreduce;
1637 }
1638
1639 /* Count tokens shifted since error; after three, turn off error
1640 status. */
1641 if (yyerrstatus)
1642 yyerrstatus--;
1643
1644 /* Shift the lookahead token. */
1645 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1646
1647 /* Discard the shifted token. */
1648 yychar = YYEMPTY;
1649
1650 yystate = yyn;
1651 *++yyvsp = yylval;
1652
1653 goto yynewstate;
1654
1655
1656 /*-----------------------------------------------------------.
1657 | yydefault -- do the default action for the current state. |
1658 `-----------------------------------------------------------*/
1659 yydefault:
1660 yyn = yydefact[yystate];
1661 if (yyn == 0)
1662 goto yyerrlab;
1663 goto yyreduce;
1664
1665
1666 /*-----------------------------.
1667 | yyreduce -- Do a reduction. |
1668 `-----------------------------*/
1669 yyreduce:
1670 /* yyn is the number of a rule to reduce with. */
1671 yylen = yyr2[yyn];
1672
1673 /* If YYLEN is nonzero, implement the default value of the action:
1674 `$$ = $1'.
1675
1676 Otherwise, the following line sets YYVAL to garbage.
1677 This behavior is undocumented and Bison
1678 users should not rely upon it. Assigning to YYVAL
1679 unconditionally makes the parser a bit smaller, and it avoids a
1680 GCC warning that YYVAL may be used uninitialized. */
1681 yyval = yyvsp[1-yylen];
1682
1683
1684 YY_REDUCE_PRINT (yyn);
1685 switch (yyn)
1686 {
1687 case 4:
1688
1689 /* Line 1455 of yacc.c */
1690 #line 242 "go-exp.y"
1691 { write_exp_elt_opcode(OP_TYPE);
1692 write_exp_elt_type((yyvsp[(1) - (1)].tval));
1693 write_exp_elt_opcode(OP_TYPE); }
1694 break;
1695
1696 case 6:
1697
1698 /* Line 1455 of yacc.c */
1699 #line 250 "go-exp.y"
1700 { write_exp_elt_opcode (BINOP_COMMA); }
1701 break;
1702
1703 case 7:
1704
1705 /* Line 1455 of yacc.c */
1706 #line 255 "go-exp.y"
1707 { write_exp_elt_opcode (UNOP_IND); }
1708 break;
1709
1710 case 8:
1711
1712 /* Line 1455 of yacc.c */
1713 #line 259 "go-exp.y"
1714 { write_exp_elt_opcode (UNOP_ADDR); }
1715 break;
1716
1717 case 9:
1718
1719 /* Line 1455 of yacc.c */
1720 #line 263 "go-exp.y"
1721 { write_exp_elt_opcode (UNOP_NEG); }
1722 break;
1723
1724 case 10:
1725
1726 /* Line 1455 of yacc.c */
1727 #line 267 "go-exp.y"
1728 { write_exp_elt_opcode (UNOP_PLUS); }
1729 break;
1730
1731 case 11:
1732
1733 /* Line 1455 of yacc.c */
1734 #line 271 "go-exp.y"
1735 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
1736 break;
1737
1738 case 12:
1739
1740 /* Line 1455 of yacc.c */
1741 #line 275 "go-exp.y"
1742 { write_exp_elt_opcode (UNOP_COMPLEMENT); }
1743 break;
1744
1745 case 13:
1746
1747 /* Line 1455 of yacc.c */
1748 #line 279 "go-exp.y"
1749 { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
1750 break;
1751
1752 case 14:
1753
1754 /* Line 1455 of yacc.c */
1755 #line 283 "go-exp.y"
1756 { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
1757 break;
1758
1759 case 15:
1760
1761 /* Line 1455 of yacc.c */
1762 #line 289 "go-exp.y"
1763 { write_exp_elt_opcode (STRUCTOP_STRUCT);
1764 write_exp_string ((yyvsp[(3) - (3)].ssym).stoken);
1765 write_exp_elt_opcode (STRUCTOP_STRUCT); }
1766 break;
1767
1768 case 16:
1769
1770 /* Line 1455 of yacc.c */
1771 #line 295 "go-exp.y"
1772 { mark_struct_expression ();
1773 write_exp_elt_opcode (STRUCTOP_STRUCT);
1774 write_exp_string ((yyvsp[(3) - (4)].ssym).stoken);
1775 write_exp_elt_opcode (STRUCTOP_STRUCT); }
1776 break;
1777
1778 case 17:
1779
1780 /* Line 1455 of yacc.c */
1781 #line 302 "go-exp.y"
1782 { struct stoken s;
1783 mark_struct_expression ();
1784 write_exp_elt_opcode (STRUCTOP_STRUCT);
1785 s.ptr = "";
1786 s.length = 0;
1787 write_exp_string (s);
1788 write_exp_elt_opcode (STRUCTOP_STRUCT); }
1789 break;
1790
1791 case 18:
1792
1793 /* Line 1455 of yacc.c */
1794 #line 312 "go-exp.y"
1795 { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
1796 break;
1797
1798 case 19:
1799
1800 /* Line 1455 of yacc.c */
1801 #line 318 "go-exp.y"
1802 { start_arglist (); }
1803 break;
1804
1805 case 20:
1806
1807 /* Line 1455 of yacc.c */
1808 #line 320 "go-exp.y"
1809 { write_exp_elt_opcode (OP_FUNCALL);
1810 write_exp_elt_longcst ((LONGEST) end_arglist ());
1811 write_exp_elt_opcode (OP_FUNCALL); }
1812 break;
1813
1814 case 21:
1815
1816 /* Line 1455 of yacc.c */
1817 #line 326 "go-exp.y"
1818 { start_arglist (); }
1819 break;
1820
1821 case 23:
1822
1823 /* Line 1455 of yacc.c */
1824 #line 333 "go-exp.y"
1825 { arglist_len = 1; }
1826 break;
1827
1828 case 24:
1829
1830 /* Line 1455 of yacc.c */
1831 #line 337 "go-exp.y"
1832 { arglist_len++; }
1833 break;
1834
1835 case 25:
1836
1837 /* Line 1455 of yacc.c */
1838 #line 341 "go-exp.y"
1839 { (yyval.lval) = end_arglist () - 1; }
1840 break;
1841
1842 case 26:
1843
1844 /* Line 1455 of yacc.c */
1845 #line 345 "go-exp.y"
1846 { write_exp_elt_opcode (UNOP_MEMVAL);
1847 write_exp_elt_type ((yyvsp[(2) - (4)].tval));
1848 write_exp_elt_opcode (UNOP_MEMVAL); }
1849 break;
1850
1851 case 27:
1852
1853 /* Line 1455 of yacc.c */
1854 #line 351 "go-exp.y"
1855 { write_exp_elt_opcode (UNOP_CAST);
1856 write_exp_elt_type ((yyvsp[(1) - (4)].tval));
1857 write_exp_elt_opcode (UNOP_CAST); }
1858 break;
1859
1860 case 28:
1861
1862 /* Line 1455 of yacc.c */
1863 #line 357 "go-exp.y"
1864 { }
1865 break;
1866
1867 case 29:
1868
1869 /* Line 1455 of yacc.c */
1870 #line 363 "go-exp.y"
1871 { write_exp_elt_opcode (BINOP_REPEAT); }
1872 break;
1873
1874 case 30:
1875
1876 /* Line 1455 of yacc.c */
1877 #line 367 "go-exp.y"
1878 { write_exp_elt_opcode (BINOP_MUL); }
1879 break;
1880
1881 case 31:
1882
1883 /* Line 1455 of yacc.c */
1884 #line 371 "go-exp.y"
1885 { write_exp_elt_opcode (BINOP_DIV); }
1886 break;
1887
1888 case 32:
1889
1890 /* Line 1455 of yacc.c */
1891 #line 375 "go-exp.y"
1892 { write_exp_elt_opcode (BINOP_REM); }
1893 break;
1894
1895 case 33:
1896
1897 /* Line 1455 of yacc.c */
1898 #line 379 "go-exp.y"
1899 { write_exp_elt_opcode (BINOP_ADD); }
1900 break;
1901
1902 case 34:
1903
1904 /* Line 1455 of yacc.c */
1905 #line 383 "go-exp.y"
1906 { write_exp_elt_opcode (BINOP_SUB); }
1907 break;
1908
1909 case 35:
1910
1911 /* Line 1455 of yacc.c */
1912 #line 387 "go-exp.y"
1913 { write_exp_elt_opcode (BINOP_LSH); }
1914 break;
1915
1916 case 36:
1917
1918 /* Line 1455 of yacc.c */
1919 #line 391 "go-exp.y"
1920 { write_exp_elt_opcode (BINOP_RSH); }
1921 break;
1922
1923 case 37:
1924
1925 /* Line 1455 of yacc.c */
1926 #line 395 "go-exp.y"
1927 { write_exp_elt_opcode (BINOP_EQUAL); }
1928 break;
1929
1930 case 38:
1931
1932 /* Line 1455 of yacc.c */
1933 #line 399 "go-exp.y"
1934 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
1935 break;
1936
1937 case 39:
1938
1939 /* Line 1455 of yacc.c */
1940 #line 403 "go-exp.y"
1941 { write_exp_elt_opcode (BINOP_LEQ); }
1942 break;
1943
1944 case 40:
1945
1946 /* Line 1455 of yacc.c */
1947 #line 407 "go-exp.y"
1948 { write_exp_elt_opcode (BINOP_GEQ); }
1949 break;
1950
1951 case 41:
1952
1953 /* Line 1455 of yacc.c */
1954 #line 411 "go-exp.y"
1955 { write_exp_elt_opcode (BINOP_LESS); }
1956 break;
1957
1958 case 42:
1959
1960 /* Line 1455 of yacc.c */
1961 #line 415 "go-exp.y"
1962 { write_exp_elt_opcode (BINOP_GTR); }
1963 break;
1964
1965 case 43:
1966
1967 /* Line 1455 of yacc.c */
1968 #line 419 "go-exp.y"
1969 { write_exp_elt_opcode (BINOP_BITWISE_AND); }
1970 break;
1971
1972 case 44:
1973
1974 /* Line 1455 of yacc.c */
1975 #line 423 "go-exp.y"
1976 { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
1977 break;
1978
1979 case 45:
1980
1981 /* Line 1455 of yacc.c */
1982 #line 427 "go-exp.y"
1983 { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
1984 break;
1985
1986 case 46:
1987
1988 /* Line 1455 of yacc.c */
1989 #line 431 "go-exp.y"
1990 { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
1991 break;
1992
1993 case 47:
1994
1995 /* Line 1455 of yacc.c */
1996 #line 435 "go-exp.y"
1997 { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
1998 break;
1999
2000 case 48:
2001
2002 /* Line 1455 of yacc.c */
2003 #line 439 "go-exp.y"
2004 { write_exp_elt_opcode (TERNOP_COND); }
2005 break;
2006
2007 case 49:
2008
2009 /* Line 1455 of yacc.c */
2010 #line 443 "go-exp.y"
2011 { write_exp_elt_opcode (BINOP_ASSIGN); }
2012 break;
2013
2014 case 50:
2015
2016 /* Line 1455 of yacc.c */
2017 #line 447 "go-exp.y"
2018 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
2019 write_exp_elt_opcode ((yyvsp[(2) - (3)].opcode));
2020 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
2021 break;
2022
2023 case 51:
2024
2025 /* Line 1455 of yacc.c */
2026 #line 453 "go-exp.y"
2027 { write_exp_elt_opcode (OP_LONG);
2028 write_exp_elt_type ((yyvsp[(1) - (1)].typed_val_int).type);
2029 write_exp_elt_longcst ((LONGEST)((yyvsp[(1) - (1)].typed_val_int).val));
2030 write_exp_elt_opcode (OP_LONG); }
2031 break;
2032
2033 case 52:
2034
2035 /* Line 1455 of yacc.c */
2036 #line 460 "go-exp.y"
2037 {
2038 struct stoken_vector vec;
2039 vec.len = 1;
2040 vec.tokens = &(yyvsp[(1) - (1)].tsval);
2041 write_exp_string_vector ((yyvsp[(1) - (1)].tsval).type, &vec);
2042 }
2043 break;
2044
2045 case 53:
2046
2047 /* Line 1455 of yacc.c */
2048 #line 469 "go-exp.y"
2049 { YYSTYPE val;
2050 parse_number ((yyvsp[(1) - (1)].ssym).stoken.ptr, (yyvsp[(1) - (1)].ssym).stoken.length,
2051 0, &val);
2052 write_exp_elt_opcode (OP_LONG);
2053 write_exp_elt_type (val.typed_val_int.type);
2054 write_exp_elt_longcst ((LONGEST)
2055 val.typed_val_int.val);
2056 write_exp_elt_opcode (OP_LONG);
2057 }
2058 break;
2059
2060 case 54:
2061
2062 /* Line 1455 of yacc.c */
2063 #line 482 "go-exp.y"
2064 { write_exp_elt_opcode (OP_DOUBLE);
2065 write_exp_elt_type ((yyvsp[(1) - (1)].typed_val_float).type);
2066 write_exp_elt_dblcst ((yyvsp[(1) - (1)].typed_val_float).dval);
2067 write_exp_elt_opcode (OP_DOUBLE); }
2068 break;
2069
2070 case 56:
2071
2072 /* Line 1455 of yacc.c */
2073 #line 492 "go-exp.y"
2074 {
2075 write_dollar_variable ((yyvsp[(1) - (1)].sval));
2076 }
2077 break;
2078
2079 case 57:
2080
2081 /* Line 1455 of yacc.c */
2082 #line 498 "go-exp.y"
2083 {
2084 /* TODO(dje): Go objects in structs. */
2085 write_exp_elt_opcode (OP_LONG);
2086 /* TODO(dje): What's the right type here? */
2087 write_exp_elt_type (parse_type->builtin_unsigned_int);
2088 CHECK_TYPEDEF ((yyvsp[(3) - (4)].tval));
2089 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ((yyvsp[(3) - (4)].tval)));
2090 write_exp_elt_opcode (OP_LONG);
2091 }
2092 break;
2093
2094 case 58:
2095
2096 /* Line 1455 of yacc.c */
2097 #line 510 "go-exp.y"
2098 {
2099 /* TODO(dje): Go objects in structs. */
2100 write_exp_elt_opcode (UNOP_SIZEOF);
2101 }
2102 break;
2103
2104 case 59:
2105
2106 /* Line 1455 of yacc.c */
2107 #line 517 "go-exp.y"
2108 {
2109 /* We copy the string here, and not in the
2110 lexer, to guarantee that we do not leak a
2111 string. */
2112 /* Note that we NUL-terminate here, but just
2113 for convenience. */
2114 struct typed_stoken *vec = XNEW (struct typed_stoken);
2115 (yyval.svec).len = 1;
2116 (yyval.svec).tokens = vec;
2117
2118 vec->type = (yyvsp[(1) - (1)].tsval).type;
2119 vec->length = (yyvsp[(1) - (1)].tsval).length;
2120 vec->ptr = xmalloc ((yyvsp[(1) - (1)].tsval).length + 1);
2121 memcpy (vec->ptr, (yyvsp[(1) - (1)].tsval).ptr, (yyvsp[(1) - (1)].tsval).length + 1);
2122 }
2123 break;
2124
2125 case 60:
2126
2127 /* Line 1455 of yacc.c */
2128 #line 534 "go-exp.y"
2129 {
2130 /* Note that we NUL-terminate here, but just
2131 for convenience. */
2132 char *p;
2133 ++(yyval.svec).len;
2134 (yyval.svec).tokens = xrealloc ((yyval.svec).tokens,
2135 (yyval.svec).len * sizeof (struct typed_stoken));
2136
2137 p = xmalloc ((yyvsp[(3) - (3)].tsval).length + 1);
2138 memcpy (p, (yyvsp[(3) - (3)].tsval).ptr, (yyvsp[(3) - (3)].tsval).length + 1);
2139
2140 (yyval.svec).tokens[(yyval.svec).len - 1].type = (yyvsp[(3) - (3)].tsval).type;
2141 (yyval.svec).tokens[(yyval.svec).len - 1].length = (yyvsp[(3) - (3)].tsval).length;
2142 (yyval.svec).tokens[(yyval.svec).len - 1].ptr = p;
2143 }
2144 break;
2145
2146 case 61:
2147
2148 /* Line 1455 of yacc.c */
2149 #line 552 "go-exp.y"
2150 {
2151 int i;
2152
2153 write_exp_string_vector (0 /*always utf8*/, &(yyvsp[(1) - (1)].svec));
2154 for (i = 0; i < (yyvsp[(1) - (1)].svec).len; ++i)
2155 xfree ((yyvsp[(1) - (1)].svec).tokens[i].ptr);
2156 xfree ((yyvsp[(1) - (1)].svec).tokens);
2157 }
2158 break;
2159
2160 case 62:
2161
2162 /* Line 1455 of yacc.c */
2163 #line 563 "go-exp.y"
2164 { write_exp_elt_opcode (OP_BOOL);
2165 write_exp_elt_longcst ((LONGEST) (yyvsp[(1) - (1)].lval));
2166 write_exp_elt_opcode (OP_BOOL); }
2167 break;
2168
2169 case 63:
2170
2171 /* Line 1455 of yacc.c */
2172 #line 569 "go-exp.y"
2173 { write_exp_elt_opcode (OP_BOOL);
2174 write_exp_elt_longcst ((LONGEST) (yyvsp[(1) - (1)].lval));
2175 write_exp_elt_opcode (OP_BOOL); }
2176 break;
2177
2178 case 64:
2179
2180 /* Line 1455 of yacc.c */
2181 #line 575 "go-exp.y"
2182 { struct symbol *sym = (yyvsp[(1) - (2)].ssym).sym;
2183
2184 if (sym == NULL
2185 || !SYMBOL_IS_ARGUMENT (sym)
2186 || !symbol_read_needs_frame (sym))
2187 error (_("@entry can be used only for function "
2188 "parameters, not for \"%s\""),
2189 copy_name ((yyvsp[(1) - (2)].ssym).stoken));
2190
2191 write_exp_elt_opcode (OP_VAR_ENTRY_VALUE);
2192 write_exp_elt_sym (sym);
2193 write_exp_elt_opcode (OP_VAR_ENTRY_VALUE);
2194 }
2195 break;
2196
2197 case 65:
2198
2199 /* Line 1455 of yacc.c */
2200 #line 591 "go-exp.y"
2201 { struct symbol *sym = (yyvsp[(1) - (1)].ssym).sym;
2202
2203 if (sym)
2204 {
2205 if (symbol_read_needs_frame (sym))
2206 {
2207 if (innermost_block == 0
2208 || contained_in (block_found,
2209 innermost_block))
2210 innermost_block = block_found;
2211 }
2212
2213 write_exp_elt_opcode (OP_VAR_VALUE);
2214 /* We want to use the selected frame, not
2215 another more inner frame which happens to
2216 be in the same block. */
2217 write_exp_elt_block (NULL);
2218 write_exp_elt_sym (sym);
2219 write_exp_elt_opcode (OP_VAR_VALUE);
2220 }
2221 else if ((yyvsp[(1) - (1)].ssym).is_a_field_of_this)
2222 {
2223 /* TODO(dje): Can we get here?
2224 E.g., via a mix of c++ and go? */
2225 gdb_assert_not_reached ("go with `this' field");
2226 }
2227 else
2228 {
2229 struct minimal_symbol *msymbol;
2230 char *arg = copy_name ((yyvsp[(1) - (1)].ssym).stoken);
2231
2232 msymbol =
2233 lookup_minimal_symbol (arg, NULL, NULL);
2234 if (msymbol != NULL)
2235 write_exp_msymbol (msymbol);
2236 else if (!have_full_symbols ()
2237 && !have_partial_symbols ())
2238 error (_("No symbol table is loaded. "
2239 "Use the \"file\" command."));
2240 else
2241 error (_("No symbol \"%s\" in current context."),
2242 copy_name ((yyvsp[(1) - (1)].ssym).stoken));
2243 }
2244 }
2245 break;
2246
2247 case 66:
2248
2249 /* Line 1455 of yacc.c */
2250 #line 646 "go-exp.y"
2251 { (yyval.tval) = lookup_pointer_type ((yyvsp[(2) - (2)].tval)); }
2252 break;
2253
2254 case 67:
2255
2256 /* Line 1455 of yacc.c */
2257 #line 648 "go-exp.y"
2258 { (yyval.tval) = (yyvsp[(1) - (1)].tsym).type; }
2259 break;
2260
2261 case 68:
2262
2263 /* Line 1455 of yacc.c */
2264 #line 655 "go-exp.y"
2265 { (yyval.tval) = builtin_go_type (parse_gdbarch)
2266 ->builtin_uint8; }
2267 break;
2268
2269
2270
2271 /* Line 1455 of yacc.c */
2272 #line 2274 "go-exp.c"
2273 default: break;
2274 }
2275 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
2276
2277 YYPOPSTACK (yylen);
2278 yylen = 0;
2279 YY_STACK_PRINT (yyss, yyssp);
2280
2281 *++yyvsp = yyval;
2282
2283 /* Now `shift' the result of the reduction. Determine what state
2284 that goes to, based on the state we popped back to and the rule
2285 number reduced by. */
2286
2287 yyn = yyr1[yyn];
2288
2289 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2290 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2291 yystate = yytable[yystate];
2292 else
2293 yystate = yydefgoto[yyn - YYNTOKENS];
2294
2295 goto yynewstate;
2296
2297
2298 /*------------------------------------.
2299 | yyerrlab -- here on detecting error |
2300 `------------------------------------*/
2301 yyerrlab:
2302 /* If not already recovering from an error, report this error. */
2303 if (!yyerrstatus)
2304 {
2305 ++yynerrs;
2306 #if ! YYERROR_VERBOSE
2307 yyerror (YY_("syntax error"));
2308 #else
2309 {
2310 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
2311 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
2312 {
2313 YYSIZE_T yyalloc = 2 * yysize;
2314 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
2315 yyalloc = YYSTACK_ALLOC_MAXIMUM;
2316 if (yymsg != yymsgbuf)
2317 YYSTACK_FREE (yymsg);
2318 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
2319 if (yymsg)
2320 yymsg_alloc = yyalloc;
2321 else
2322 {
2323 yymsg = yymsgbuf;
2324 yymsg_alloc = sizeof yymsgbuf;
2325 }
2326 }
2327
2328 if (0 < yysize && yysize <= yymsg_alloc)
2329 {
2330 (void) yysyntax_error (yymsg, yystate, yychar);
2331 yyerror (yymsg);
2332 }
2333 else
2334 {
2335 yyerror (YY_("syntax error"));
2336 if (yysize != 0)
2337 goto yyexhaustedlab;
2338 }
2339 }
2340 #endif
2341 }
2342
2343
2344
2345 if (yyerrstatus == 3)
2346 {
2347 /* If just tried and failed to reuse lookahead token after an
2348 error, discard it. */
2349
2350 if (yychar <= YYEOF)
2351 {
2352 /* Return failure if at end of input. */
2353 if (yychar == YYEOF)
2354 YYABORT;
2355 }
2356 else
2357 {
2358 yydestruct ("Error: discarding",
2359 yytoken, &yylval);
2360 yychar = YYEMPTY;
2361 }
2362 }
2363
2364 /* Else will try to reuse lookahead token after shifting the error
2365 token. */
2366 goto yyerrlab1;
2367
2368
2369 /*---------------------------------------------------.
2370 | yyerrorlab -- error raised explicitly by YYERROR. |
2371 `---------------------------------------------------*/
2372 yyerrorlab:
2373
2374 /* Pacify compilers like GCC when the user code never invokes
2375 YYERROR and the label yyerrorlab therefore never appears in user
2376 code. */
2377 if (/*CONSTCOND*/ 0)
2378 goto yyerrorlab;
2379
2380 /* Do not reclaim the symbols of the rule which action triggered
2381 this YYERROR. */
2382 YYPOPSTACK (yylen);
2383 yylen = 0;
2384 YY_STACK_PRINT (yyss, yyssp);
2385 yystate = *yyssp;
2386 goto yyerrlab1;
2387
2388
2389 /*-------------------------------------------------------------.
2390 | yyerrlab1 -- common code for both syntax error and YYERROR. |
2391 `-------------------------------------------------------------*/
2392 yyerrlab1:
2393 yyerrstatus = 3; /* Each real token shifted decrements this. */
2394
2395 for (;;)
2396 {
2397 yyn = yypact[yystate];
2398 if (yyn != YYPACT_NINF)
2399 {
2400 yyn += YYTERROR;
2401 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
2402 {
2403 yyn = yytable[yyn];
2404 if (0 < yyn)
2405 break;
2406 }
2407 }
2408
2409 /* Pop the current state because it cannot handle the error token. */
2410 if (yyssp == yyss)
2411 YYABORT;
2412
2413
2414 yydestruct ("Error: popping",
2415 yystos[yystate], yyvsp);
2416 YYPOPSTACK (1);
2417 yystate = *yyssp;
2418 YY_STACK_PRINT (yyss, yyssp);
2419 }
2420
2421 *++yyvsp = yylval;
2422
2423
2424 /* Shift the error token. */
2425 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
2426
2427 yystate = yyn;
2428 goto yynewstate;
2429
2430
2431 /*-------------------------------------.
2432 | yyacceptlab -- YYACCEPT comes here. |
2433 `-------------------------------------*/
2434 yyacceptlab:
2435 yyresult = 0;
2436 goto yyreturn;
2437
2438 /*-----------------------------------.
2439 | yyabortlab -- YYABORT comes here. |
2440 `-----------------------------------*/
2441 yyabortlab:
2442 yyresult = 1;
2443 goto yyreturn;
2444
2445 #if !defined(yyoverflow) || YYERROR_VERBOSE
2446 /*-------------------------------------------------.
2447 | yyexhaustedlab -- memory exhaustion comes here. |
2448 `-------------------------------------------------*/
2449 yyexhaustedlab:
2450 yyerror (YY_("memory exhausted"));
2451 yyresult = 2;
2452 /* Fall through. */
2453 #endif
2454
2455 yyreturn:
2456 if (yychar != YYEMPTY)
2457 yydestruct ("Cleanup: discarding lookahead",
2458 yytoken, &yylval);
2459 /* Do not reclaim the symbols of the rule which action triggered
2460 this YYABORT or YYACCEPT. */
2461 YYPOPSTACK (yylen);
2462 YY_STACK_PRINT (yyss, yyssp);
2463 while (yyssp != yyss)
2464 {
2465 yydestruct ("Cleanup: popping",
2466 yystos[*yyssp], yyvsp);
2467 YYPOPSTACK (1);
2468 }
2469 #ifndef yyoverflow
2470 if (yyss != yyssa)
2471 YYSTACK_FREE (yyss);
2472 #endif
2473 #if YYERROR_VERBOSE
2474 if (yymsg != yymsgbuf)
2475 YYSTACK_FREE (yymsg);
2476 #endif
2477 /* Make sure YYID is used. */
2478 return YYID (yyresult);
2479 }
2480
2481
2482
2483 /* Line 1675 of yacc.c */
2484 #line 677 "go-exp.y"
2485
2486
2487 /* Wrapper on parse_c_float to get the type right for Go. */
2488
2489 static int
2490 parse_go_float (struct gdbarch *gdbarch, const char *p, int len,
2491 DOUBLEST *d, struct type **t)
2492 {
2493 int result = parse_c_float (gdbarch, p, len, d, t);
2494 const struct builtin_type *builtin_types = builtin_type (gdbarch);
2495 const struct builtin_go_type *builtin_go_types = builtin_go_type (gdbarch);
2496
2497 if (*t == builtin_types->builtin_float)
2498 *t = builtin_go_types->builtin_float32;
2499 else if (*t == builtin_types->builtin_double)
2500 *t = builtin_go_types->builtin_float64;
2501
2502 return result;
2503 }
2504
2505 /* Take care of parsing a number (anything that starts with a digit).
2506 Set yylval and return the token type; update lexptr.
2507 LEN is the number of characters in it. */
2508
2509 /* FIXME: Needs some error checking for the float case. */
2510 /* FIXME(dje): IWBN to use c-exp.y's parse_number if we could.
2511 That will require moving the guts into a function that we both call
2512 as our YYSTYPE is different than c-exp.y's */
2513
2514 static int
2515 parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere)
2516 {
2517 /* FIXME: Shouldn't these be unsigned? We don't deal with negative values
2518 here, and we do kind of silly things like cast to unsigned. */
2519 LONGEST n = 0;
2520 LONGEST prevn = 0;
2521 ULONGEST un;
2522
2523 int i = 0;
2524 int c;
2525 int base = input_radix;
2526 int unsigned_p = 0;
2527
2528 /* Number of "L" suffixes encountered. */
2529 int long_p = 0;
2530
2531 /* We have found a "L" or "U" suffix. */
2532 int found_suffix = 0;
2533
2534 ULONGEST high_bit;
2535 struct type *signed_type;
2536 struct type *unsigned_type;
2537
2538 if (parsed_float)
2539 {
2540 if (! parse_go_float (parse_gdbarch, p, len,
2541 &putithere->typed_val_float.dval,
2542 &putithere->typed_val_float.type))
2543 return ERROR;
2544 return FLOAT;
2545 }
2546
2547 /* Handle base-switching prefixes 0x, 0t, 0d, 0. */
2548 if (p[0] == '0')
2549 switch (p[1])
2550 {
2551 case 'x':
2552 case 'X':
2553 if (len >= 3)
2554 {
2555 p += 2;
2556 base = 16;
2557 len -= 2;
2558 }
2559 break;
2560
2561 case 'b':
2562 case 'B':
2563 if (len >= 3)
2564 {
2565 p += 2;
2566 base = 2;
2567 len -= 2;
2568 }
2569 break;
2570
2571 case 't':
2572 case 'T':
2573 case 'd':
2574 case 'D':
2575 if (len >= 3)
2576 {
2577 p += 2;
2578 base = 10;
2579 len -= 2;
2580 }
2581 break;
2582
2583 default:
2584 base = 8;
2585 break;
2586 }
2587
2588 while (len-- > 0)
2589 {
2590 c = *p++;
2591 if (c >= 'A' && c <= 'Z')
2592 c += 'a' - 'A';
2593 if (c != 'l' && c != 'u')
2594 n *= base;
2595 if (c >= '0' && c <= '9')
2596 {
2597 if (found_suffix)
2598 return ERROR;
2599 n += i = c - '0';
2600 }
2601 else
2602 {
2603 if (base > 10 && c >= 'a' && c <= 'f')
2604 {
2605 if (found_suffix)
2606 return ERROR;
2607 n += i = c - 'a' + 10;
2608 }
2609 else if (c == 'l')
2610 {
2611 ++long_p;
2612 found_suffix = 1;
2613 }
2614 else if (c == 'u')
2615 {
2616 unsigned_p = 1;
2617 found_suffix = 1;
2618 }
2619 else
2620 return ERROR; /* Char not a digit */
2621 }
2622 if (i >= base)
2623 return ERROR; /* Invalid digit in this base. */
2624
2625 /* Portably test for overflow (only works for nonzero values, so make
2626 a second check for zero). FIXME: Can't we just make n and prevn
2627 unsigned and avoid this? */
2628 if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
2629 unsigned_p = 1; /* Try something unsigned. */
2630
2631 /* Portably test for unsigned overflow.
2632 FIXME: This check is wrong; for example it doesn't find overflow
2633 on 0x123456789 when LONGEST is 32 bits. */
2634 if (c != 'l' && c != 'u' && n != 0)
2635 {
2636 if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
2637 error (_("Numeric constant too large."));
2638 }
2639 prevn = n;
2640 }
2641
2642 /* An integer constant is an int, a long, or a long long. An L
2643 suffix forces it to be long; an LL suffix forces it to be long
2644 long. If not forced to a larger size, it gets the first type of
2645 the above that it fits in. To figure out whether it fits, we
2646 shift it right and see whether anything remains. Note that we
2647 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
2648 operation, because many compilers will warn about such a shift
2649 (which always produces a zero result). Sometimes gdbarch_int_bit
2650 or gdbarch_long_bit will be that big, sometimes not. To deal with
2651 the case where it is we just always shift the value more than
2652 once, with fewer bits each time. */
2653
2654 un = (ULONGEST)n >> 2;
2655 if (long_p == 0
2656 && (un >> (gdbarch_int_bit (parse_gdbarch) - 2)) == 0)
2657 {
2658 high_bit = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch) - 1);
2659
2660 /* A large decimal (not hex or octal) constant (between INT_MAX
2661 and UINT_MAX) is a long or unsigned long, according to ANSI,
2662 never an unsigned int, but this code treats it as unsigned
2663 int. This probably should be fixed. GCC gives a warning on
2664 such constants. */
2665
2666 unsigned_type = parse_type->builtin_unsigned_int;
2667 signed_type = parse_type->builtin_int;
2668 }
2669 else if (long_p <= 1
2670 && (un >> (gdbarch_long_bit (parse_gdbarch) - 2)) == 0)
2671 {
2672 high_bit = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch) - 1);
2673 unsigned_type = parse_type->builtin_unsigned_long;
2674 signed_type = parse_type->builtin_long;
2675 }
2676 else
2677 {
2678 int shift;
2679 if (sizeof (ULONGEST) * HOST_CHAR_BIT
2680 < gdbarch_long_long_bit (parse_gdbarch))
2681 /* A long long does not fit in a LONGEST. */
2682 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
2683 else
2684 shift = (gdbarch_long_long_bit (parse_gdbarch) - 1);
2685 high_bit = (ULONGEST) 1 << shift;
2686 unsigned_type = parse_type->builtin_unsigned_long_long;
2687 signed_type = parse_type->builtin_long_long;
2688 }
2689
2690 putithere->typed_val_int.val = n;
2691
2692 /* If the high bit of the worked out type is set then this number
2693 has to be unsigned. */
2694
2695 if (unsigned_p || (n & high_bit))
2696 {
2697 putithere->typed_val_int.type = unsigned_type;
2698 }
2699 else
2700 {
2701 putithere->typed_val_int.type = signed_type;
2702 }
2703
2704 return INT;
2705 }
2706
2707 /* Temporary obstack used for holding strings. */
2708 static struct obstack tempbuf;
2709 static int tempbuf_init;
2710
2711 /* Parse a string or character literal from TOKPTR. The string or
2712 character may be wide or unicode. *OUTPTR is set to just after the
2713 end of the literal in the input string. The resulting token is
2714 stored in VALUE. This returns a token value, either STRING or
2715 CHAR, depending on what was parsed. *HOST_CHARS is set to the
2716 number of host characters in the literal. */
2717
2718 static int
2719 parse_string_or_char (char *tokptr, char **outptr, struct typed_stoken *value,
2720 int *host_chars)
2721 {
2722 int quote;
2723
2724 /* Build the gdb internal form of the input string in tempbuf. Note
2725 that the buffer is null byte terminated *only* for the
2726 convenience of debugging gdb itself and printing the buffer
2727 contents when the buffer contains no embedded nulls. Gdb does
2728 not depend upon the buffer being null byte terminated, it uses
2729 the length string instead. This allows gdb to handle C strings
2730 (as well as strings in other languages) with embedded null
2731 bytes */
2732
2733 if (!tempbuf_init)
2734 tempbuf_init = 1;
2735 else
2736 obstack_free (&tempbuf, NULL);
2737 obstack_init (&tempbuf);
2738
2739 /* Skip the quote. */
2740 quote = *tokptr;
2741 ++tokptr;
2742
2743 *host_chars = 0;
2744
2745 while (*tokptr)
2746 {
2747 char c = *tokptr;
2748 if (c == '\\')
2749 {
2750 ++tokptr;
2751 *host_chars += c_parse_escape (&tokptr, &tempbuf);
2752 }
2753 else if (c == quote)
2754 break;
2755 else
2756 {
2757 obstack_1grow (&tempbuf, c);
2758 ++tokptr;
2759 /* FIXME: this does the wrong thing with multi-byte host
2760 characters. We could use mbrlen here, but that would
2761 make "set host-charset" a bit less useful. */
2762 ++*host_chars;
2763 }
2764 }
2765
2766 if (*tokptr != quote)
2767 {
2768 if (quote == '"')
2769 error (_("Unterminated string in expression."));
2770 else
2771 error (_("Unmatched single quote."));
2772 }
2773 ++tokptr;
2774
2775 value->type = C_STRING | (quote == '\'' ? C_CHAR : 0); /*FIXME*/
2776 value->ptr = obstack_base (&tempbuf);
2777 value->length = obstack_object_size (&tempbuf);
2778
2779 *outptr = tokptr;
2780
2781 return quote == '\'' ? CHAR : STRING;
2782 }
2783
2784 struct token
2785 {
2786 char *operator;
2787 int token;
2788 enum exp_opcode opcode;
2789 };
2790
2791 static const struct token tokentab3[] =
2792 {
2793 {">>=", ASSIGN_MODIFY, BINOP_RSH},
2794 {"<<=", ASSIGN_MODIFY, BINOP_LSH},
2795 /*{"&^=", ASSIGN_MODIFY, BINOP_BITWISE_ANDNOT}, TODO */
2796 {"...", DOTDOTDOT, OP_NULL},
2797 };
2798
2799 static const struct token tokentab2[] =
2800 {
2801 {"+=", ASSIGN_MODIFY, BINOP_ADD},
2802 {"-=", ASSIGN_MODIFY, BINOP_SUB},
2803 {"*=", ASSIGN_MODIFY, BINOP_MUL},
2804 {"/=", ASSIGN_MODIFY, BINOP_DIV},
2805 {"%=", ASSIGN_MODIFY, BINOP_REM},
2806 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
2807 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
2808 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
2809 {"++", INCREMENT, BINOP_END},
2810 {"--", DECREMENT, BINOP_END},
2811 /*{"->", RIGHT_ARROW, BINOP_END}, Doesn't exist in Go. */
2812 {"<-", LEFT_ARROW, BINOP_END},
2813 {"&&", ANDAND, BINOP_END},
2814 {"||", OROR, BINOP_END},
2815 {"<<", LSH, BINOP_END},
2816 {">>", RSH, BINOP_END},
2817 {"==", EQUAL, BINOP_END},
2818 {"!=", NOTEQUAL, BINOP_END},
2819 {"<=", LEQ, BINOP_END},
2820 {">=", GEQ, BINOP_END},
2821 /*{"&^", ANDNOT, BINOP_END}, TODO */
2822 };
2823
2824 /* Identifier-like tokens. */
2825 static const struct token ident_tokens[] =
2826 {
2827 {"true", TRUE_KEYWORD, OP_NULL},
2828 {"false", FALSE_KEYWORD, OP_NULL},
2829 {"nil", NIL_KEYWORD, OP_NULL},
2830 {"const", CONST_KEYWORD, OP_NULL},
2831 {"struct", STRUCT_KEYWORD, OP_NULL},
2832 {"type", TYPE_KEYWORD, OP_NULL},
2833 {"interface", INTERFACE_KEYWORD, OP_NULL},
2834 {"chan", CHAN_KEYWORD, OP_NULL},
2835 {"byte", BYTE_KEYWORD, OP_NULL}, /* An alias of uint8. */
2836 {"len", LEN_KEYWORD, OP_NULL},
2837 {"cap", CAP_KEYWORD, OP_NULL},
2838 {"new", NEW_KEYWORD, OP_NULL},
2839 {"iota", IOTA_KEYWORD, OP_NULL},
2840 };
2841
2842 /* This is set if a NAME token appeared at the very end of the input
2843 string, with no whitespace separating the name from the EOF. This
2844 is used only when parsing to do field name completion. */
2845 static int saw_name_at_eof;
2846
2847 /* This is set if the previously-returned token was a structure
2848 operator -- either '.' or ARROW. This is used only when parsing to
2849 do field name completion. */
2850 static int last_was_structop;
2851
2852 /* Read one token, getting characters through lexptr. */
2853
2854 static int
2855 lex_one_token (void)
2856 {
2857 int c;
2858 int namelen;
2859 unsigned int i;
2860 char *tokstart;
2861 int saw_structop = last_was_structop;
2862 char *copy;
2863
2864 last_was_structop = 0;
2865
2866 retry:
2867
2868 prev_lexptr = lexptr;
2869
2870 tokstart = lexptr;
2871 /* See if it is a special token of length 3. */
2872 for (i = 0; i < sizeof (tokentab3) / sizeof (tokentab3[0]); i++)
2873 if (strncmp (tokstart, tokentab3[i].operator, 3) == 0)
2874 {
2875 lexptr += 3;
2876 yylval.opcode = tokentab3[i].opcode;
2877 return tokentab3[i].token;
2878 }
2879
2880 /* See if it is a special token of length 2. */
2881 for (i = 0; i < sizeof (tokentab2) / sizeof (tokentab2[0]); i++)
2882 if (strncmp (tokstart, tokentab2[i].operator, 2) == 0)
2883 {
2884 lexptr += 2;
2885 yylval.opcode = tokentab2[i].opcode;
2886 /* NOTE: -> doesn't exist in Go, so we don't need to watch for
2887 setting last_was_structop here. */
2888 return tokentab2[i].token;
2889 }
2890
2891 switch (c = *tokstart)
2892 {
2893 case 0:
2894 if (saw_name_at_eof)
2895 {
2896 saw_name_at_eof = 0;
2897 return COMPLETE;
2898 }
2899 else if (saw_structop)
2900 return COMPLETE;
2901 else
2902 return 0;
2903
2904 case ' ':
2905 case '\t':
2906 case '\n':
2907 lexptr++;
2908 goto retry;
2909
2910 case '[':
2911 case '(':
2912 paren_depth++;
2913 lexptr++;
2914 return c;
2915
2916 case ']':
2917 case ')':
2918 if (paren_depth == 0)
2919 return 0;
2920 paren_depth--;
2921 lexptr++;
2922 return c;
2923
2924 case ',':
2925 if (comma_terminates
2926 && paren_depth == 0)
2927 return 0;
2928 lexptr++;
2929 return c;
2930
2931 case '.':
2932 /* Might be a floating point number. */
2933 if (lexptr[1] < '0' || lexptr[1] > '9')
2934 {
2935 if (parse_completion)
2936 last_was_structop = 1;
2937 goto symbol; /* Nope, must be a symbol. */
2938 }
2939 /* FALL THRU into number case. */
2940
2941 case '0':
2942 case '1':
2943 case '2':
2944 case '3':
2945 case '4':
2946 case '5':
2947 case '6':
2948 case '7':
2949 case '8':
2950 case '9':
2951 {
2952 /* It's a number. */
2953 int got_dot = 0, got_e = 0, toktype;
2954 char *p = tokstart;
2955 int hex = input_radix > 10;
2956
2957 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
2958 {
2959 p += 2;
2960 hex = 1;
2961 }
2962
2963 for (;; ++p)
2964 {
2965 /* This test includes !hex because 'e' is a valid hex digit
2966 and thus does not indicate a floating point number when
2967 the radix is hex. */
2968 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
2969 got_dot = got_e = 1;
2970 /* This test does not include !hex, because a '.' always indicates
2971 a decimal floating point number regardless of the radix. */
2972 else if (!got_dot && *p == '.')
2973 got_dot = 1;
2974 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
2975 && (*p == '-' || *p == '+'))
2976 /* This is the sign of the exponent, not the end of the
2977 number. */
2978 continue;
2979 /* We will take any letters or digits. parse_number will
2980 complain if past the radix, or if L or U are not final. */
2981 else if ((*p < '0' || *p > '9')
2982 && ((*p < 'a' || *p > 'z')
2983 && (*p < 'A' || *p > 'Z')))
2984 break;
2985 }
2986 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
2987 if (toktype == ERROR)
2988 {
2989 char *err_copy = (char *) alloca (p - tokstart + 1);
2990
2991 memcpy (err_copy, tokstart, p - tokstart);
2992 err_copy[p - tokstart] = 0;
2993 error (_("Invalid number \"%s\"."), err_copy);
2994 }
2995 lexptr = p;
2996 return toktype;
2997 }
2998
2999 case '@':
3000 {
3001 char *p = &tokstart[1];
3002 size_t len = strlen ("entry");
3003
3004 while (isspace (*p))
3005 p++;
3006 if (strncmp (p, "entry", len) == 0 && !isalnum (p[len])
3007 && p[len] != '_')
3008 {
3009 lexptr = &p[len];
3010 return ENTRY;
3011 }
3012 }
3013 /* FALLTHRU */
3014 case '+':
3015 case '-':
3016 case '*':
3017 case '/':
3018 case '%':
3019 case '|':
3020 case '&':
3021 case '^':
3022 case '~':
3023 case '!':
3024 case '<':
3025 case '>':
3026 case '?':
3027 case ':':
3028 case '=':
3029 case '{':
3030 case '}':
3031 symbol:
3032 lexptr++;
3033 return c;
3034
3035 case '\'':
3036 case '"':
3037 case '`':
3038 {
3039 int host_len;
3040 int result = parse_string_or_char (tokstart, &lexptr, &yylval.tsval,
3041 &host_len);
3042 if (result == CHAR)
3043 {
3044 if (host_len == 0)
3045 error (_("Empty character constant."));
3046 else if (host_len > 2 && c == '\'')
3047 {
3048 ++tokstart;
3049 namelen = lexptr - tokstart - 1;
3050 goto tryname;
3051 }
3052 else if (host_len > 1)
3053 error (_("Invalid character constant."));
3054 }
3055 return result;
3056 }
3057 }
3058
3059 if (!(c == '_' || c == '$'
3060 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
3061 /* We must have come across a bad character (e.g. ';'). */
3062 error (_("Invalid character '%c' in expression."), c);
3063
3064 /* It's a name. See how long it is. */
3065 namelen = 0;
3066 for (c = tokstart[namelen];
3067 (c == '_' || c == '$' || (c >= '0' && c <= '9')
3068 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));)
3069 {
3070 c = tokstart[++namelen];
3071 }
3072
3073 /* The token "if" terminates the expression and is NOT removed from
3074 the input stream. It doesn't count if it appears in the
3075 expansion of a macro. */
3076 if (namelen == 2
3077 && tokstart[0] == 'i'
3078 && tokstart[1] == 'f')
3079 {
3080 return 0;
3081 }
3082
3083 /* For the same reason (breakpoint conditions), "thread N"
3084 terminates the expression. "thread" could be an identifier, but
3085 an identifier is never followed by a number without intervening
3086 punctuation.
3087 Handle abbreviations of these, similarly to
3088 breakpoint.c:find_condition_and_thread.
3089 TODO: Watch for "goroutine" here? */
3090 if (namelen >= 1
3091 && strncmp (tokstart, "thread", namelen) == 0
3092 && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t'))
3093 {
3094 char *p = tokstart + namelen + 1;
3095 while (*p == ' ' || *p == '\t')
3096 p++;
3097 if (*p >= '0' && *p <= '9')
3098 return 0;
3099 }
3100
3101 lexptr += namelen;
3102
3103 tryname:
3104
3105 yylval.sval.ptr = tokstart;
3106 yylval.sval.length = namelen;
3107
3108 /* Catch specific keywords. */
3109 copy = copy_name (yylval.sval);
3110 for (i = 0; i < sizeof (ident_tokens) / sizeof (ident_tokens[0]); i++)
3111 if (strcmp (copy, ident_tokens[i].operator) == 0)
3112 {
3113 /* It is ok to always set this, even though we don't always
3114 strictly need to. */
3115 yylval.opcode = ident_tokens[i].opcode;
3116 return ident_tokens[i].token;
3117 }
3118
3119 if (*tokstart == '$')
3120 return DOLLAR_VARIABLE;
3121
3122 if (parse_completion && *lexptr == '\0')
3123 saw_name_at_eof = 1;
3124 return NAME;
3125 }
3126
3127 /* An object of this type is pushed on a FIFO by the "outer" lexer. */
3128 typedef struct
3129 {
3130 int token;
3131 YYSTYPE value;
3132 } token_and_value;
3133
3134 DEF_VEC_O (token_and_value);
3135
3136 /* A FIFO of tokens that have been read but not yet returned to the
3137 parser. */
3138 static VEC (token_and_value) *token_fifo;
3139
3140 /* Non-zero if the lexer should return tokens from the FIFO. */
3141 static int popping;
3142
3143 /* Temporary storage for yylex; this holds symbol names as they are
3144 built up. */
3145 static struct obstack name_obstack;
3146
3147 /* Build "package.name" in name_obstack.
3148 For convenience of the caller, the name is NUL-terminated,
3149 but the NUL is not included in the recorded length. */
3150
3151 static struct stoken
3152 build_packaged_name (const char *package, int package_len,
3153 const char *name, int name_len)
3154 {
3155 struct stoken result;
3156
3157 obstack_free (&name_obstack, obstack_base (&name_obstack));
3158 obstack_grow (&name_obstack, package, package_len);
3159 obstack_grow_str (&name_obstack, ".");
3160 obstack_grow (&name_obstack, name, name_len);
3161 obstack_grow (&name_obstack, "", 1);
3162 result.ptr = obstack_base (&name_obstack);
3163 result.length = obstack_object_size (&name_obstack) - 1;
3164
3165 return result;
3166 }
3167
3168 /* Return non-zero if NAME is a package name.
3169 BLOCK is the scope in which to interpret NAME; this can be NULL
3170 to mean the global scope. */
3171
3172 static int
3173 package_name_p (const char *name, const struct block *block)
3174 {
3175 struct symbol *sym;
3176 struct field_of_this_result is_a_field_of_this;
3177
3178 sym = lookup_symbol (name, block, STRUCT_DOMAIN, &is_a_field_of_this);
3179
3180 if (sym
3181 && SYMBOL_CLASS (sym) == LOC_TYPEDEF
3182 && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_MODULE)
3183 return 1;
3184
3185 return 0;
3186 }
3187
3188 /* Classify a (potential) function in the "unsafe" package.
3189 We fold these into "keywords" to keep things simple, at least until
3190 something more complex is warranted. */
3191
3192 static int
3193 classify_unsafe_function (struct stoken function_name)
3194 {
3195 char *copy = copy_name (function_name);
3196
3197 if (strcmp (copy, "Sizeof") == 0)
3198 {
3199 yylval.sval = function_name;
3200 return SIZEOF_KEYWORD;
3201 }
3202
3203 error (_("Unknown function in `unsafe' package: %s"), copy);
3204 }
3205
3206 /* Classify token(s) "name1.name2" where name1 is known to be a package.
3207 The contents of the token are in `yylval'.
3208 Updates yylval and returns the new token type.
3209
3210 The result is one of NAME, NAME_OR_INT, or TYPENAME. */
3211
3212 static int
3213 classify_packaged_name (const struct block *block)
3214 {
3215 char *copy;
3216 struct symbol *sym;
3217 struct field_of_this_result is_a_field_of_this;
3218
3219 copy = copy_name (yylval.sval);
3220
3221 sym = lookup_symbol (copy, block, VAR_DOMAIN, &is_a_field_of_this);
3222
3223 if (sym)
3224 {
3225 yylval.ssym.sym = sym;
3226 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
3227 }
3228
3229 return NAME;
3230 }
3231
3232 /* Classify a NAME token.
3233 The contents of the token are in `yylval'.
3234 Updates yylval and returns the new token type.
3235 BLOCK is the block in which lookups start; this can be NULL
3236 to mean the global scope.
3237
3238 The result is one of NAME, NAME_OR_INT, or TYPENAME. */
3239
3240 static int
3241 classify_name (const struct block *block)
3242 {
3243 struct type *type;
3244 struct symbol *sym;
3245 char *copy;
3246 struct field_of_this_result is_a_field_of_this;
3247
3248 copy = copy_name (yylval.sval);
3249
3250 /* Try primitive types first so they win over bad/weird debug info. */
3251 type = language_lookup_primitive_type_by_name (parse_language,
3252 parse_gdbarch, copy);
3253 if (type != NULL)
3254 {
3255 /* NOTE: We take advantage of the fact that yylval coming in was a
3256 NAME, and that struct ttype is a compatible extension of struct
3257 stoken, so yylval.tsym.stoken is already filled in. */
3258 yylval.tsym.type = type;
3259 return TYPENAME;
3260 }
3261
3262 /* TODO: What about other types? */
3263
3264 sym = lookup_symbol (copy, block, VAR_DOMAIN, &is_a_field_of_this);
3265
3266 if (sym)
3267 {
3268 yylval.ssym.sym = sym;
3269 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
3270 return NAME;
3271 }
3272
3273 /* If we didn't find a symbol, look again in the current package.
3274 This is to, e.g., make "p global_var" work without having to specify
3275 the package name. We intentionally only looks for objects in the
3276 current package. */
3277
3278 {
3279 char *current_package_name = go_block_package_name (block);
3280
3281 if (current_package_name != NULL)
3282 {
3283 struct stoken sval =
3284 build_packaged_name (current_package_name,
3285 strlen (current_package_name),
3286 copy, strlen (copy));
3287
3288 xfree (current_package_name);
3289 sym = lookup_symbol (sval.ptr, block, VAR_DOMAIN,
3290 &is_a_field_of_this);
3291 if (sym)
3292 {
3293 yylval.ssym.stoken = sval;
3294 yylval.ssym.sym = sym;
3295 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
3296 return NAME;
3297 }
3298 }
3299 }
3300
3301 /* Input names that aren't symbols but ARE valid hex numbers, when
3302 the input radix permits them, can be names or numbers depending
3303 on the parse. Note we support radixes > 16 here. */
3304 if ((copy[0] >= 'a' && copy[0] < 'a' + input_radix - 10)
3305 || (copy[0] >= 'A' && copy[0] < 'A' + input_radix - 10))
3306 {
3307 YYSTYPE newlval; /* Its value is ignored. */
3308 int hextype = parse_number (copy, yylval.sval.length, 0, &newlval);
3309 if (hextype == INT)
3310 {
3311 yylval.ssym.sym = NULL;
3312 yylval.ssym.is_a_field_of_this = 0;
3313 return NAME_OR_INT;
3314 }
3315 }
3316
3317 yylval.ssym.sym = NULL;
3318 yylval.ssym.is_a_field_of_this = 0;
3319 return NAME;
3320 }
3321
3322 /* This is taken from c-exp.y mostly to get something working.
3323 The basic structure has been kept because we may yet need some of it. */
3324
3325 static int
3326 yylex (void)
3327 {
3328 token_and_value current, next;
3329
3330 if (popping && !VEC_empty (token_and_value, token_fifo))
3331 {
3332 token_and_value tv = *VEC_index (token_and_value, token_fifo, 0);
3333 VEC_ordered_remove (token_and_value, token_fifo, 0);
3334 yylval = tv.value;
3335 /* There's no need to fall through to handle package.name
3336 as that can never happen here. In theory. */
3337 return tv.token;
3338 }
3339 popping = 0;
3340
3341 current.token = lex_one_token ();
3342
3343 /* TODO: Need a way to force specifying name1 as a package.
3344 .name1.name2 ? */
3345
3346 if (current.token != NAME)
3347 return current.token;
3348
3349 /* See if we have "name1 . name2". */
3350
3351 current.value = yylval;
3352 next.token = lex_one_token ();
3353 next.value = yylval;
3354
3355 if (next.token == '.')
3356 {
3357 token_and_value name2;
3358
3359 name2.token = lex_one_token ();
3360 name2.value = yylval;
3361
3362 if (name2.token == NAME)
3363 {
3364 /* Ok, we have "name1 . name2". */
3365 char *copy;
3366
3367 copy = copy_name (current.value.sval);
3368
3369 if (strcmp (copy, "unsafe") == 0)
3370 {
3371 popping = 1;
3372 return classify_unsafe_function (name2.value.sval);
3373 }
3374
3375 if (package_name_p (copy, expression_context_block))
3376 {
3377 popping = 1;
3378 yylval.sval = build_packaged_name (current.value.sval.ptr,
3379 current.value.sval.length,
3380 name2.value.sval.ptr,
3381 name2.value.sval.length);
3382 return classify_packaged_name (expression_context_block);
3383 }
3384 }
3385
3386 VEC_safe_push (token_and_value, token_fifo, &next);
3387 VEC_safe_push (token_and_value, token_fifo, &name2);
3388 }
3389 else
3390 {
3391 VEC_safe_push (token_and_value, token_fifo, &next);
3392 }
3393
3394 /* If we arrive here we don't have a package-qualified name. */
3395
3396 popping = 1;
3397 yylval = current.value;
3398 return classify_name (expression_context_block);
3399 }
3400
3401 int
3402 go_parse (void)
3403 {
3404 int result;
3405 struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
3406
3407 make_cleanup_restore_integer (&yydebug);
3408 yydebug = parser_debug;
3409
3410 /* Initialize some state used by the lexer. */
3411 last_was_structop = 0;
3412 saw_name_at_eof = 0;
3413
3414 VEC_free (token_and_value, token_fifo);
3415 popping = 0;
3416 obstack_init (&name_obstack);
3417 make_cleanup_obstack_free (&name_obstack);
3418
3419 result = yyparse ();
3420 do_cleanups (back_to);
3421 return result;
3422 }
3423
3424 void
3425 yyerror (char *msg)
3426 {
3427 if (prev_lexptr)
3428 lexptr = prev_lexptr;
3429
3430 error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr);
3431 }
3432
DragonFly BSD