]> Git Repo - binutils.git/blame - gdb/d-exp.y
projects / binutils.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[ARM] Make human parsing of "processor does not support instruction in mode" error...
[binutils.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
129%}
130
131/* Although the yacc "value" of an expression is not used,
132 since the result is stored in the structure being created,
133 other node types do have values. */
134
135%union
136 {
137 struct {
138 LONGEST val;
139 struct type *type;
140 } typed_val_int;
141 struct {
142 DOUBLEST dval;
143 struct type *type;
144 } typed_val_float;
145 struct symbol *sym;
146 struct type *tval;
147 struct typed_stoken tsval;
148 struct stoken sval;
149 struct ttype tsym;
150 struct symtoken ssym;
151 int ival;
152 struct block *bval;
153 enum exp_opcode opcode;
154 struct stoken_vector svec;
155 }
156
157%{
158/* YYSTYPE gets defined by %union */
159static int parse_number (struct parser_state *, const char *,
160 int, int, YYSTYPE *);
161
162static void push_expression_name (struct parser_state *, struct stoken);
163%}
164
165%token <sval> IDENTIFIER
166%token <tsym> TYPENAME
167%token <voidval> COMPLETE
168
169/* A NAME_OR_INT is a symbol which is not known in the symbol table,
170 but which would parse as a valid number in the current input radix.
171 E.g. "c" when input_radix==16. Depending on the parse, it will be
172 turned into a name or into a number. */
173
174%token <sval> NAME_OR_INT
175
176%token <typed_val_int> INTEGER_LITERAL
177%token <typed_val_float> FLOAT_LITERAL
178%token <tsval> CHARACTER_LITERAL
179%token <tsval> STRING_LITERAL
180
181%type <svec> StringExp
182%type <tval> BasicType TypeExp
183%type <sval> IdentifierExp
184%type <ival> ArrayLiteral
185
186%token ENTRY
187%token ERROR
188
189/* Keywords that have a constant value. */
190%token TRUE_KEYWORD FALSE_KEYWORD NULL_KEYWORD
191/* Class 'super' accessor. */
192%token SUPER_KEYWORD
193/* Properties. */
194%token CAST_KEYWORD SIZEOF_KEYWORD
195%token TYPEOF_KEYWORD TYPEID_KEYWORD
196%token INIT_KEYWORD
197/* Comparison keywords. */
198/* Type storage classes. */
199%token IMMUTABLE_KEYWORD CONST_KEYWORD SHARED_KEYWORD
200/* Non-scalar type keywords. */
201%token STRUCT_KEYWORD UNION_KEYWORD
202%token CLASS_KEYWORD INTERFACE_KEYWORD
203%token ENUM_KEYWORD TEMPLATE_KEYWORD
204%token DELEGATE_KEYWORD FUNCTION_KEYWORD
205
206%token <sval> DOLLAR_VARIABLE
207
208%token <opcode> ASSIGN_MODIFY
209
210%left ','
211%right '=' ASSIGN_MODIFY
212%right '?'
213%left OROR
214%left ANDAND
215%left '|'
216%left '^'
217%left '&'
218%left EQUAL NOTEQUAL '<' '>' LEQ GEQ
219%right LSH RSH
220%left '+' '-'
221%left '*' '/' '%'
222%right HATHAT
223%left IDENTITY NOTIDENTITY
224%right INCREMENT DECREMENT
225%right '.' '[' '('
226%token DOTDOT
227
228\f
229%%
230
231start :
232 Expression
233| TypeExp
234;
235
236/* Expressions, including the comma operator. */
237
238Expression:
239 CommaExpression
240;
241
242CommaExpression:
243 AssignExpression
244| AssignExpression ',' CommaExpression
245 { write_exp_elt_opcode (pstate, BINOP_COMMA); }
246;
247
248AssignExpression:
249 ConditionalExpression
250| ConditionalExpression '=' AssignExpression
251 { write_exp_elt_opcode (pstate, BINOP_ASSIGN); }
252| ConditionalExpression ASSIGN_MODIFY AssignExpression
253 { write_exp_elt_opcode (pstate, BINOP_ASSIGN_MODIFY);
254 write_exp_elt_opcode (pstate, $2);
255 write_exp_elt_opcode (pstate, BINOP_ASSIGN_MODIFY); }
256;
257
258ConditionalExpression:
259 OrOrExpression
260| OrOrExpression '?' Expression ':' ConditionalExpression
261 { write_exp_elt_opcode (pstate, TERNOP_COND); }
262;
263
264OrOrExpression:
265 AndAndExpression
266| OrOrExpression OROR AndAndExpression
267 { write_exp_elt_opcode (pstate, BINOP_LOGICAL_OR); }
268;
269
270AndAndExpression:
271 OrExpression
272| AndAndExpression ANDAND OrExpression
273 { write_exp_elt_opcode (pstate, BINOP_LOGICAL_AND); }
274;
275
276OrExpression:
277 XorExpression
278| OrExpression '|' XorExpression
279 { write_exp_elt_opcode (pstate, BINOP_BITWISE_IOR); }
280;
281
282XorExpression:
283 AndExpression
284| XorExpression '^' AndExpression
285 { write_exp_elt_opcode (pstate, BINOP_BITWISE_XOR); }
286;
287
288AndExpression:
289 CmpExpression
290| AndExpression '&' CmpExpression
291 { write_exp_elt_opcode (pstate, BINOP_BITWISE_AND); }
292;
293
294CmpExpression:
295 ShiftExpression
296| EqualExpression
297| IdentityExpression
298| RelExpression
299;
300
301EqualExpression:
302 ShiftExpression EQUAL ShiftExpression
303 { write_exp_elt_opcode (pstate, BINOP_EQUAL); }
304| ShiftExpression NOTEQUAL ShiftExpression
305 { write_exp_elt_opcode (pstate, BINOP_NOTEQUAL); }
306;
307
308IdentityExpression:
309 ShiftExpression IDENTITY ShiftExpression
310 { write_exp_elt_opcode (pstate, BINOP_EQUAL); }
311| ShiftExpression NOTIDENTITY ShiftExpression
312 { write_exp_elt_opcode (pstate, BINOP_NOTEQUAL); }
313;
314
315RelExpression:
316 ShiftExpression '<' ShiftExpression
317 { write_exp_elt_opcode (pstate, BINOP_LESS); }
318| ShiftExpression LEQ ShiftExpression
319 { write_exp_elt_opcode (pstate, BINOP_LEQ); }
320| ShiftExpression '>' ShiftExpression
321 { write_exp_elt_opcode (pstate, BINOP_GTR); }
322| ShiftExpression GEQ ShiftExpression
323 { write_exp_elt_opcode (pstate, BINOP_GEQ); }
324;
325
326ShiftExpression:
327 AddExpression
328| ShiftExpression LSH AddExpression
329 { write_exp_elt_opcode (pstate, BINOP_LSH); }
330| ShiftExpression RSH AddExpression
331 { write_exp_elt_opcode (pstate, BINOP_RSH); }
332;
333
334AddExpression:
335 MulExpression
336| AddExpression '+' MulExpression
337 { write_exp_elt_opcode (pstate, BINOP_ADD); }
338| AddExpression '-' MulExpression
339 { write_exp_elt_opcode (pstate, BINOP_SUB); }
340| AddExpression '~' MulExpression
341 { write_exp_elt_opcode (pstate, BINOP_CONCAT); }
342;
343
344MulExpression:
345 UnaryExpression
346| MulExpression '*' UnaryExpression
347 { write_exp_elt_opcode (pstate, BINOP_MUL); }
348| MulExpression '/' UnaryExpression
349 { write_exp_elt_opcode (pstate, BINOP_DIV); }
350| MulExpression '%' UnaryExpression
351 { write_exp_elt_opcode (pstate, BINOP_REM); }
352
353UnaryExpression:
354 '&' UnaryExpression
355 { write_exp_elt_opcode (pstate, UNOP_ADDR); }
356| INCREMENT UnaryExpression
357 { write_exp_elt_opcode (pstate, UNOP_PREINCREMENT); }
358| DECREMENT UnaryExpression
359 { write_exp_elt_opcode (pstate, UNOP_PREDECREMENT); }
360| '*' UnaryExpression
361 { write_exp_elt_opcode (pstate, UNOP_IND); }
362| '-' UnaryExpression
363 { write_exp_elt_opcode (pstate, UNOP_NEG); }
364| '+' UnaryExpression
365 { write_exp_elt_opcode (pstate, UNOP_PLUS); }
366| '!' UnaryExpression
367 { write_exp_elt_opcode (pstate, UNOP_LOGICAL_NOT); }
368| '~' UnaryExpression
369 { write_exp_elt_opcode (pstate, UNOP_COMPLEMENT); }
370| CastExpression
371| PowExpression
372;
373
374CastExpression:
375 CAST_KEYWORD '(' TypeExp ')' UnaryExpression
376 { write_exp_elt_opcode (pstate, UNOP_CAST);
377 write_exp_elt_type (pstate, $3);
378 write_exp_elt_opcode (pstate, UNOP_CAST); }
379 /* C style cast is illegal D, but is still recognised in
380 the grammar, so we keep this around for convenience. */
381| '(' TypeExp ')' UnaryExpression
382 { write_exp_elt_opcode (pstate, UNOP_CAST);
383 write_exp_elt_type (pstate, $2);
384 write_exp_elt_opcode (pstate, UNOP_CAST); }
385;
386
387PowExpression:
388 PostfixExpression
389| PostfixExpression HATHAT UnaryExpression
390 { write_exp_elt_opcode (pstate, BINOP_EXP); }
391;
392
393PostfixExpression:
394 PrimaryExpression
395| PostfixExpression INCREMENT
396 { write_exp_elt_opcode (pstate, UNOP_POSTINCREMENT); }
397| PostfixExpression DECREMENT
398 { write_exp_elt_opcode (pstate, UNOP_POSTDECREMENT); }
399| CallExpression
400| IndexExpression
401| SliceExpression
402;
403
404ArgumentList:
405 AssignExpression
406 { arglist_len = 1; }
407| ArgumentList ',' AssignExpression
408 { arglist_len++; }
409;
410
411ArgumentList_opt:
412 /* EMPTY */
413 { arglist_len = 0; }
414| ArgumentList
415;
416
417CallExpression:
418 PostfixExpression '('
419 { start_arglist (); }
420 ArgumentList_opt ')'
421 { write_exp_elt_opcode (pstate, OP_FUNCALL);
422 write_exp_elt_longcst (pstate, (LONGEST) end_arglist ());
423 write_exp_elt_opcode (pstate, OP_FUNCALL); }
424;
425
426IndexExpression:
427 PostfixExpression '[' ArgumentList ']'
428 { if (arglist_len > 0)
429 {
430 write_exp_elt_opcode (pstate, MULTI_SUBSCRIPT);
431 write_exp_elt_longcst (pstate, (LONGEST) arglist_len);
432 write_exp_elt_opcode (pstate, MULTI_SUBSCRIPT);
433 }
434 else
435 write_exp_elt_opcode (pstate, BINOP_SUBSCRIPT);
436 }
437;
438
439SliceExpression:
440 PostfixExpression '[' ']'
441 { /* Do nothing. */ }
442| PostfixExpression '[' AssignExpression DOTDOT AssignExpression ']'
443 { write_exp_elt_opcode (pstate, TERNOP_SLICE); }
444;
445
446PrimaryExpression:
447 '(' Expression ')'
448 { /* Do nothing. */ }
449| IdentifierExp
450 { push_expression_name (pstate, $1); }
451| IdentifierExp '.' COMPLETE
452 { struct stoken s;
453 s.ptr = "";
454 s.length = 0;
455 push_expression_name (pstate, $1);
456 mark_struct_expression (pstate);
457 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
458 write_exp_string (pstate, s);
459 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
460| IdentifierExp '.' IDENTIFIER COMPLETE
461 { push_expression_name (pstate, $1);
462 mark_struct_expression (pstate);
463 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
464 write_exp_string (pstate, $3);
465 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
466| DOLLAR_VARIABLE
467 { write_dollar_variable (pstate, $1); }
468| NAME_OR_INT
469 { YYSTYPE val;
470 parse_number (pstate, $1.ptr, $1.length, 0, &val);
471 write_exp_elt_opcode (pstate, OP_LONG);
472 write_exp_elt_type (pstate, val.typed_val_int.type);
473 write_exp_elt_longcst (pstate,
474 (LONGEST) val.typed_val_int.val);
475 write_exp_elt_opcode (pstate, OP_LONG); }
476| NULL_KEYWORD
477 { struct type *type = parse_d_type (pstate)->builtin_void;
478 type = lookup_pointer_type (type);
479 write_exp_elt_opcode (pstate, OP_LONG);
480 write_exp_elt_type (pstate, type);
481 write_exp_elt_longcst (pstate, (LONGEST) 0);
482 write_exp_elt_opcode (pstate, OP_LONG); }
483| TRUE_KEYWORD
484 { write_exp_elt_opcode (pstate, OP_BOOL);
485 write_exp_elt_longcst (pstate, (LONGEST) 1);
486 write_exp_elt_opcode (pstate, OP_BOOL); }
487| FALSE_KEYWORD
488 { write_exp_elt_opcode (pstate, OP_BOOL);
489 write_exp_elt_longcst (pstate, (LONGEST) 0);
490 write_exp_elt_opcode (pstate, OP_BOOL); }
491| INTEGER_LITERAL
492 { write_exp_elt_opcode (pstate, OP_LONG);
493 write_exp_elt_type (pstate, $1.type);
494 write_exp_elt_longcst (pstate, (LONGEST)($1.val));
495 write_exp_elt_opcode (pstate, OP_LONG); }
496| FLOAT_LITERAL
497 { write_exp_elt_opcode (pstate, OP_DOUBLE);
498 write_exp_elt_type (pstate, $1.type);
499 write_exp_elt_dblcst (pstate, $1.dval);
500 write_exp_elt_opcode (pstate, OP_DOUBLE); }
501| CHARACTER_LITERAL
502 { struct stoken_vector vec;
503 vec.len = 1;
504 vec.tokens = &$1;
505 write_exp_string_vector (pstate, $1.type, &vec); }
506| StringExp
507 { int i;
508 write_exp_string_vector (pstate, 0, &$1);
509 for (i = 0; i < $1.len; ++i)
510 free ($1.tokens[i].ptr);
511 free ($1.tokens); }
512| ArrayLiteral
513 { write_exp_elt_opcode (pstate, OP_ARRAY);
514 write_exp_elt_longcst (pstate, (LONGEST) 0);
515 write_exp_elt_longcst (pstate, (LONGEST) $1 - 1);
516 write_exp_elt_opcode (pstate, OP_ARRAY); }
517;
518
519ArrayLiteral:
520 '[' ArgumentList_opt ']'
521 { $$ = arglist_len; }
522;
523
524IdentifierExp:
525 IDENTIFIER
526| IdentifierExp '.' IDENTIFIER
527 { $$.length = $1.length + $3.length + 1;
528 if ($1.ptr + $1.length + 1 == $3.ptr
529 && $1.ptr[$1.length] == '.')
530 $$.ptr = $1.ptr; /* Optimization. */
531 else
532 {
533 char *buf = malloc ($$.length + 1);
534 make_cleanup (free, buf);
535 sprintf (buf, "%.*s.%.*s",
536 $1.length, $1.ptr, $3.length, $3.ptr);
537 $$.ptr = buf;
538 }
539 }
540;
541
542StringExp:
543 STRING_LITERAL
544 { /* We copy the string here, and not in the
545 lexer, to guarantee that we do not leak a
546 string. Note that we follow the
547 NUL-termination convention of the
548 lexer. */
549 struct typed_stoken *vec = XNEW (struct typed_stoken);
550 $$.len = 1;
551 $$.tokens = vec;
552
553 vec->type = $1.type;
554 vec->length = $1.length;
555 vec->ptr = malloc ($1.length + 1);
556 memcpy (vec->ptr, $1.ptr, $1.length + 1);
557 }
558| StringExp STRING_LITERAL
559 { /* Note that we NUL-terminate here, but just
560 for convenience. */
561 char *p;
562 ++$$.len;
563 $$.tokens = realloc ($$.tokens,
564 $$.len * sizeof (struct typed_stoken));
565
566 p = malloc ($2.length + 1);
567 memcpy (p, $2.ptr, $2.length + 1);
568
569 $$.tokens[$$.len - 1].type = $2.type;
570 $$.tokens[$$.len - 1].length = $2.length;
571 $$.tokens[$$.len - 1].ptr = p;
572 }
573;
574
575TypeExp:
576 BasicType
577 { write_exp_elt_opcode (pstate, OP_TYPE);
578 write_exp_elt_type (pstate, $1);
579 write_exp_elt_opcode (pstate, OP_TYPE); }
580| BasicType BasicType2
581 { $$ = follow_types ($1);
582 write_exp_elt_opcode (pstate, OP_TYPE);
583 write_exp_elt_type (pstate, $$);
584 write_exp_elt_opcode (pstate, OP_TYPE);
585 }
586;
587
588BasicType2:
589 '*'
590 { push_type (tp_pointer); }
591| '*' BasicType2
592 { push_type (tp_pointer); }
593| '[' INTEGER_LITERAL ']'
594 { push_type_int ($2.val);
595 push_type (tp_array); }
596| '[' INTEGER_LITERAL ']' BasicType2
597 { push_type_int ($2.val);
598 push_type (tp_array); }
599;
600
601BasicType:
602 TYPENAME
603 { $$ = $1.type; }
604| CLASS_KEYWORD IdentifierExp
605 { $$ = lookup_struct (copy_name ($2),
606 expression_context_block); }
607| CLASS_KEYWORD COMPLETE
4753d33b 608 { mark_completion_tag (TYPE_CODE_STRUCT, "", 0);
3ed9baed
IB		 609 $$ = NULL; }
610| CLASS_KEYWORD IdentifierExp COMPLETE
4753d33b 611 { mark_completion_tag (TYPE_CODE_STRUCT, $2.ptr, $2.length);
3ed9baed
IB		 612 $$ = NULL; }
613| STRUCT_KEYWORD IdentifierExp
614 { $$ = lookup_struct (copy_name ($2),
615 expression_context_block); }
616| STRUCT_KEYWORD COMPLETE
617 { mark_completion_tag (TYPE_CODE_STRUCT, "", 0);
618 $$ = NULL; }
619| STRUCT_KEYWORD IdentifierExp COMPLETE
620 { mark_completion_tag (TYPE_CODE_STRUCT, $2.ptr, $2.length);
621 $$ = NULL; }
622| UNION_KEYWORD IdentifierExp
623 { $$ = lookup_union (copy_name ($2),
624 expression_context_block); }
625| UNION_KEYWORD COMPLETE
626 { mark_completion_tag (TYPE_CODE_UNION, "", 0);
627 $$ = NULL; }
628| UNION_KEYWORD IdentifierExp COMPLETE
629 { mark_completion_tag (TYPE_CODE_UNION, $2.ptr, $2.length);
630 $$ = NULL; }
631| ENUM_KEYWORD IdentifierExp
632 { $$ = lookup_enum (copy_name ($2),
633 expression_context_block); }
634| ENUM_KEYWORD COMPLETE
635 { mark_completion_tag (TYPE_CODE_ENUM, "", 0);
636 $$ = NULL; }
637| ENUM_KEYWORD IdentifierExp COMPLETE
638 { mark_completion_tag (TYPE_CODE_ENUM, $2.ptr, $2.length);
639 $$ = NULL; }
640;
641
642%%
643
644/* Take care of parsing a number (anything that starts with a digit).
645 Set yylval and return the token type; update lexptr.
646 LEN is the number of characters in it. */
647
648/*** Needs some error checking for the float case ***/
649
650static int
651parse_number (struct parser_state *ps, const char *p,
652 int len, int parsed_float, YYSTYPE *putithere)
653{
654 ULONGEST n = 0;
655 ULONGEST prevn = 0;
656 ULONGEST un;
657
658 int i = 0;
659 int c;
660 int base = input_radix;
661 int unsigned_p = 0;
662 int long_p = 0;
663
664 /* We have found a "L" or "U" suffix. */
665 int found_suffix = 0;
666
667 ULONGEST high_bit;
668 struct type *signed_type;
669 struct type *unsigned_type;
670
671 if (parsed_float)
672 {
673 const struct builtin_d_type *builtin_d_types;
674 const char *suffix;
675 int suffix_len;
676 char *s, *sp;
677
678 /* Strip out all embedded '_' before passing to parse_float. */
679 s = (char *) alloca (len + 1);
680 sp = s;
681 while (len-- > 0)
682 {
683 if (*p != '_')
684 *sp++ = *p;
685 p++;
686 }
687 *sp = '\0';
688 len = strlen (s);
689
690 if (! parse_float (s, len, &putithere->typed_val_float.dval, &suffix))
691 return ERROR;
692
693 suffix_len = s + len - suffix;
694
695 if (suffix_len == 0)
696 {
697 putithere->typed_val_float.type
698 = parse_d_type (ps)->builtin_double;
699 }
700 else if (suffix_len == 1)
701 {
702 /* Check suffix for `f', `l', or `i' (float, real, or idouble). */
703 if (tolower (*suffix) == 'f')
704 {
705 putithere->typed_val_float.type
706 = parse_d_type (ps)->builtin_float;
707 }
708 else if (tolower (*suffix) == 'l')
709 {
710 putithere->typed_val_float.type
711 = parse_d_type (ps)->builtin_real;
712 }
713 else if (tolower (*suffix) == 'i')
714 {
715 putithere->typed_val_float.type
716 = parse_d_type (ps)->builtin_idouble;
717 }
718 else
719 return ERROR;
720 }
721 else if (suffix_len == 2)
722 {
723 /* Check suffix for `fi' or `li' (ifloat or ireal). */
724 if (tolower (suffix[0]) == 'f' && tolower (suffix[1] == 'i'))
725 {
726 putithere->typed_val_float.type
727 = parse_d_type (ps)->builtin_ifloat;
728 }
729 else if (tolower (suffix[0]) == 'l' && tolower (suffix[1] == 'i'))
730 {
731 putithere->typed_val_float.type
732 = parse_d_type (ps)->builtin_ireal;
733 }
734 else
735 return ERROR;
736 }
737 else
738 return ERROR;
739
740 return FLOAT_LITERAL;
741 }
742
743 /* Handle base-switching prefixes 0x, 0b, 0 */
744 if (p[0] == '0')
745 switch (p[1])
746 {
747 case 'x':
748 case 'X':
749 if (len >= 3)
750 {
751 p += 2;
752 base = 16;
753 len -= 2;
754 }
755 break;
756
757 case 'b':
758 case 'B':
759 if (len >= 3)
760 {
761 p += 2;
762 base = 2;
763 len -= 2;
764 }
765 break;
766
767 default:
768 base = 8;
769 break;
770 }
771
772 while (len-- > 0)
773 {
774 c = *p++;
775 if (c == '_')
776 continue; /* Ignore embedded '_'. */
777 if (c >= 'A' && c <= 'Z')
778 c += 'a' - 'A';
779 if (c != 'l' && c != 'u')
780 n *= base;
781 if (c >= '0' && c <= '9')
782 {
783 if (found_suffix)
784 return ERROR;
785 n += i = c - '0';
786 }
787 else
788 {
789 if (base > 10 && c >= 'a' && c <= 'f')
790 {
791 if (found_suffix)
792 return ERROR;
793 n += i = c - 'a' + 10;
794 }
795 else if (c == 'l' && long_p == 0)
796 {
797 long_p = 1;
798 found_suffix = 1;
799 }
800 else if (c == 'u' && unsigned_p == 0)
801 {
802 unsigned_p = 1;
803 found_suffix = 1;
804 }
805 else
806 return ERROR; /* Char not a digit */
807 }
808 if (i >= base)
809 return ERROR; /* Invalid digit in this base. */
810 /* Portably test for integer overflow. */
811 if (c != 'l' && c != 'u')
812 {
813 ULONGEST n2 = prevn * base;
814 if ((n2 / base != prevn) || (n2 + i < prevn))
815 error (_("Numeric constant too large."));
816 }
817 prevn = n;
818 }
819
820 /* An integer constant is an int or a long. An L suffix forces it to
821 be long, and a U suffix forces it to be unsigned. To figure out
822 whether it fits, we shift it right and see whether anything remains.
823 Note that we can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or
824 more in one operation, because many compilers will warn about such a
825 shift (which always produces a zero result). To deal with the case
826 where it is we just always shift the value more than once, with fewer
827 bits each time. */
828 un = (ULONGEST) n >> 2;
829 if (long_p == 0 && (un >> 30) == 0)
830 {
831 high_bit = ((ULONGEST) 1) << 31;
832 signed_type = parse_d_type (ps)->builtin_int;
833 /* For decimal notation, keep the sign of the worked out type. */
834 if (base == 10 && !unsigned_p)
835 unsigned_type = parse_d_type (ps)->builtin_long;
836 else
837 unsigned_type = parse_d_type (ps)->builtin_uint;
838 }
839 else
840 {
841 int shift;
842 if (sizeof (ULONGEST) * HOST_CHAR_BIT < 64)
843 /* A long long does not fit in a LONGEST. */
844 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
845 else
846 shift = 63;
847 high_bit = (ULONGEST) 1 << shift;
848 signed_type = parse_d_type (ps)->builtin_long;
849 unsigned_type = parse_d_type (ps)->builtin_ulong;
850 }
851
852 putithere->typed_val_int.val = n;
853
854 /* If the high bit of the worked out type is set then this number
855 has to be unsigned_type. */
856 if (unsigned_p || (n & high_bit))
857 putithere->typed_val_int.type = unsigned_type;
858 else
859 putithere->typed_val_int.type = signed_type;
860
861 return INTEGER_LITERAL;
862}
863
864/* Temporary obstack used for holding strings. */
865static struct obstack tempbuf;
866static int tempbuf_init;
867
868/* Parse a string or character literal from TOKPTR. The string or
869 character may be wide or unicode. *OUTPTR is set to just after the
870 end of the literal in the input string. The resulting token is
871 stored in VALUE. This returns a token value, either STRING or
872 CHAR, depending on what was parsed. *HOST_CHARS is set to the
873 number of host characters in the literal. */
874
875static int
876parse_string_or_char (const char *tokptr, const char **outptr,
877 struct typed_stoken *value, int *host_chars)
878{
879 int quote;
880
881 /* Build the gdb internal form of the input string in tempbuf. Note
882 that the buffer is null byte terminated *only* for the
883 convenience of debugging gdb itself and printing the buffer
884 contents when the buffer contains no embedded nulls. Gdb does
885 not depend upon the buffer being null byte terminated, it uses
886 the length string instead. This allows gdb to handle C strings
887 (as well as strings in other languages) with embedded null
888 bytes */
889
890 if (!tempbuf_init)
891 tempbuf_init = 1;
892 else
893 obstack_free (&tempbuf, NULL);
894 obstack_init (&tempbuf);
895
896 /* Skip the quote. */
897 quote = *tokptr;
898 ++tokptr;
899
900 *host_chars = 0;
901
902 while (*tokptr)
903 {
904 char c = *tokptr;
905 if (c == '\\')
906 {
907 ++tokptr;
908 *host_chars += c_parse_escape (&tokptr, &tempbuf);
909 }
910 else if (c == quote)
911 break;
912 else
913 {
914 obstack_1grow (&tempbuf, c);
915 ++tokptr;
916 /* FIXME: this does the wrong thing with multi-byte host
917 characters. We could use mbrlen here, but that would
918 make "set host-charset" a bit less useful. */
919 ++*host_chars;
920 }
921 }
922
923 if (*tokptr != quote)
924 {
925 if (quote == '"' || quote == '`')
926 error (_("Unterminated string in expression."));
927 else
928 error (_("Unmatched single quote."));
929 }
930 ++tokptr;
931
932 /* FIXME: should instead use own language string_type enum
933 and handle D-specific string suffixes here. */
934 if (quote == '\'')
935 value->type = C_CHAR;
936 else
937 value->type = C_STRING;
938
939 value->ptr = obstack_base (&tempbuf);
940 value->length = obstack_object_size (&tempbuf);
941
942 *outptr = tokptr;
943
944 return quote == '\'' ? CHARACTER_LITERAL : STRING_LITERAL;
945}
946
947struct token
948{
fe978cb0 949 char *oper;
3ed9baed
IB		 950 int token;
951 enum exp_opcode opcode;
952};
953
954static const struct token tokentab3[] =
955 {
956 {"^^=", ASSIGN_MODIFY, BINOP_EXP},
957 {"<<=", ASSIGN_MODIFY, BINOP_LSH},
958 {">>=", ASSIGN_MODIFY, BINOP_RSH},
959 };
960
961static const struct token tokentab2[] =
962 {
963 {"+=", ASSIGN_MODIFY, BINOP_ADD},
964 {"-=", ASSIGN_MODIFY, BINOP_SUB},
965 {"*=", ASSIGN_MODIFY, BINOP_MUL},
966 {"/=", ASSIGN_MODIFY, BINOP_DIV},
967 {"%=", ASSIGN_MODIFY, BINOP_REM},
968 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
969 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
970 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
971 {"++", INCREMENT, BINOP_END},
972 {"--", DECREMENT, BINOP_END},
973 {"&&", ANDAND, BINOP_END},
974 {"||", OROR, BINOP_END},
975 {"^^", HATHAT, BINOP_END},
976 {"<<", LSH, BINOP_END},
977 {">>", RSH, BINOP_END},
978 {"==", EQUAL, BINOP_END},
979 {"!=", NOTEQUAL, BINOP_END},
980 {"<=", LEQ, BINOP_END},
981 {">=", GEQ, BINOP_END},
982 {"..", DOTDOT, BINOP_END},
983 };
984
985/* Identifier-like tokens. */
986static const struct token ident_tokens[] =
987 {
988 {"is", IDENTITY, BINOP_END},
989 {"!is", NOTIDENTITY, BINOP_END},
990
991 {"cast", CAST_KEYWORD, OP_NULL},
992 {"const", CONST_KEYWORD, OP_NULL},
993 {"immutable", IMMUTABLE_KEYWORD, OP_NULL},
994 {"shared", SHARED_KEYWORD, OP_NULL},
995 {"super", SUPER_KEYWORD, OP_NULL},
996
997 {"null", NULL_KEYWORD, OP_NULL},
998 {"true", TRUE_KEYWORD, OP_NULL},
999 {"false", FALSE_KEYWORD, OP_NULL},
1000
1001 {"init", INIT_KEYWORD, OP_NULL},
1002 {"sizeof", SIZEOF_KEYWORD, OP_NULL},
1003 {"typeof", TYPEOF_KEYWORD, OP_NULL},
1004 {"typeid", TYPEID_KEYWORD, OP_NULL},
1005
1006 {"delegate", DELEGATE_KEYWORD, OP_NULL},
1007 {"function", FUNCTION_KEYWORD, OP_NULL},
1008 {"struct", STRUCT_KEYWORD, OP_NULL},
1009 {"union", UNION_KEYWORD, OP_NULL},
1010 {"class", CLASS_KEYWORD, OP_NULL},
1011 {"interface", INTERFACE_KEYWORD, OP_NULL},
1012 {"enum", ENUM_KEYWORD, OP_NULL},
1013 {"template", TEMPLATE_KEYWORD, OP_NULL},
1014 };
1015
1016/* If NAME is a type name in this scope, return it. */
1017
1018static struct type *
1019d_type_from_name (struct stoken name)
1020{
1021 struct symbol *sym;
1022 char *copy = copy_name (name);
1023
1024 sym = lookup_symbol (copy, expression_context_block,
1025 STRUCT_DOMAIN, NULL);
1026 if (sym != NULL)
1027 return SYMBOL_TYPE (sym);
1028
1029 return NULL;
1030}
1031
1032/* If NAME is a module name in this scope, return it. */
1033
1034static struct type *
1035d_module_from_name (struct stoken name)
1036{
1037 struct symbol *sym;
1038 char *copy = copy_name (name);
1039
1040 sym = lookup_symbol (copy, expression_context_block,
1041 MODULE_DOMAIN, NULL);
1042 if (sym != NULL)
1043 return SYMBOL_TYPE (sym);
1044
1045 return NULL;
1046}
1047
1048/* If NAME is a valid variable name in this scope, push it and return 1.
1049 Otherwise, return 0. */
1050
1051static int
1052push_variable (struct parser_state *ps, struct stoken name)
1053{
1054 char *copy = copy_name (name);
1055 struct field_of_this_result is_a_field_of_this;
1056 struct symbol *sym;
1057 sym = lookup_symbol (copy, expression_context_block, VAR_DOMAIN,
1058 &is_a_field_of_this);
1059 if (sym && SYMBOL_CLASS (sym) != LOC_TYPEDEF)
1060 {
1061 if (symbol_read_needs_frame (sym))
1062 {
1063 if (innermost_block == 0 ||
1064 contained_in (block_found, innermost_block))
1065 innermost_block = block_found;
1066 }
1067
1068 write_exp_elt_opcode (ps, OP_VAR_VALUE);
1069 /* We want to use the selected frame, not another more inner frame
1070 which happens to be in the same block. */
1071 write_exp_elt_block (ps, NULL);
1072 write_exp_elt_sym (ps, sym);
1073 write_exp_elt_opcode (ps, OP_VAR_VALUE);
1074 return 1;
1075 }
1076 if (is_a_field_of_this.type != NULL)
1077 {
1078 /* It hangs off of `this'. Must not inadvertently convert from a
1079 method call to data ref. */
1080 if (innermost_block == 0 ||
1081 contained_in (block_found, innermost_block))
1082 innermost_block = block_found;
1083 write_exp_elt_opcode (ps, OP_THIS);
1084 write_exp_elt_opcode (ps, OP_THIS);
1085 write_exp_elt_opcode (ps, STRUCTOP_PTR);
1086 write_exp_string (ps, name);
1087 write_exp_elt_opcode (ps, STRUCTOP_PTR);
1088 return 1;
1089 }
1090 return 0;
1091}
1092
1093/* Assuming a reference expression has been pushed, emit the
1094 STRUCTOP_PTR ops to access the field named NAME. If NAME is a
1095 qualified name (has '.'), generate a field access for each part. */
1096
1097static void
1098push_fieldnames (struct parser_state *ps, struct stoken name)
1099{
1100 int i;
1101 struct stoken token;
1102 token.ptr = name.ptr;
1103 for (i = 0; ; i++)
1104 {
1105 if (i == name.length || name.ptr[i] == '.')
1106 {
1107 /* token.ptr is start of current field name. */
1108 token.length = &name.ptr[i] - token.ptr;
1109 write_exp_elt_opcode (ps, STRUCTOP_PTR);
1110 write_exp_string (ps, token);
1111 write_exp_elt_opcode (ps, STRUCTOP_PTR);
1112 token.ptr += token.length + 1;
1113 }
1114 if (i >= name.length)
1115 break;
1116 }
1117}
1118
1119/* Helper routine for push_expression_name. Handle a TYPE symbol,
1120 where DOT_INDEX is the index of the first '.' if NAME is part of
1121 a qualified type. */
1122
1123static void
1124push_type_name (struct parser_state *ps, struct type *type,
1125 struct stoken name, int dot_index)
1126{
1127 if (dot_index == name.length)
1128 {
1129 write_exp_elt_opcode (ps, OP_TYPE);
1130 write_exp_elt_type (ps, type);
1131 write_exp_elt_opcode (ps, OP_TYPE);
1132 }
1133 else
1134 {
1135 struct stoken token;
1136
1137 token.ptr = name.ptr;
1138 token.length = dot_index;
1139
1140 dot_index = 0;
1141
1142 while (dot_index < name.length && name.ptr[dot_index] != '.')
1143 dot_index++;
1144 token.ptr = name.ptr;
1145 token.length = dot_index;
1146
1147 write_exp_elt_opcode (ps, OP_SCOPE);
1148 write_exp_elt_type (ps, type);
1149 write_exp_string (ps, token);
1150 write_exp_elt_opcode (ps, OP_SCOPE);
1151
1152 if (dot_index < name.length)
1153 {
1154 dot_index++;
1155 name.ptr += dot_index;
1156 name.length -= dot_index;
1157 push_fieldnames (ps, name);
1158 }
1159 }
1160}
1161
1162/* Helper routine for push_expression_name. Like push_type_name,
1163 but used when TYPE is a module. Returns 1 on pushing the symbol. */
1164
1165static int
1166push_module_name (struct parser_state *ps, struct type *module,
1167 struct stoken name, int dot_index)
1168{
1169 if (dot_index == name.length)
1170 {
1171 write_exp_elt_opcode (ps, OP_TYPE);
1172 write_exp_elt_type (ps, module);
1173 write_exp_elt_opcode (ps, OP_TYPE);
1174 return 1;
1175 }
1176 else
1177 {
1178 struct symbol *sym;
1179 char *copy;
1180
1181 copy = copy_name (name);
24d864bb
DE		 1182 sym = lookup_symbol_in_static_block (copy, expression_context_block,
1183 VAR_DOMAIN);
3ed9baed 1184 if (sym != NULL)
08724ab7 1185 sym = lookup_global_symbol (copy, expression_context_block,
3ed9baed
IB		 1186 VAR_DOMAIN);
1187
1188 if (sym != NULL)
1189 {
1190 if (SYMBOL_CLASS (sym) != LOC_TYPEDEF)
1191 {
1192 write_exp_elt_opcode (ps, OP_VAR_VALUE);
1193 write_exp_elt_block (ps, NULL);
1194 write_exp_elt_sym (ps, sym);
1195 write_exp_elt_opcode (ps, OP_VAR_VALUE);
1196 }
1197 else
1198 {
1199 write_exp_elt_opcode (ps, OP_TYPE);
1200 write_exp_elt_type (ps, SYMBOL_TYPE (sym));
1201 write_exp_elt_opcode (ps, OP_TYPE);
1202 }
1203 return 1;
1204 }
1205 }
1206
1207 return 0;
1208}
1209
1210/* Handle NAME in an expression (or LHS), which could be a
1211 variable, type, or module. */
1212
1213static void
1214push_expression_name (struct parser_state *ps, struct stoken name)
1215{
1216 struct stoken token;
1217 struct type *typ;
1218 struct bound_minimal_symbol msymbol;
1219 char *copy;
1220 int doti;
1221
1222 /* Handle VAR, which could be local or global. */
1223 if (push_variable (ps, name) != 0)
1224 return;
1225
1226 /* Handle MODULE. */
1227 typ = d_module_from_name (name);
1228 if (typ != NULL)
1229 {
1230 if (push_module_name (ps, typ, name, name.length) != 0)
1231 return;
1232 }
1233
1234 /* Handle TYPE. */
1235 typ = d_type_from_name (name);
1236 if (typ != NULL)
1237 {
1238 push_type_name (ps, typ, name, name.length);
1239 return;
1240 }
1241
1242 /* Handle VAR.FIELD1..FIELDN. */
1243 for (doti = 0; doti < name.length; doti++)
1244 {
1245 if (name.ptr[doti] == '.')
1246 {
1247 token.ptr = name.ptr;
1248 token.length = doti;
1249
1250 if (push_variable (ps, token) != 0)
1251 {
1252 token.ptr = name.ptr + doti + 1;
1253 token.length = name.length - doti - 1;
1254 push_fieldnames (ps, token);
1255 return;
1256 }
1257 break;
1258 }
1259 }
1260
1261 /* Continue looking if we found a '.' in the name. */
1262 if (doti < name.length)
1263 {
1264 token.ptr = name.ptr;
1265 for (;;)
1266 {
1267 token.length = doti;
1268
1269 /* Handle PACKAGE.MODULE. */
1270 typ = d_module_from_name (token);
1271 if (typ != NULL)
1272 {
1273 if (push_module_name (ps, typ, name, doti) != 0)
1274 return;
1275 }
1276 /* Handle TYPE.FIELD1..FIELDN. */
1277 typ = d_type_from_name (token);
1278 if (typ != NULL)
1279 {
1280 push_type_name (ps, typ, name, doti);
1281 return;
1282 }
1283
1284 if (doti >= name.length)
1285 break;
1286 doti++; /* Skip '.' */
1287 while (doti < name.length && name.ptr[doti] != '.')
1288 doti++;
1289 }
1290 }
1291
1292 /* Lookup foreign name in global static symbols. */
1293 copy = copy_name (name);
1294 msymbol = lookup_bound_minimal_symbol (copy);
1295 if (msymbol.minsym != NULL)
1296 write_exp_msymbol (ps, msymbol);
1297 else if (!have_full_symbols () && !have_partial_symbols ())
1298 error (_("No symbol table is loaded. Use the \"file\" command"));
1299 else
1300 error (_("No symbol \"%s\" in current context."), copy);
1301}
1302
1303/* This is set if a NAME token appeared at the very end of the input
1304 string, with no whitespace separating the name from the EOF. This
1305 is used only when parsing to do field name completion. */
1306static int saw_name_at_eof;
1307
1308/* This is set if the previously-returned token was a structure operator.
1309 This is used only when parsing to do field name completion. */
1310static int last_was_structop;
1311
1312/* Read one token, getting characters through lexptr. */
1313
1314static int
1315yylex (void)
1316{
1317 int c;
1318 int namelen;
1319 unsigned int i;
1320 const char *tokstart;
1321 int saw_structop = last_was_structop;
1322 char *copy;
1323
1324 last_was_structop = 0;
1325
1326 retry:
1327
1328 prev_lexptr = lexptr;
1329
1330 tokstart = lexptr;
1331 /* See if it is a special token of length 3. */
1332 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
fe978cb0 1333 if (strncmp (tokstart, tokentab3[i].oper, 3) == 0)
3ed9baed
IB		 1334 {
1335 lexptr += 3;
1336 yylval.opcode = tokentab3[i].opcode;
1337 return tokentab3[i].token;
1338 }
1339
1340 /* See if it is a special token of length 2. */
1341 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
fe978cb0 1342 if (strncmp (tokstart, tokentab2[i].oper, 2) == 0)
3ed9baed
IB		 1343 {
1344 lexptr += 2;
1345 yylval.opcode = tokentab2[i].opcode;
1346 return tokentab2[i].token;
1347 }
1348
1349 switch (c = *tokstart)
1350 {
1351 case 0:
1352 /* If we're parsing for field name completion, and the previous
1353 token allows such completion, return a COMPLETE token.
1354 Otherwise, we were already scanning the original text, and
1355 we're really done. */
1356 if (saw_name_at_eof)
1357 {
1358 saw_name_at_eof = 0;
1359 return COMPLETE;
1360 }
1361 else if (saw_structop)
1362 return COMPLETE;
1363 else
1364 return 0;
1365
1366 case ' ':
1367 case '\t':
1368 case '\n':
1369 lexptr++;
1370 goto retry;
1371
1372 case '[':
1373 case '(':
1374 paren_depth++;
1375 lexptr++;
1376 return c;
1377
1378 case ']':
1379 case ')':
1380 if (paren_depth == 0)
1381 return 0;
1382 paren_depth--;
1383 lexptr++;
1384 return c;
1385
1386 case ',':
1387 if (comma_terminates && paren_depth == 0)
1388 return 0;
1389 lexptr++;
1390 return c;
1391
1392 case '.':
1393 /* Might be a floating point number. */
1394 if (lexptr[1] < '0' || lexptr[1] > '9')
1395 {
1396 if (parse_completion)
1397 last_was_structop = 1;
1398 goto symbol; /* Nope, must be a symbol. */
1399 }
1400 /* FALL THRU into number case. */
1401
1402 case '0':
1403 case '1':
1404 case '2':
1405 case '3':
1406 case '4':
1407 case '5':
1408 case '6':
1409 case '7':
1410 case '8':
1411 case '9':
1412 {
1413 /* It's a number. */
1414 int got_dot = 0, got_e = 0, toktype;
1415 const char *p = tokstart;
1416 int hex = input_radix > 10;
1417
1418 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1419 {
1420 p += 2;
1421 hex = 1;
1422 }
1423
1424 for (;; ++p)
1425 {
1426 /* Hex exponents start with 'p', because 'e' is a valid hex
1427 digit and thus does not indicate a floating point number
1428 when the radix is hex. */
1429 if ((!hex && !got_e && tolower (p[0]) == 'e')
1430 || (hex && !got_e && tolower (p[0] == 'p')))
1431 got_dot = got_e = 1;
1432 /* A '.' always indicates a decimal floating point number
1433 regardless of the radix. If we have a '..' then its the
1434 end of the number and the beginning of a slice. */
1435 else if (!got_dot && (p[0] == '.' && p[1] != '.'))
1436 got_dot = 1;
1437 /* This is the sign of the exponent, not the end of the number. */
1438 else if (got_e && (tolower (p[-1]) == 'e' || tolower (p[-1]) == 'p')
1439 && (*p == '-' || *p == '+'))
1440 continue;
1441 /* We will take any letters or digits, ignoring any embedded '_'.
1442 parse_number will complain if past the radix, or if L or U are
1443 not final. */
1444 else if ((*p < '0' || *p > '9') && (*p != '_') &&
1445 ((*p < 'a' || *p > 'z') && (*p < 'A' || *p > 'Z')))
1446 break;
1447 }
1448
1449 toktype = parse_number (pstate, tokstart, p - tokstart,
1450 got_dot|got_e, &yylval);
1451 if (toktype == ERROR)
1452 {
1453 char *err_copy = (char *) alloca (p - tokstart + 1);
1454
1455 memcpy (err_copy, tokstart, p - tokstart);
1456 err_copy[p - tokstart] = 0;
1457 error (_("Invalid number \"%s\"."), err_copy);
1458 }
1459 lexptr = p;
1460 return toktype;
1461 }
1462
1463 case '@':
1464 {
1465 const char *p = &tokstart[1];
1466 size_t len = strlen ("entry");
1467
1468 while (isspace (*p))
1469 p++;
1470 if (strncmp (p, "entry", len) == 0 && !isalnum (p[len])
1471 && p[len] != '_')
1472 {
1473 lexptr = &p[len];
1474 return ENTRY;
1475 }
1476 }
1477 /* FALLTHRU */
1478 case '+':
1479 case '-':
1480 case '*':
1481 case '/':
1482 case '%':
1483 case '|':
1484 case '&':
1485 case '^':
1486 case '~':
1487 case '!':
1488 case '<':
1489 case '>':
1490 case '?':
1491 case ':':
1492 case '=':
1493 case '{':
1494 case '}':
1495 symbol:
1496 lexptr++;
1497 return c;
1498
1499 case '\'':
1500 case '"':
1501 case '`':
1502 {
1503 int host_len;
1504 int result = parse_string_or_char (tokstart, &lexptr, &yylval.tsval,
1505 &host_len);
1506 if (result == CHARACTER_LITERAL)
1507 {
1508 if (host_len == 0)
1509 error (_("Empty character constant."));
1510 else if (host_len > 2 && c == '\'')
1511 {
1512 ++tokstart;
1513 namelen = lexptr - tokstart - 1;
1514 goto tryname;
1515 }
1516 else if (host_len > 1)
1517 error (_("Invalid character constant."));
1518 }
1519 return result;
1520 }
1521 }
1522
1523 if (!(c == '_' || c == '$'
1524 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1525 /* We must have come across a bad character (e.g. ';'). */
1526 error (_("Invalid character '%c' in expression"), c);
1527
1528 /* It's a name. See how long it is. */
1529 namelen = 0;
1530 for (c = tokstart[namelen];
1531 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1532 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));)
1533 c = tokstart[++namelen];
1534
1535 /* The token "if" terminates the expression and is NOT
1536 removed from the input stream. */
1537 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1538 return 0;
1539
1540 /* For the same reason (breakpoint conditions), "thread N"
1541 terminates the expression. "thread" could be an identifier, but
1542 an identifier is never followed by a number without intervening
1543 punctuation. "task" is similar. Handle abbreviations of these,
1544 similarly to breakpoint.c:find_condition_and_thread. */
1545 if (namelen >= 1
1546 && (strncmp (tokstart, "thread", namelen) == 0
1547 || strncmp (tokstart, "task", namelen) == 0)
1548 && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t'))
1549 {
1550 const char *p = tokstart + namelen + 1;
1551
1552 while (*p == ' ' || *p == '\t')
1553 p++;
1554 if (*p >= '0' && *p <= '9')
1555 return 0;
1556 }
1557
1558 lexptr += namelen;
1559
1560 tryname:
1561
1562 yylval.sval.ptr = tokstart;
1563 yylval.sval.length = namelen;
1564
1565 /* Catch specific keywords. */
1566 copy = copy_name (yylval.sval);
1567 for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++)
fe978cb0 1568 if (strcmp (copy, ident_tokens[i].oper) == 0)
3ed9baed
IB		 1569 {
1570 /* It is ok to always set this, even though we don't always
1571 strictly need to. */
1572 yylval.opcode = ident_tokens[i].opcode;
1573 return ident_tokens[i].token;
1574 }
1575
1576 if (*tokstart == '$')
1577 return DOLLAR_VARIABLE;
1578
1579 yylval.tsym.type
46b0da17
DE		 1580 = language_lookup_primitive_type (parse_language (pstate),
1581 parse_gdbarch (pstate), copy);
3ed9baed
IB		 1582 if (yylval.tsym.type != NULL)
1583 return TYPENAME;
1584
1585 /* Input names that aren't symbols but ARE valid hex numbers,
1586 when the input radix permits them, can be names or numbers
1587 depending on the parse. Note we support radixes > 16 here. */
1588 if ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10)
1589 || (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10))
1590 {
1591 YYSTYPE newlval; /* Its value is ignored. */
1592 int hextype = parse_number (pstate, tokstart, namelen, 0, &newlval);
1593 if (hextype == INTEGER_LITERAL)
1594 return NAME_OR_INT;
1595 }
1596
1597 if (parse_completion && *lexptr == '\0')
1598 saw_name_at_eof = 1;
1599
1600 return IDENTIFIER;
1601}
1602
1603int
1604d_parse (struct parser_state *par_state)
1605{
1606 int result;
1607 struct cleanup *back_to;
1608
1609 /* Setting up the parser state. */
1610 gdb_assert (par_state != NULL);
1611 pstate = par_state;
1612
1613 back_to = make_cleanup (null_cleanup, NULL);
1614
1615 make_cleanup_restore_integer (&yydebug);
1616 make_cleanup_clear_parser_state (&pstate);
1617 yydebug = parser_debug;
1618
1619 /* Initialize some state used by the lexer. */
1620 last_was_structop = 0;
1621 saw_name_at_eof = 0;
1622
1623 result = yyparse ();
1624 do_cleanups (back_to);
1625 return result;
1626}
1627
1628void
1629yyerror (char *msg)
1630{
1631 if (prev_lexptr)
1632 lexptr = prev_lexptr;
1633
1634 error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr);
1635}
1636
Empty description
This page took 0.414904 seconds and 4 git commands to generate.