projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] Add micromips support to the MIPS simulator
[deliverable/binutils-gdb.git] / gdb / d-exp.y
CommitLineData
3ed9baed
IB		 1/* YACC parser for D expressions, for GDB.
2
32d0add0 3 Copyright (C) 2014-2015 Free Software Foundation, Inc.
3ed9baed
IB		 4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20/* This file is derived from c-exp.y, jv-exp.y. */
21
22/* Parse a D expression from text in a string,
23 and return the result as a struct expression pointer.
24 That structure contains arithmetic operations in reverse polish,
25 with constants represented by operations that are followed by special data.
26 See expression.h for the details of the format.
27 What is important here is that it can be built up sequentially
28 during the process of parsing; the lower levels of the tree always
29 come first in the result.
30
31 Note that malloc's and realloc's in this file are transformed to
32 xmalloc and xrealloc respectively by the same sed command in the
33 makefile that remaps any other malloc/realloc inserted by the parser
34 generator. Doing this with #defines and trying to control the interaction
35 with include files (<malloc.h> and <stdlib.h> for example) just became
36 too messy, particularly when such includes can be inserted at random
37 times by the parser generator. */
38
39%{
40
41#include "defs.h"
3ed9baed
IB		 42#include <ctype.h>
43#include "expression.h"
44#include "value.h"
45#include "parser-defs.h"
46#include "language.h"
47#include "c-lang.h"
48#include "d-lang.h"
49#include "bfd.h" /* Required by objfiles.h. */
50#include "symfile.h" /* Required by objfiles.h. */
51#include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
52#include "charset.h"
53#include "block.h"
54
55#define parse_type(ps) builtin_type (parse_gdbarch (ps))
56#define parse_d_type(ps) builtin_d_type (parse_gdbarch (ps))
57
58/* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
59 as well as gratuitiously global symbol names, so we can have multiple
60 yacc generated parsers in gdb. Note that these are only the variables
61 produced by yacc. If other parser generators (bison, byacc, etc) produce
62 additional global names that conflict at link time, then those parser
63 generators need to be fixed instead of adding those names to this list. */
64
65#define yymaxdepth d_maxdepth
66#define yyparse d_parse_internal
67#define yylex d_lex
68#define yyerror d_error
69#define yylval d_lval
70#define yychar d_char
71#define yydebug d_debug
72#define yypact d_pact
73#define yyr1 d_r1
74#define yyr2 d_r2
75#define yydef d_def
76#define yychk d_chk
77#define yypgo d_pgo
78#define yyact d_act
79#define yyexca d_exca
80#define yyerrflag d_errflag
81#define yynerrs d_nerrs
82#define yyps d_ps
83#define yypv d_pv
84#define yys d_s
85#define yy_yys d_yys
86#define yystate d_state
87#define yytmp d_tmp
88#define yyv d_v
89#define yy_yyv d_yyv
90#define yyval d_val
91#define yylloc d_lloc
92#define yyreds d_reds /* With YYDEBUG defined */
93#define yytoks d_toks /* With YYDEBUG defined */
94#define yyname d_name /* With YYDEBUG defined */
95#define yyrule d_rule /* With YYDEBUG defined */
96#define yylhs d_yylhs
97#define yylen d_yylen
98#define yydefre d_yydefred
99#define yydgoto d_yydgoto
100#define yysindex d_yysindex
101#define yyrindex d_yyrindex
102#define yygindex d_yygindex
103#define yytable d_yytable
104#define yycheck d_yycheck
105#define yyss d_yyss
106#define yysslim d_yysslim
107#define yyssp d_yyssp
108#define yystacksize d_yystacksize
109#define yyvs d_yyvs
110#define yyvsp d_yyvsp
111
112#ifndef YYDEBUG
113#define YYDEBUG 1 /* Default to yydebug support */
114#endif
115
116#define YYFPRINTF parser_fprintf
117
118/* The state of the parser, used internally when we are parsing the
119 expression. */
120
121static struct parser_state *pstate = NULL;
122
123int yyparse (void);
124
125static int yylex (void);
126
127void yyerror (char *);
128
7f3706eb
IB		 129static int type_aggregate_p (struct type *);
130
3ed9baed
IB		 131%}
132
133/* Although the yacc "value" of an expression is not used,
134 since the result is stored in the structure being created,
135 other node types do have values. */
136
137%union
138 {
139 struct {
140 LONGEST val;
141 struct type *type;
142 } typed_val_int;
143 struct {
144 DOUBLEST dval;
145 struct type *type;
146 } typed_val_float;
147 struct symbol *sym;
148 struct type *tval;
149 struct typed_stoken tsval;
150 struct stoken sval;
151 struct ttype tsym;
152 struct symtoken ssym;
153 int ival;
444c1ed8 154 int voidval;
3ed9baed
IB		 155 struct block *bval;
156 enum exp_opcode opcode;
157 struct stoken_vector svec;
158 }
159
160%{
161/* YYSTYPE gets defined by %union */
162static int parse_number (struct parser_state *, const char *,
163 int, int, YYSTYPE *);
3ed9baed
IB		 164%}
165
444c1ed8 166%token <sval> IDENTIFIER UNKNOWN_NAME
3ed9baed
IB		 167%token <tsym> TYPENAME
168%token <voidval> COMPLETE
169
170/* A NAME_OR_INT is a symbol which is not known in the symbol table,
171 but which would parse as a valid number in the current input radix.
172 E.g. "c" when input_radix==16. Depending on the parse, it will be
173 turned into a name or into a number. */
174
175%token <sval> NAME_OR_INT
176
177%token <typed_val_int> INTEGER_LITERAL
178%token <typed_val_float> FLOAT_LITERAL
179%token <tsval> CHARACTER_LITERAL
180%token <tsval> STRING_LITERAL
181
182%type <svec> StringExp
183%type <tval> BasicType TypeExp
184%type <sval> IdentifierExp
185%type <ival> ArrayLiteral
186
187%token ENTRY
188%token ERROR
189
190/* Keywords that have a constant value. */
191%token TRUE_KEYWORD FALSE_KEYWORD NULL_KEYWORD
192/* Class 'super' accessor. */
193%token SUPER_KEYWORD
194/* Properties. */
195%token CAST_KEYWORD SIZEOF_KEYWORD
196%token TYPEOF_KEYWORD TYPEID_KEYWORD
197%token INIT_KEYWORD
198/* Comparison keywords. */
199/* Type storage classes. */
200%token IMMUTABLE_KEYWORD CONST_KEYWORD SHARED_KEYWORD
201/* Non-scalar type keywords. */
202%token STRUCT_KEYWORD UNION_KEYWORD
203%token CLASS_KEYWORD INTERFACE_KEYWORD
204%token ENUM_KEYWORD TEMPLATE_KEYWORD
205%token DELEGATE_KEYWORD FUNCTION_KEYWORD
206
207%token <sval> DOLLAR_VARIABLE
208
209%token <opcode> ASSIGN_MODIFY
210
211%left ','
212%right '=' ASSIGN_MODIFY
213%right '?'
214%left OROR
215%left ANDAND
216%left '|'
217%left '^'
218%left '&'
219%left EQUAL NOTEQUAL '<' '>' LEQ GEQ
220%right LSH RSH
221%left '+' '-'
222%left '*' '/' '%'
223%right HATHAT
224%left IDENTITY NOTIDENTITY
225%right INCREMENT DECREMENT
226%right '.' '[' '('
227%token DOTDOT
228
229\f
230%%
231
232start :
233 Expression
234| TypeExp
235;
236
237/* Expressions, including the comma operator. */
238
239Expression:
240 CommaExpression
241;
242
243CommaExpression:
244 AssignExpression
245| AssignExpression ',' CommaExpression
246 { write_exp_elt_opcode (pstate, BINOP_COMMA); }
247;
248
249AssignExpression:
250 ConditionalExpression
251| ConditionalExpression '=' AssignExpression
252 { write_exp_elt_opcode (pstate, BINOP_ASSIGN); }
253| ConditionalExpression ASSIGN_MODIFY AssignExpression
254 { write_exp_elt_opcode (pstate, BINOP_ASSIGN_MODIFY);
255 write_exp_elt_opcode (pstate, $2);
256 write_exp_elt_opcode (pstate, BINOP_ASSIGN_MODIFY); }
257;
258
259ConditionalExpression:
260 OrOrExpression
261| OrOrExpression '?' Expression ':' ConditionalExpression
262 { write_exp_elt_opcode (pstate, TERNOP_COND); }
263;
264
265OrOrExpression:
266 AndAndExpression
267| OrOrExpression OROR AndAndExpression
268 { write_exp_elt_opcode (pstate, BINOP_LOGICAL_OR); }
269;
270
271AndAndExpression:
272 OrExpression
273| AndAndExpression ANDAND OrExpression
274 { write_exp_elt_opcode (pstate, BINOP_LOGICAL_AND); }
275;
276
277OrExpression:
278 XorExpression
279| OrExpression '|' XorExpression
280 { write_exp_elt_opcode (pstate, BINOP_BITWISE_IOR); }
281;
282
283XorExpression:
284 AndExpression
285| XorExpression '^' AndExpression
286 { write_exp_elt_opcode (pstate, BINOP_BITWISE_XOR); }
287;
288
289AndExpression:
290 CmpExpression
291| AndExpression '&' CmpExpression
292 { write_exp_elt_opcode (pstate, BINOP_BITWISE_AND); }
293;
294
295CmpExpression:
296 ShiftExpression
297| EqualExpression
298| IdentityExpression
299| RelExpression
300;
301
302EqualExpression:
303 ShiftExpression EQUAL ShiftExpression
304 { write_exp_elt_opcode (pstate, BINOP_EQUAL); }
305| ShiftExpression NOTEQUAL ShiftExpression
306 { write_exp_elt_opcode (pstate, BINOP_NOTEQUAL); }
307;
308
309IdentityExpression:
310 ShiftExpression IDENTITY ShiftExpression
311 { write_exp_elt_opcode (pstate, BINOP_EQUAL); }
312| ShiftExpression NOTIDENTITY ShiftExpression
313 { write_exp_elt_opcode (pstate, BINOP_NOTEQUAL); }
314;
315
316RelExpression:
317 ShiftExpression '<' ShiftExpression
318 { write_exp_elt_opcode (pstate, BINOP_LESS); }
319| ShiftExpression LEQ ShiftExpression
320 { write_exp_elt_opcode (pstate, BINOP_LEQ); }
321| ShiftExpression '>' ShiftExpression
322 { write_exp_elt_opcode (pstate, BINOP_GTR); }
323| ShiftExpression GEQ ShiftExpression
324 { write_exp_elt_opcode (pstate, BINOP_GEQ); }
325;
326
327ShiftExpression:
328 AddExpression
329| ShiftExpression LSH AddExpression
330 { write_exp_elt_opcode (pstate, BINOP_LSH); }
331| ShiftExpression RSH AddExpression
332 { write_exp_elt_opcode (pstate, BINOP_RSH); }
333;
334
335AddExpression:
336 MulExpression
337| AddExpression '+' MulExpression
338 { write_exp_elt_opcode (pstate, BINOP_ADD); }
339| AddExpression '-' MulExpression
340 { write_exp_elt_opcode (pstate, BINOP_SUB); }
341| AddExpression '~' MulExpression
342 { write_exp_elt_opcode (pstate, BINOP_CONCAT); }
343;
344
345MulExpression:
346 UnaryExpression
347| MulExpression '*' UnaryExpression
348 { write_exp_elt_opcode (pstate, BINOP_MUL); }
349| MulExpression '/' UnaryExpression
350 { write_exp_elt_opcode (pstate, BINOP_DIV); }
351| MulExpression '%' UnaryExpression
352 { write_exp_elt_opcode (pstate, BINOP_REM); }
353
354UnaryExpression:
355 '&' UnaryExpression
356 { write_exp_elt_opcode (pstate, UNOP_ADDR); }
357| INCREMENT UnaryExpression
358 { write_exp_elt_opcode (pstate, UNOP_PREINCREMENT); }
359| DECREMENT UnaryExpression
360 { write_exp_elt_opcode (pstate, UNOP_PREDECREMENT); }
361| '*' UnaryExpression
362 { write_exp_elt_opcode (pstate, UNOP_IND); }
363| '-' UnaryExpression
364 { write_exp_elt_opcode (pstate, UNOP_NEG); }
365| '+' UnaryExpression
366 { write_exp_elt_opcode (pstate, UNOP_PLUS); }
367| '!' UnaryExpression
368 { write_exp_elt_opcode (pstate, UNOP_LOGICAL_NOT); }
369| '~' UnaryExpression
370 { write_exp_elt_opcode (pstate, UNOP_COMPLEMENT); }
371| CastExpression
372| PowExpression
373;
374
375CastExpression:
376 CAST_KEYWORD '(' TypeExp ')' UnaryExpression
377 { write_exp_elt_opcode (pstate, UNOP_CAST);
378 write_exp_elt_type (pstate, $3);
379 write_exp_elt_opcode (pstate, UNOP_CAST); }
380 /* C style cast is illegal D, but is still recognised in
381 the grammar, so we keep this around for convenience. */
382| '(' TypeExp ')' UnaryExpression
383 { write_exp_elt_opcode (pstate, UNOP_CAST);
384 write_exp_elt_type (pstate, $2);
385 write_exp_elt_opcode (pstate, UNOP_CAST); }
386;
387
388PowExpression:
389 PostfixExpression
390| PostfixExpression HATHAT UnaryExpression
391 { write_exp_elt_opcode (pstate, BINOP_EXP); }
392;
393
394PostfixExpression:
395 PrimaryExpression
444c1ed8
IB		 396| PostfixExpression '.' COMPLETE
397 { struct stoken s;
398 mark_struct_expression (pstate);
399 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
400 s.ptr = "";
401 s.length = 0;
402 write_exp_string (pstate, s);
403 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
404| PostfixExpression '.' IDENTIFIER
405 { write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
406 write_exp_string (pstate, $3);
407 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
408| PostfixExpression '.' IDENTIFIER COMPLETE
409 { mark_struct_expression (pstate);
410 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
411 write_exp_string (pstate, $3);
412 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
3ed9baed
IB		 413| PostfixExpression INCREMENT
414 { write_exp_elt_opcode (pstate, UNOP_POSTINCREMENT); }
415| PostfixExpression DECREMENT
416 { write_exp_elt_opcode (pstate, UNOP_POSTDECREMENT); }
417| CallExpression
418| IndexExpression
419| SliceExpression
420;
421
422ArgumentList:
423 AssignExpression
424 { arglist_len = 1; }
425| ArgumentList ',' AssignExpression
426 { arglist_len++; }
427;
428
429ArgumentList_opt:
430 /* EMPTY */
431 { arglist_len = 0; }
432| ArgumentList
433;
434
435CallExpression:
436 PostfixExpression '('
437 { start_arglist (); }
438 ArgumentList_opt ')'
439 { write_exp_elt_opcode (pstate, OP_FUNCALL);
440 write_exp_elt_longcst (pstate, (LONGEST) end_arglist ());
441 write_exp_elt_opcode (pstate, OP_FUNCALL); }
442;
443
444IndexExpression:
445 PostfixExpression '[' ArgumentList ']'
446 { if (arglist_len > 0)
447 {
448 write_exp_elt_opcode (pstate, MULTI_SUBSCRIPT);
449 write_exp_elt_longcst (pstate, (LONGEST) arglist_len);
450 write_exp_elt_opcode (pstate, MULTI_SUBSCRIPT);
451 }
452 else
453 write_exp_elt_opcode (pstate, BINOP_SUBSCRIPT);
454 }
455;
456
457SliceExpression:
458 PostfixExpression '[' ']'
459 { /* Do nothing. */ }
460| PostfixExpression '[' AssignExpression DOTDOT AssignExpression ']'
461 { write_exp_elt_opcode (pstate, TERNOP_SLICE); }
462;
463
464PrimaryExpression:
465 '(' Expression ')'
466 { /* Do nothing. */ }
467| IdentifierExp
444c1ed8
IB		 468 { struct bound_minimal_symbol msymbol;
469 char *copy = copy_name ($1);
470 struct field_of_this_result is_a_field_of_this;
471 struct block_symbol sym;
472
473 /* Handle VAR, which could be local or global. */
474 sym = lookup_symbol (copy, expression_context_block, VAR_DOMAIN,
475 &is_a_field_of_this);
476 if (sym.symbol && SYMBOL_CLASS (sym.symbol) != LOC_TYPEDEF)
477 {
478 if (symbol_read_needs_frame (sym.symbol))
479 {
c0fe2ae7
IB		 480 if (innermost_block == 0
481 || contained_in (sym.block, innermost_block))
444c1ed8
IB		 482 innermost_block = sym.block;
483 }
484
485 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
486 /* We want to use the selected frame, not another more inner frame
487 which happens to be in the same block. */
488 write_exp_elt_block (pstate, NULL);
489 write_exp_elt_sym (pstate, sym.symbol);
490 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
491 }
492 else if (is_a_field_of_this.type != NULL)
493 {
494 /* It hangs off of `this'. Must not inadvertently convert from a
495 method call to data ref. */
c0fe2ae7
IB		 496 if (innermost_block == 0
497 || contained_in (sym.block, innermost_block))
444c1ed8
IB		 498 innermost_block = sym.block;
499 write_exp_elt_opcode (pstate, OP_THIS);
500 write_exp_elt_opcode (pstate, OP_THIS);
501 write_exp_elt_opcode (pstate, STRUCTOP_PTR);
502 write_exp_string (pstate, $1);
503 write_exp_elt_opcode (pstate, STRUCTOP_PTR);
504 }
505 else
506 {
507 /* Lookup foreign name in global static symbols. */
508 msymbol = lookup_bound_minimal_symbol (copy);
509 if (msymbol.minsym != NULL)
510 write_exp_msymbol (pstate, msymbol);
511 else if (!have_full_symbols () && !have_partial_symbols ())
512 error (_("No symbol table is loaded. Use the \"file\" command"));
513 else
514 error (_("No symbol \"%s\" in current context."), copy);
515 }
516 }
517| TypeExp '.' IdentifierExp
518 { struct type *type = check_typedef ($1);
519
520 /* Check if the qualified name is in the global
521 context. However if the symbol has not already
522 been resolved, it's not likely to be found. */
523 if (TYPE_CODE (type) == TYPE_CODE_MODULE)
524 {
525 struct bound_minimal_symbol msymbol;
526 struct block_symbol sym;
b56ccc20
KS		 527 const char *type_name = TYPE_SAFE_NAME (type);
528 int type_name_len = strlen (type_name);
c0fe2ae7 529 char *name;
444c1ed8 530
c0fe2ae7 531 name = xstrprintf ("%.*s.%.*s",
b56ccc20 532 type_name_len, type_name,
c0fe2ae7
IB		 533 $3.length, $3.ptr);
534 make_cleanup (xfree, name);
444c1ed8
IB		 535
536 sym =
537 lookup_symbol (name, (const struct block *) NULL,
538 VAR_DOMAIN, NULL);
539 if (sym.symbol)
540 {
541 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
542 write_exp_elt_block (pstate, sym.block);
543 write_exp_elt_sym (pstate, sym.symbol);
544 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
545 break;
546 }
547
548 msymbol = lookup_bound_minimal_symbol (name);
549 if (msymbol.minsym != NULL)
550 write_exp_msymbol (pstate, msymbol);
551 else if (!have_full_symbols () && !have_partial_symbols ())
552 error (_("No symbol table is loaded. Use the \"file\" command."));
553 else
554 error (_("No symbol \"%s\" in current context."), name);
555 }
556
557 /* Check if the qualified name resolves as a member
558 of an aggregate or an enum type. */
7f3706eb 559 if (!type_aggregate_p (type))
444c1ed8
IB		 560 error (_("`%s' is not defined as an aggregate type."),
561 TYPE_SAFE_NAME (type));
562
563 write_exp_elt_opcode (pstate, OP_SCOPE);
564 write_exp_elt_type (pstate, type);
565 write_exp_string (pstate, $3);
566 write_exp_elt_opcode (pstate, OP_SCOPE);
567 }
3ed9baed
IB		 568| DOLLAR_VARIABLE
569 { write_dollar_variable (pstate, $1); }
570| NAME_OR_INT
571 { YYSTYPE val;
572 parse_number (pstate, $1.ptr, $1.length, 0, &val);
573 write_exp_elt_opcode (pstate, OP_LONG);
574 write_exp_elt_type (pstate, val.typed_val_int.type);
575 write_exp_elt_longcst (pstate,
576 (LONGEST) val.typed_val_int.val);
577 write_exp_elt_opcode (pstate, OP_LONG); }
578| NULL_KEYWORD
579 { struct type *type = parse_d_type (pstate)->builtin_void;
580 type = lookup_pointer_type (type);
581 write_exp_elt_opcode (pstate, OP_LONG);
582 write_exp_elt_type (pstate, type);
583 write_exp_elt_longcst (pstate, (LONGEST) 0);
584 write_exp_elt_opcode (pstate, OP_LONG); }
585| TRUE_KEYWORD
586 { write_exp_elt_opcode (pstate, OP_BOOL);
587 write_exp_elt_longcst (pstate, (LONGEST) 1);
588 write_exp_elt_opcode (pstate, OP_BOOL); }
589| FALSE_KEYWORD
590 { write_exp_elt_opcode (pstate, OP_BOOL);
591 write_exp_elt_longcst (pstate, (LONGEST) 0);
592 write_exp_elt_opcode (pstate, OP_BOOL); }
593| INTEGER_LITERAL
594 { write_exp_elt_opcode (pstate, OP_LONG);
595 write_exp_elt_type (pstate, $1.type);
596 write_exp_elt_longcst (pstate, (LONGEST)($1.val));
597 write_exp_elt_opcode (pstate, OP_LONG); }
598| FLOAT_LITERAL
599 { write_exp_elt_opcode (pstate, OP_DOUBLE);
600 write_exp_elt_type (pstate, $1.type);
601 write_exp_elt_dblcst (pstate, $1.dval);
602 write_exp_elt_opcode (pstate, OP_DOUBLE); }
603| CHARACTER_LITERAL
604 { struct stoken_vector vec;
605 vec.len = 1;
606 vec.tokens = &$1;
607 write_exp_string_vector (pstate, $1.type, &vec); }
608| StringExp
609 { int i;
610 write_exp_string_vector (pstate, 0, &$1);
611 for (i = 0; i < $1.len; ++i)
612 free ($1.tokens[i].ptr);
613 free ($1.tokens); }
614| ArrayLiteral
615 { write_exp_elt_opcode (pstate, OP_ARRAY);
616 write_exp_elt_longcst (pstate, (LONGEST) 0);
617 write_exp_elt_longcst (pstate, (LONGEST) $1 - 1);
618 write_exp_elt_opcode (pstate, OP_ARRAY); }
619;
620
621ArrayLiteral:
622 '[' ArgumentList_opt ']'
623 { $$ = arglist_len; }
624;
625
626IdentifierExp:
627 IDENTIFIER
3ed9baed
IB		 628;
629
630StringExp:
631 STRING_LITERAL
632 { /* We copy the string here, and not in the
633 lexer, to guarantee that we do not leak a
634 string. Note that we follow the
635 NUL-termination convention of the
636 lexer. */
637 struct typed_stoken *vec = XNEW (struct typed_stoken);
638 $$.len = 1;
639 $$.tokens = vec;
640
641 vec->type = $1.type;
642 vec->length = $1.length;
643 vec->ptr = malloc ($1.length + 1);
644 memcpy (vec->ptr, $1.ptr, $1.length + 1);
645 }
646| StringExp STRING_LITERAL
647 { /* Note that we NUL-terminate here, but just
648 for convenience. */
649 char *p;
650 ++$$.len;
651 $$.tokens = realloc ($$.tokens,
652 $$.len * sizeof (struct typed_stoken));
653
654 p = malloc ($2.length + 1);
655 memcpy (p, $2.ptr, $2.length + 1);
656
657 $$.tokens[$$.len - 1].type = $2.type;
658 $$.tokens[$$.len - 1].length = $2.length;
659 $$.tokens[$$.len - 1].ptr = p;
660 }
661;
662
663TypeExp:
444c1ed8
IB		 664 '(' TypeExp ')'
665 { /* Do nothing. */ }
666| BasicType
3ed9baed
IB		 667 { write_exp_elt_opcode (pstate, OP_TYPE);
668 write_exp_elt_type (pstate, $1);
669 write_exp_elt_opcode (pstate, OP_TYPE); }
670| BasicType BasicType2
671 { $$ = follow_types ($1);
672 write_exp_elt_opcode (pstate, OP_TYPE);
673 write_exp_elt_type (pstate, $$);
674 write_exp_elt_opcode (pstate, OP_TYPE);
675 }
676;
677
678BasicType2:
679 '*'
680 { push_type (tp_pointer); }
681| '*' BasicType2
682 { push_type (tp_pointer); }
683| '[' INTEGER_LITERAL ']'
684 { push_type_int ($2.val);
685 push_type (tp_array); }
686| '[' INTEGER_LITERAL ']' BasicType2
687 { push_type_int ($2.val);
688 push_type (tp_array); }
689;
690
691BasicType:
692 TYPENAME
693 { $$ = $1.type; }
3ed9baed
IB		 694;
695
696%%
697
7f3706eb
IB		 698/* Return true if the type is aggregate-like. */
699
700static int
701type_aggregate_p (struct type *type)
702{
703 return (TYPE_CODE (type) == TYPE_CODE_STRUCT
704 || TYPE_CODE (type) == TYPE_CODE_UNION
705 || (TYPE_CODE (type) == TYPE_CODE_ENUM
706 && TYPE_DECLARED_CLASS (type)));
707}
708
3ed9baed
IB		 709/* Take care of parsing a number (anything that starts with a digit).
710 Set yylval and return the token type; update lexptr.
711 LEN is the number of characters in it. */
712
713/*** Needs some error checking for the float case ***/
714
715static int
716parse_number (struct parser_state *ps, const char *p,
717 int len, int parsed_float, YYSTYPE *putithere)
718{
719 ULONGEST n = 0;
720 ULONGEST prevn = 0;
721 ULONGEST un;
722
723 int i = 0;
724 int c;
725 int base = input_radix;
726 int unsigned_p = 0;
727 int long_p = 0;
728
729 /* We have found a "L" or "U" suffix. */
730 int found_suffix = 0;
731
732 ULONGEST high_bit;
733 struct type *signed_type;
734 struct type *unsigned_type;
735
736 if (parsed_float)
737 {
738 const struct builtin_d_type *builtin_d_types;
739 const char *suffix;
740 int suffix_len;
741 char *s, *sp;
742
743 /* Strip out all embedded '_' before passing to parse_float. */
744 s = (char *) alloca (len + 1);
745 sp = s;
746 while (len-- > 0)
747 {
748 if (*p != '_')
749 *sp++ = *p;
750 p++;
751 }
752 *sp = '\0';
753 len = strlen (s);
754
755 if (! parse_float (s, len, &putithere->typed_val_float.dval, &suffix))
756 return ERROR;
757
758 suffix_len = s + len - suffix;
759
760 if (suffix_len == 0)
761 {
762 putithere->typed_val_float.type
763 = parse_d_type (ps)->builtin_double;
764 }
765 else if (suffix_len == 1)
766 {
767 /* Check suffix for `f', `l', or `i' (float, real, or idouble). */
768 if (tolower (*suffix) == 'f')
769 {
770 putithere->typed_val_float.type
771 = parse_d_type (ps)->builtin_float;
772 }
773 else if (tolower (*suffix) == 'l')
774 {
775 putithere->typed_val_float.type
776 = parse_d_type (ps)->builtin_real;
777 }
778 else if (tolower (*suffix) == 'i')
779 {
780 putithere->typed_val_float.type
781 = parse_d_type (ps)->builtin_idouble;
782 }
783 else
784 return ERROR;
785 }
786 else if (suffix_len == 2)
787 {
788 /* Check suffix for `fi' or `li' (ifloat or ireal). */
789 if (tolower (suffix[0]) == 'f' && tolower (suffix[1] == 'i'))
790 {
791 putithere->typed_val_float.type
792 = parse_d_type (ps)->builtin_ifloat;
793 }
794 else if (tolower (suffix[0]) == 'l' && tolower (suffix[1] == 'i'))
795 {
796 putithere->typed_val_float.type
797 = parse_d_type (ps)->builtin_ireal;
798 }
799 else
800 return ERROR;
801 }
802 else
803 return ERROR;
804
805 return FLOAT_LITERAL;
806 }
807
808 /* Handle base-switching prefixes 0x, 0b, 0 */
809 if (p[0] == '0')
810 switch (p[1])
811 {
812 case 'x':
813 case 'X':
814 if (len >= 3)
815 {
816 p += 2;
817 base = 16;
818 len -= 2;
819 }
820 break;
821
822 case 'b':
823 case 'B':
824 if (len >= 3)
825 {
826 p += 2;
827 base = 2;
828 len -= 2;
829 }
830 break;
831
832 default:
833 base = 8;
834 break;
835 }
836
837 while (len-- > 0)
838 {
839 c = *p++;
840 if (c == '_')
841 continue; /* Ignore embedded '_'. */
842 if (c >= 'A' && c <= 'Z')
843 c += 'a' - 'A';
844 if (c != 'l' && c != 'u')
845 n *= base;
846 if (c >= '0' && c <= '9')
847 {
848 if (found_suffix)
849 return ERROR;
850 n += i = c - '0';
851 }
852 else
853 {
854 if (base > 10 && c >= 'a' && c <= 'f')
855 {
856 if (found_suffix)
857 return ERROR;
858 n += i = c - 'a' + 10;
859 }
860 else if (c == 'l' && long_p == 0)
861 {
862 long_p = 1;
863 found_suffix = 1;
864 }
865 else if (c == 'u' && unsigned_p == 0)
866 {
867 unsigned_p = 1;
868 found_suffix = 1;
869 }
870 else
871 return ERROR; /* Char not a digit */
872 }
873 if (i >= base)
874 return ERROR; /* Invalid digit in this base. */
875 /* Portably test for integer overflow. */
876 if (c != 'l' && c != 'u')
877 {
878 ULONGEST n2 = prevn * base;
879 if ((n2 / base != prevn) || (n2 + i < prevn))
880 error (_("Numeric constant too large."));
881 }
882 prevn = n;
883 }
884
885 /* An integer constant is an int or a long. An L suffix forces it to
886 be long, and a U suffix forces it to be unsigned. To figure out
887 whether it fits, we shift it right and see whether anything remains.
888 Note that we can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or
889 more in one operation, because many compilers will warn about such a
890 shift (which always produces a zero result). To deal with the case
891 where it is we just always shift the value more than once, with fewer
892 bits each time. */
893 un = (ULONGEST) n >> 2;
894 if (long_p == 0 && (un >> 30) == 0)
895 {
896 high_bit = ((ULONGEST) 1) << 31;
897 signed_type = parse_d_type (ps)->builtin_int;
898 /* For decimal notation, keep the sign of the worked out type. */
899 if (base == 10 && !unsigned_p)
900 unsigned_type = parse_d_type (ps)->builtin_long;
901 else
902 unsigned_type = parse_d_type (ps)->builtin_uint;
903 }
904 else
905 {
906 int shift;
907 if (sizeof (ULONGEST) * HOST_CHAR_BIT < 64)
908 /* A long long does not fit in a LONGEST. */
909 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
910 else
911 shift = 63;
912 high_bit = (ULONGEST) 1 << shift;
913 signed_type = parse_d_type (ps)->builtin_long;
914 unsigned_type = parse_d_type (ps)->builtin_ulong;
915 }
916
917 putithere->typed_val_int.val = n;
918
919 /* If the high bit of the worked out type is set then this number
920 has to be unsigned_type. */
921 if (unsigned_p || (n & high_bit))
922 putithere->typed_val_int.type = unsigned_type;
923 else
924 putithere->typed_val_int.type = signed_type;
925
926 return INTEGER_LITERAL;
927}
928
929/* Temporary obstack used for holding strings. */
930static struct obstack tempbuf;
931static int tempbuf_init;
932
933/* Parse a string or character literal from TOKPTR. The string or
934 character may be wide or unicode. *OUTPTR is set to just after the
935 end of the literal in the input string. The resulting token is
936 stored in VALUE. This returns a token value, either STRING or
937 CHAR, depending on what was parsed. *HOST_CHARS is set to the
938 number of host characters in the literal. */
939
940static int
941parse_string_or_char (const char *tokptr, const char **outptr,
942 struct typed_stoken *value, int *host_chars)
943{
944 int quote;
945
946 /* Build the gdb internal form of the input string in tempbuf. Note
947 that the buffer is null byte terminated *only* for the
948 convenience of debugging gdb itself and printing the buffer
949 contents when the buffer contains no embedded nulls. Gdb does
950 not depend upon the buffer being null byte terminated, it uses
951 the length string instead. This allows gdb to handle C strings
952 (as well as strings in other languages) with embedded null
953 bytes */
954
955 if (!tempbuf_init)
956 tempbuf_init = 1;
957 else
958 obstack_free (&tempbuf, NULL);
959 obstack_init (&tempbuf);
960
961 /* Skip the quote. */
962 quote = *tokptr;
963 ++tokptr;
964
965 *host_chars = 0;
966
967 while (*tokptr)
968 {
969 char c = *tokptr;
970 if (c == '\\')
971 {
972 ++tokptr;
973 *host_chars += c_parse_escape (&tokptr, &tempbuf);
974 }
975 else if (c == quote)
976 break;
977 else
978 {
979 obstack_1grow (&tempbuf, c);
980 ++tokptr;
981 /* FIXME: this does the wrong thing with multi-byte host
982 characters. We could use mbrlen here, but that would
983 make "set host-charset" a bit less useful. */
984 ++*host_chars;
985 }
986 }
987
988 if (*tokptr != quote)
989 {
990 if (quote == '"' || quote == '`')
991 error (_("Unterminated string in expression."));
992 else
993 error (_("Unmatched single quote."));
994 }
995 ++tokptr;
996
997 /* FIXME: should instead use own language string_type enum
998 and handle D-specific string suffixes here. */
999 if (quote == '\'')
1000 value->type = C_CHAR;
1001 else
1002 value->type = C_STRING;
1003
1004 value->ptr = obstack_base (&tempbuf);
1005 value->length = obstack_object_size (&tempbuf);
1006
1007 *outptr = tokptr;
1008
1009 return quote == '\'' ? CHARACTER_LITERAL : STRING_LITERAL;
1010}
1011
1012struct token
1013{
fe978cb0 1014 char *oper;
3ed9baed
IB		 1015 int token;
1016 enum exp_opcode opcode;
1017};
1018
1019static const struct token tokentab3[] =
1020 {
1021 {"^^=", ASSIGN_MODIFY, BINOP_EXP},
1022 {"<<=", ASSIGN_MODIFY, BINOP_LSH},
1023 {">>=", ASSIGN_MODIFY, BINOP_RSH},
1024 };
1025
1026static const struct token tokentab2[] =
1027 {
1028 {"+=", ASSIGN_MODIFY, BINOP_ADD},
1029 {"-=", ASSIGN_MODIFY, BINOP_SUB},
1030 {"*=", ASSIGN_MODIFY, BINOP_MUL},
1031 {"/=", ASSIGN_MODIFY, BINOP_DIV},
1032 {"%=", ASSIGN_MODIFY, BINOP_REM},
1033 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
1034 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
1035 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
1036 {"++", INCREMENT, BINOP_END},
1037 {"--", DECREMENT, BINOP_END},
1038 {"&&", ANDAND, BINOP_END},
1039 {"||", OROR, BINOP_END},
1040 {"^^", HATHAT, BINOP_END},
1041 {"<<", LSH, BINOP_END},
1042 {">>", RSH, BINOP_END},
1043 {"==", EQUAL, BINOP_END},
1044 {"!=", NOTEQUAL, BINOP_END},
1045 {"<=", LEQ, BINOP_END},
1046 {">=", GEQ, BINOP_END},
1047 {"..", DOTDOT, BINOP_END},
1048 };
1049
1050/* Identifier-like tokens. */
1051static const struct token ident_tokens[] =
1052 {
1053 {"is", IDENTITY, BINOP_END},
1054 {"!is", NOTIDENTITY, BINOP_END},
1055
1056 {"cast", CAST_KEYWORD, OP_NULL},
1057 {"const", CONST_KEYWORD, OP_NULL},
1058 {"immutable", IMMUTABLE_KEYWORD, OP_NULL},
1059 {"shared", SHARED_KEYWORD, OP_NULL},
1060 {"super", SUPER_KEYWORD, OP_NULL},
1061
1062 {"null", NULL_KEYWORD, OP_NULL},
1063 {"true", TRUE_KEYWORD, OP_NULL},
1064 {"false", FALSE_KEYWORD, OP_NULL},
1065
1066 {"init", INIT_KEYWORD, OP_NULL},
1067 {"sizeof", SIZEOF_KEYWORD, OP_NULL},
1068 {"typeof", TYPEOF_KEYWORD, OP_NULL},
1069 {"typeid", TYPEID_KEYWORD, OP_NULL},
1070
1071 {"delegate", DELEGATE_KEYWORD, OP_NULL},
1072 {"function", FUNCTION_KEYWORD, OP_NULL},
1073 {"struct", STRUCT_KEYWORD, OP_NULL},
1074 {"union", UNION_KEYWORD, OP_NULL},
1075 {"class", CLASS_KEYWORD, OP_NULL},
1076 {"interface", INTERFACE_KEYWORD, OP_NULL},
1077 {"enum", ENUM_KEYWORD, OP_NULL},
1078 {"template", TEMPLATE_KEYWORD, OP_NULL},
1079 };
1080
3ed9baed
IB		 1081/* This is set if a NAME token appeared at the very end of the input
1082 string, with no whitespace separating the name from the EOF. This
1083 is used only when parsing to do field name completion. */
1084static int saw_name_at_eof;
1085
1086/* This is set if the previously-returned token was a structure operator.
1087 This is used only when parsing to do field name completion. */
1088static int last_was_structop;
1089
1090/* Read one token, getting characters through lexptr. */
1091
1092static int
444c1ed8 1093lex_one_token (struct parser_state *par_state)
3ed9baed
IB		 1094{
1095 int c;
1096 int namelen;
1097 unsigned int i;
1098 const char *tokstart;
1099 int saw_structop = last_was_structop;
1100 char *copy;
1101
1102 last_was_structop = 0;
1103
1104 retry:
1105
1106 prev_lexptr = lexptr;
1107
1108 tokstart = lexptr;
1109 /* See if it is a special token of length 3. */
1110 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
fe978cb0 1111 if (strncmp (tokstart, tokentab3[i].oper, 3) == 0)
3ed9baed
IB		 1112 {
1113 lexptr += 3;
1114 yylval.opcode = tokentab3[i].opcode;
1115 return tokentab3[i].token;
1116 }
1117
1118 /* See if it is a special token of length 2. */
1119 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
fe978cb0 1120 if (strncmp (tokstart, tokentab2[i].oper, 2) == 0)
3ed9baed
IB		 1121 {
1122 lexptr += 2;
1123 yylval.opcode = tokentab2[i].opcode;
1124 return tokentab2[i].token;
1125 }
1126
1127 switch (c = *tokstart)
1128 {
1129 case 0:
1130 /* If we're parsing for field name completion, and the previous
1131 token allows such completion, return a COMPLETE token.
1132 Otherwise, we were already scanning the original text, and
1133 we're really done. */
1134 if (saw_name_at_eof)
1135 {
1136 saw_name_at_eof = 0;
1137 return COMPLETE;
1138 }
1139 else if (saw_structop)
1140 return COMPLETE;
1141 else
1142 return 0;
1143
1144 case ' ':
1145 case '\t':
1146 case '\n':
1147 lexptr++;
1148 goto retry;
1149
1150 case '[':
1151 case '(':
1152 paren_depth++;
1153 lexptr++;
1154 return c;
1155
1156 case ']':
1157 case ')':
1158 if (paren_depth == 0)
1159 return 0;
1160 paren_depth--;
1161 lexptr++;
1162 return c;
1163
1164 case ',':
1165 if (comma_terminates && paren_depth == 0)
1166 return 0;
1167 lexptr++;
1168 return c;
1169
1170 case '.':
1171 /* Might be a floating point number. */
1172 if (lexptr[1] < '0' || lexptr[1] > '9')
1173 {
1174 if (parse_completion)
1175 last_was_structop = 1;
1176 goto symbol; /* Nope, must be a symbol. */
1177 }
1178 /* FALL THRU into number case. */
1179
1180 case '0':
1181 case '1':
1182 case '2':
1183 case '3':
1184 case '4':
1185 case '5':
1186 case '6':
1187 case '7':
1188 case '8':
1189 case '9':
1190 {
1191 /* It's a number. */
1192 int got_dot = 0, got_e = 0, toktype;
1193 const char *p = tokstart;
1194 int hex = input_radix > 10;
1195
1196 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1197 {
1198 p += 2;
1199 hex = 1;
1200 }
1201
1202 for (;; ++p)
1203 {
1204 /* Hex exponents start with 'p', because 'e' is a valid hex
1205 digit and thus does not indicate a floating point number
1206 when the radix is hex. */
1207 if ((!hex && !got_e && tolower (p[0]) == 'e')
1208 || (hex && !got_e && tolower (p[0] == 'p')))
1209 got_dot = got_e = 1;
1210 /* A '.' always indicates a decimal floating point number
1211 regardless of the radix. If we have a '..' then its the
1212 end of the number and the beginning of a slice. */
1213 else if (!got_dot && (p[0] == '.' && p[1] != '.'))
1214 got_dot = 1;
1215 /* This is the sign of the exponent, not the end of the number. */
1216 else if (got_e && (tolower (p[-1]) == 'e' || tolower (p[-1]) == 'p')
1217 && (*p == '-' || *p == '+'))
1218 continue;
1219 /* We will take any letters or digits, ignoring any embedded '_'.
1220 parse_number will complain if past the radix, or if L or U are
1221 not final. */
c0fe2ae7
IB		 1222 else if ((*p < '0' || *p > '9') && (*p != '_')
1223 && ((*p < 'a' || *p > 'z') && (*p < 'A' || *p > 'Z')))
3ed9baed
IB		 1224 break;
1225 }
1226
444c1ed8 1227 toktype = parse_number (par_state, tokstart, p - tokstart,
3ed9baed
IB		 1228 got_dot|got_e, &yylval);
1229 if (toktype == ERROR)
1230 {
1231 char *err_copy = (char *) alloca (p - tokstart + 1);
1232
1233 memcpy (err_copy, tokstart, p - tokstart);
1234 err_copy[p - tokstart] = 0;
1235 error (_("Invalid number \"%s\"."), err_copy);
1236 }
1237 lexptr = p;
1238 return toktype;
1239 }
1240
1241 case '@':
1242 {
1243 const char *p = &tokstart[1];
1244 size_t len = strlen ("entry");
1245
1246 while (isspace (*p))
1247 p++;
1248 if (strncmp (p, "entry", len) == 0 && !isalnum (p[len])
1249 && p[len] != '_')
1250 {
1251 lexptr = &p[len];
1252 return ENTRY;
1253 }
1254 }
1255 /* FALLTHRU */
1256 case '+':
1257 case '-':
1258 case '*':
1259 case '/':
1260 case '%':
1261 case '|':
1262 case '&':
1263 case '^':
1264 case '~':
1265 case '!':
1266 case '<':
1267 case '>':
1268 case '?':
1269 case ':':
1270 case '=':
1271 case '{':
1272 case '}':
1273 symbol:
1274 lexptr++;
1275 return c;
1276
1277 case '\'':
1278 case '"':
1279 case '`':
1280 {
1281 int host_len;
1282 int result = parse_string_or_char (tokstart, &lexptr, &yylval.tsval,
1283 &host_len);
1284 if (result == CHARACTER_LITERAL)
1285 {
1286 if (host_len == 0)
1287 error (_("Empty character constant."));
1288 else if (host_len > 2 && c == '\'')
1289 {
1290 ++tokstart;
1291 namelen = lexptr - tokstart - 1;
1292 goto tryname;
1293 }
1294 else if (host_len > 1)
1295 error (_("Invalid character constant."));
1296 }
1297 return result;
1298 }
1299 }
1300
1301 if (!(c == '_' || c == '$'
1302 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1303 /* We must have come across a bad character (e.g. ';'). */
1304 error (_("Invalid character '%c' in expression"), c);
1305
1306 /* It's a name. See how long it is. */
1307 namelen = 0;
1308 for (c = tokstart[namelen];
1309 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1310 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));)
1311 c = tokstart[++namelen];
1312
1313 /* The token "if" terminates the expression and is NOT
1314 removed from the input stream. */
1315 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1316 return 0;
1317
1318 /* For the same reason (breakpoint conditions), "thread N"
1319 terminates the expression. "thread" could be an identifier, but
1320 an identifier is never followed by a number without intervening
1321 punctuation. "task" is similar. Handle abbreviations of these,
1322 similarly to breakpoint.c:find_condition_and_thread. */
1323 if (namelen >= 1
1324 && (strncmp (tokstart, "thread", namelen) == 0
1325 || strncmp (tokstart, "task", namelen) == 0)
1326 && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t'))
1327 {
1328 const char *p = tokstart + namelen + 1;
1329
1330 while (*p == ' ' || *p == '\t')
1331 p++;
1332 if (*p >= '0' && *p <= '9')
1333 return 0;
1334 }
1335
1336 lexptr += namelen;
1337
1338 tryname:
1339
1340 yylval.sval.ptr = tokstart;
1341 yylval.sval.length = namelen;
1342
1343 /* Catch specific keywords. */
1344 copy = copy_name (yylval.sval);
1345 for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++)
fe978cb0 1346 if (strcmp (copy, ident_tokens[i].oper) == 0)
3ed9baed
IB		 1347 {
1348 /* It is ok to always set this, even though we don't always
1349 strictly need to. */
1350 yylval.opcode = ident_tokens[i].opcode;
1351 return ident_tokens[i].token;
1352 }
1353
1354 if (*tokstart == '$')
1355 return DOLLAR_VARIABLE;
1356
1357 yylval.tsym.type
444c1ed8
IB		 1358 = language_lookup_primitive_type (parse_language (par_state),
1359 parse_gdbarch (par_state), copy);
3ed9baed
IB		 1360 if (yylval.tsym.type != NULL)
1361 return TYPENAME;
1362
1363 /* Input names that aren't symbols but ARE valid hex numbers,
1364 when the input radix permits them, can be names or numbers
1365 depending on the parse. Note we support radixes > 16 here. */
1366 if ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10)
1367 || (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10))
1368 {
1369 YYSTYPE newlval; /* Its value is ignored. */
444c1ed8 1370 int hextype = parse_number (par_state, tokstart, namelen, 0, &newlval);
3ed9baed
IB		 1371 if (hextype == INTEGER_LITERAL)
1372 return NAME_OR_INT;
1373 }
1374
1375 if (parse_completion && *lexptr == '\0')
1376 saw_name_at_eof = 1;
1377
1378 return IDENTIFIER;
1379}
1380
444c1ed8
IB		 1381/* An object of this type is pushed on a FIFO by the "outer" lexer. */
1382typedef struct
1383{
1384 int token;
1385 YYSTYPE value;
1386} token_and_value;
1387
1388DEF_VEC_O (token_and_value);
1389
1390/* A FIFO of tokens that have been read but not yet returned to the
1391 parser. */
1392static VEC (token_and_value) *token_fifo;
1393
1394/* Non-zero if the lexer should return tokens from the FIFO. */
1395static int popping;
1396
1397/* Temporary storage for yylex; this holds symbol names as they are
1398 built up. */
1399static struct obstack name_obstack;
1400
1401/* Classify an IDENTIFIER token. The contents of the token are in `yylval'.
1402 Updates yylval and returns the new token type. BLOCK is the block
1403 in which lookups start; this can be NULL to mean the global scope. */
1404
1405static int
1406classify_name (struct parser_state *par_state, const struct block *block)
1407{
1408 struct block_symbol sym;
1409 char *copy;
1410 struct field_of_this_result is_a_field_of_this;
1411
1412 copy = copy_name (yylval.sval);
1413
1414 sym = lookup_symbol (copy, block, VAR_DOMAIN, &is_a_field_of_this);
1415 if (sym.symbol && SYMBOL_CLASS (sym.symbol) == LOC_TYPEDEF)
1416 {
1417 yylval.tsym.type = SYMBOL_TYPE (sym.symbol);
1418 return TYPENAME;
1419 }
1420 else if (sym.symbol == NULL)
1421 {
1422 /* Look-up first for a module name, then a type. */
1423 sym = lookup_symbol (copy, block, MODULE_DOMAIN, NULL);
1424 if (sym.symbol == NULL)
1425 sym = lookup_symbol (copy, block, STRUCT_DOMAIN, NULL);
1426
1427 if (sym.symbol != NULL)
1428 {
1429 yylval.tsym.type = SYMBOL_TYPE (sym.symbol);
1430 return TYPENAME;
1431 }
1432
1433 return UNKNOWN_NAME;
1434 }
1435
1436 return IDENTIFIER;
1437}
1438
1439/* Like classify_name, but used by the inner loop of the lexer, when a
1440 name might have already been seen. CONTEXT is the context type, or
1441 NULL if this is the first component of a name. */
1442
1443static int
1444classify_inner_name (struct parser_state *par_state,
1445 const struct block *block, struct type *context)
1446{
1447 struct type *type;
1448 char *copy;
1449
1450 if (context == NULL)
1451 return classify_name (par_state, block);
1452
1453 type = check_typedef (context);
7f3706eb
IB		 1454 if (!type_aggregate_p (type))
1455 return ERROR;
444c1ed8
IB		 1456
1457 copy = copy_name (yylval.ssym.stoken);
1458 yylval.ssym.sym = d_lookup_nested_symbol (type, copy, block);
1459
1460 if (yylval.ssym.sym.symbol == NULL)
1461 return ERROR;
1462
1463 if (SYMBOL_CLASS (yylval.ssym.sym.symbol) == LOC_TYPEDEF)
1464 {
1465 yylval.tsym.type = SYMBOL_TYPE (yylval.ssym.sym.symbol);
1466 return TYPENAME;
1467 }
1468
1469 return IDENTIFIER;
1470}
1471
1472/* The outer level of a two-level lexer. This calls the inner lexer
1473 to return tokens. It then either returns these tokens, or
1474 aggregates them into a larger token. This lets us work around a
1475 problem in our parsing approach, where the parser could not
1476 distinguish between qualified names and qualified types at the
1477 right point. */
1478
1479static int
1480yylex (void)
1481{
1482 token_and_value current;
1483 int last_was_dot;
1484 struct type *context_type = NULL;
1485 int last_to_examine, next_to_examine, checkpoint;
1486 const struct block *search_block;
1487
1488 if (popping && !VEC_empty (token_and_value, token_fifo))
1489 goto do_pop;
1490 popping = 0;
1491
1492 /* Read the first token and decide what to do. */
1493 current.token = lex_one_token (pstate);
1494 if (current.token != IDENTIFIER && current.token != '.')
1495 return current.token;
1496
1497 /* Read any sequence of alternating "." and identifier tokens into
1498 the token FIFO. */
1499 current.value = yylval;
1500 VEC_safe_push (token_and_value, token_fifo, &current);
1501 last_was_dot = current.token == '.';
1502
1503 while (1)
1504 {
1505 current.token = lex_one_token (pstate);
1506 current.value = yylval;
1507 VEC_safe_push (token_and_value, token_fifo, &current);
1508
1509 if ((last_was_dot && current.token != IDENTIFIER)
1510 || (!last_was_dot && current.token != '.'))
1511 break;
1512
1513 last_was_dot = !last_was_dot;
1514 }
1515 popping = 1;
1516
1517 /* We always read one extra token, so compute the number of tokens
1518 to examine accordingly. */
1519 last_to_examine = VEC_length (token_and_value, token_fifo) - 2;
1520 next_to_examine = 0;
1521
1522 current = *VEC_index (token_and_value, token_fifo, next_to_examine);
1523 ++next_to_examine;
1524
1525 /* If we are not dealing with a typename, now is the time to find out. */
1526 if (current.token == IDENTIFIER)
1527 {
1528 yylval = current.value;
1529 current.token = classify_name (pstate, expression_context_block);
1530 current.value = yylval;
1531 }
1532
1533 /* If the IDENTIFIER is not known, it could be a package symbol,
1534 first try building up a name until we find the qualified module. */
1535 if (current.token == UNKNOWN_NAME)
1536 {
1537 obstack_free (&name_obstack, obstack_base (&name_obstack));
1538 obstack_grow (&name_obstack, current.value.sval.ptr,
1539 current.value.sval.length);
1540
1541 last_was_dot = 0;
1542
1543 while (next_to_examine <= last_to_examine)
1544 {
1545 token_and_value *next;
1546
1547 next = VEC_index (token_and_value, token_fifo, next_to_examine);
1548 ++next_to_examine;
1549
1550 if (next->token == IDENTIFIER && last_was_dot)
1551 {
1552 /* Update the partial name we are constructing. */
1553 obstack_grow_str (&name_obstack, ".");
1554 obstack_grow (&name_obstack, next->value.sval.ptr,
1555 next->value.sval.length);
1556
1557 yylval.sval.ptr = obstack_base (&name_obstack);
1558 yylval.sval.length = obstack_object_size (&name_obstack);
1559
1560 current.token = classify_name (pstate, expression_context_block);
1561 current.value = yylval;
1562
1563 /* We keep going until we find a TYPENAME. */
1564 if (current.token == TYPENAME)
1565 {
1566 /* Install it as the first token in the FIFO. */
1567 VEC_replace (token_and_value, token_fifo, 0, &current);
1568 VEC_block_remove (token_and_value, token_fifo, 1,
1569 next_to_examine - 1);
1570 break;
1571 }
1572 }
1573 else if (next->token == '.' && !last_was_dot)
1574 last_was_dot = 1;
1575 else
1576 {
1577 /* We've reached the end of the name. */
1578 break;
1579 }
1580 }
1581
1582 /* Reset our current token back to the start, if we found nothing
1583 this means that we will just jump to do pop. */
1584 current = *VEC_index (token_and_value, token_fifo, 0);
1585 next_to_examine = 1;
1586 }
1587 if (current.token != TYPENAME && current.token != '.')
1588 goto do_pop;
1589
1590 obstack_free (&name_obstack, obstack_base (&name_obstack));
1591 checkpoint = 0;
1592 if (current.token == '.')
1593 search_block = NULL;
1594 else
1595 {
1596 gdb_assert (current.token == TYPENAME);
1597 search_block = expression_context_block;
1598 obstack_grow (&name_obstack, current.value.sval.ptr,
1599 current.value.sval.length);
1600 context_type = current.value.tsym.type;
1601 checkpoint = 1;
1602 }
1603
1604 last_was_dot = current.token == '.';
1605
1606 while (next_to_examine <= last_to_examine)
1607 {
1608 token_and_value *next;
1609
1610 next = VEC_index (token_and_value, token_fifo, next_to_examine);
1611 ++next_to_examine;
1612
1613 if (next->token == IDENTIFIER && last_was_dot)
1614 {
1615 int classification;
1616
1617 yylval = next->value;
1618 classification = classify_inner_name (pstate, search_block,
1619 context_type);
1620 /* We keep going until we either run out of names, or until
1621 we have a qualified name which is not a type. */
1622 if (classification != TYPENAME && classification != IDENTIFIER)
1623 break;
1624
1625 /* Accept up to this token. */
1626 checkpoint = next_to_examine;
1627
1628 /* Update the partial name we are constructing. */
1629 if (context_type != NULL)
1630 {
1631 /* We don't want to put a leading "." into the name. */
1632 obstack_grow_str (&name_obstack, ".");
1633 }
1634 obstack_grow (&name_obstack, next->value.sval.ptr,
1635 next->value.sval.length);
1636
1637 yylval.sval.ptr = obstack_base (&name_obstack);
1638 yylval.sval.length = obstack_object_size (&name_obstack);
1639 current.value = yylval;
1640 current.token = classification;
1641
1642 last_was_dot = 0;
1643
1644 if (classification == IDENTIFIER)
1645 break;
1646
1647 context_type = yylval.tsym.type;
1648 }
1649 else if (next->token == '.' && !last_was_dot)
1650 last_was_dot = 1;
1651 else
1652 {
1653 /* We've reached the end of the name. */
1654 break;
1655 }
1656 }
1657
1658 /* If we have a replacement token, install it as the first token in
1659 the FIFO, and delete the other constituent tokens. */
1660 if (checkpoint > 0)
1661 {
1662 VEC_replace (token_and_value, token_fifo, 0, &current);
1663 if (checkpoint > 1)
1664 VEC_block_remove (token_and_value, token_fifo, 1, checkpoint - 1);
1665 }
1666
1667 do_pop:
1668 current = *VEC_index (token_and_value, token_fifo, 0);
1669 VEC_ordered_remove (token_and_value, token_fifo, 0);
1670 yylval = current.value;
1671 return current.token;
1672}
1673
3ed9baed
IB		 1674int
1675d_parse (struct parser_state *par_state)
1676{
1677 int result;
1678 struct cleanup *back_to;
1679
1680 /* Setting up the parser state. */
1681 gdb_assert (par_state != NULL);
1682 pstate = par_state;
1683
1684 back_to = make_cleanup (null_cleanup, NULL);
1685
1686 make_cleanup_restore_integer (&yydebug);
1687 make_cleanup_clear_parser_state (&pstate);
1688 yydebug = parser_debug;
1689
1690 /* Initialize some state used by the lexer. */
1691 last_was_structop = 0;
1692 saw_name_at_eof = 0;
1693
444c1ed8
IB		 1694 VEC_free (token_and_value, token_fifo);
1695 popping = 0;
1696 obstack_init (&name_obstack);
1697 make_cleanup_obstack_free (&name_obstack);
1698
3ed9baed
IB		 1699 result = yyparse ();
1700 do_cleanups (back_to);
1701 return result;
1702}
1703
1704void
1705yyerror (char *msg)
1706{
1707 if (prev_lexptr)
1708 lexptr = prev_lexptr;
1709
1710 error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr);
1711}
1712
GDB Binutils - Deliverables
This page took 0.237453 seconds and 4 git commands to generate.