X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fd-exp.y;h=c09fe7a3f36aa706a8de5aafdb232ff3887d6800;hb=74d3fbbb3e35129526392718b63df41be3b0e88b;hp=d392a5cb2ef510bec4f81b244187309718e198ff;hpb=8268c77870de3c27ef598348f3023ba159fd0fca;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/d-exp.y b/gdb/d-exp.y index d392a5cb2e..c09fe7a3f3 100644 --- a/gdb/d-exp.y +++ b/gdb/d-exp.y @@ -1,6 +1,6 @@ /* YACC parser for D expressions, for GDB. - Copyright (C) 2014-2017 Free Software Foundation, Inc. + Copyright (C) 2014-2018 Free Software Foundation, Inc. This file is part of GDB. @@ -69,7 +69,7 @@ int yyparse (void); static int yylex (void); -void yyerror (const char *); +static void yyerror (const char *); static int type_aggregate_p (struct type *); @@ -86,7 +86,7 @@ static int type_aggregate_p (struct type *); struct type *type; } typed_val_int; struct { - DOUBLEST dval; + gdb_byte val[16]; struct type *type; } typed_val_float; struct symbol *sym; @@ -422,12 +422,7 @@ PrimaryExpression: if (sym.symbol && SYMBOL_CLASS (sym.symbol) != LOC_TYPEDEF) { if (symbol_read_needs_frame (sym.symbol)) - { - if (innermost_block == 0 - || contained_in (sym.block, innermost_block)) - innermost_block = sym.block; - } - + innermost_block.update (sym); write_exp_elt_opcode (pstate, OP_VAR_VALUE); write_exp_elt_block (pstate, sym.block); write_exp_elt_sym (pstate, sym.symbol); @@ -437,9 +432,7 @@ PrimaryExpression: { /* It hangs off of `this'. Must not inadvertently convert from a method call to data ref. */ - if (innermost_block == 0 - || contained_in (sym.block, innermost_block)) - innermost_block = sym.block; + innermost_block.update (sym); write_exp_elt_opcode (pstate, OP_THIS); write_exp_elt_opcode (pstate, OP_THIS); write_exp_elt_opcode (pstate, STRUCTOP_PTR); @@ -470,15 +463,14 @@ PrimaryExpression: struct block_symbol sym; const char *type_name = TYPE_SAFE_NAME (type); int type_name_len = strlen (type_name); - char *name; - - name = xstrprintf ("%.*s.%.*s", + std::string name + = string_printf ("%.*s.%.*s", type_name_len, type_name, $3.length, $3.ptr); - make_cleanup (xfree, name); sym = - lookup_symbol (name, (const struct block *) NULL, + lookup_symbol (name.c_str (), + (const struct block *) NULL, VAR_DOMAIN, NULL); if (sym.symbol) { @@ -489,13 +481,14 @@ PrimaryExpression: break; } - msymbol = lookup_bound_minimal_symbol (name); + msymbol = lookup_bound_minimal_symbol (name.c_str ()); if (msymbol.minsym != NULL) write_exp_msymbol (pstate, msymbol); else if (!have_full_symbols () && !have_partial_symbols ()) error (_("No symbol table is loaded. Use the \"file\" command.")); else - error (_("No symbol \"%s\" in current context."), name); + error (_("No symbol \"%s\" in current context."), + name.c_str ()); } /* Check if the qualified name resolves as a member @@ -540,10 +533,10 @@ PrimaryExpression: write_exp_elt_longcst (pstate, (LONGEST)($1.val)); write_exp_elt_opcode (pstate, OP_LONG); } | FLOAT_LITERAL - { write_exp_elt_opcode (pstate, OP_DOUBLE); + { write_exp_elt_opcode (pstate, OP_FLOAT); write_exp_elt_type (pstate, $1.type); - write_exp_elt_dblcst (pstate, $1.dval); - write_exp_elt_opcode (pstate, OP_DOUBLE); } + write_exp_elt_floatcst (pstate, $1.val); + write_exp_elt_opcode (pstate, OP_FLOAT); } | CHARACTER_LITERAL { struct stoken_vector vec; vec.len = 1; @@ -682,8 +675,6 @@ parse_number (struct parser_state *ps, const char *p, if (parsed_float) { - const char *suffix; - int suffix_len; char *s, *sp; /* Strip out all embedded '_' before passing to parse_float. */ @@ -698,54 +689,51 @@ parse_number (struct parser_state *ps, const char *p, *sp = '\0'; len = strlen (s); - if (! parse_float (s, len, &putithere->typed_val_float.dval, &suffix)) - return ERROR; - - suffix_len = s + len - suffix; - - if (suffix_len == 0) - { - putithere->typed_val_float.type - = parse_d_type (ps)->builtin_double; - } - else if (suffix_len == 1) + /* Check suffix for `i' , `fi' or `li' (idouble, ifloat or ireal). */ + if (len >= 1 && tolower (s[len - 1]) == 'i') { - /* Check suffix for `f', `l', or `i' (float, real, or idouble). */ - if (tolower (*suffix) == 'f') + if (len >= 2 && tolower (s[len - 2]) == 'f') { putithere->typed_val_float.type - = parse_d_type (ps)->builtin_float; + = parse_d_type (ps)->builtin_ifloat; + len -= 2; } - else if (tolower (*suffix) == 'l') + else if (len >= 2 && tolower (s[len - 2]) == 'l') { putithere->typed_val_float.type - = parse_d_type (ps)->builtin_real; + = parse_d_type (ps)->builtin_ireal; + len -= 2; } - else if (tolower (*suffix) == 'i') + else { putithere->typed_val_float.type = parse_d_type (ps)->builtin_idouble; + len -= 1; } - else - return ERROR; } - else if (suffix_len == 2) + /* Check suffix for `f' or `l'' (float or real). */ + else if (len >= 1 && tolower (s[len - 1]) == 'f') { - /* Check suffix for `fi' or `li' (ifloat or ireal). */ - if (tolower (suffix[0]) == 'f' && tolower (suffix[1] == 'i')) - { - putithere->typed_val_float.type - = parse_d_type (ps)->builtin_ifloat; - } - else if (tolower (suffix[0]) == 'l' && tolower (suffix[1] == 'i')) - { - putithere->typed_val_float.type - = parse_d_type (ps)->builtin_ireal; - } - else - return ERROR; + putithere->typed_val_float.type + = parse_d_type (ps)->builtin_float; + len -= 1; + } + else if (len >= 1 && tolower (s[len - 1]) == 'l') + { + putithere->typed_val_float.type + = parse_d_type (ps)->builtin_real; + len -= 1; } + /* Default type if no suffix. */ else + { + putithere->typed_val_float.type + = parse_d_type (ps)->builtin_double; + } + + if (!parse_float (s, len, + putithere->typed_val_float.type, + putithere->typed_val_float.val)) return ERROR; return FLOAT_LITERAL; @@ -1121,7 +1109,7 @@ lex_one_token (struct parser_state *par_state) last_was_structop = 1; goto symbol; /* Nope, must be a symbol. */ } - /* FALL THRU into number case. */ + /* FALL THRU. */ case '0': case '1': @@ -1325,17 +1313,16 @@ lex_one_token (struct parser_state *par_state) } /* An object of this type is pushed on a FIFO by the "outer" lexer. */ -typedef struct +struct token_and_value { int token; YYSTYPE value; -} token_and_value; +}; -DEF_VEC_O (token_and_value); /* A FIFO of tokens that have been read but not yet returned to the parser. */ -static VEC (token_and_value) *token_fifo; +static std::vector token_fifo; /* Non-zero if the lexer should return tokens from the FIFO. */ static int popping; @@ -1431,7 +1418,7 @@ yylex (void) int last_to_examine, next_to_examine, checkpoint; const struct block *search_block; - if (popping && !VEC_empty (token_and_value, token_fifo)) + if (popping && !token_fifo.empty ()) goto do_pop; popping = 0; @@ -1443,14 +1430,14 @@ yylex (void) /* Read any sequence of alternating "." and identifier tokens into the token FIFO. */ current.value = yylval; - VEC_safe_push (token_and_value, token_fifo, ¤t); + token_fifo.push_back (current); last_was_dot = current.token == '.'; while (1) { current.token = lex_one_token (pstate); current.value = yylval; - VEC_safe_push (token_and_value, token_fifo, ¤t); + token_fifo.push_back (current); if ((last_was_dot && current.token != IDENTIFIER) || (!last_was_dot && current.token != '.')) @@ -1462,10 +1449,10 @@ yylex (void) /* We always read one extra token, so compute the number of tokens to examine accordingly. */ - last_to_examine = VEC_length (token_and_value, token_fifo) - 2; + last_to_examine = token_fifo.size () - 2; next_to_examine = 0; - current = *VEC_index (token_and_value, token_fifo, next_to_examine); + current = token_fifo[next_to_examine]; ++next_to_examine; /* If we are not dealing with a typename, now is the time to find out. */ @@ -1488,17 +1475,17 @@ yylex (void) while (next_to_examine <= last_to_examine) { - token_and_value *next; + token_and_value next; - next = VEC_index (token_and_value, token_fifo, next_to_examine); + next = token_fifo[next_to_examine]; ++next_to_examine; - if (next->token == IDENTIFIER && last_was_dot) + if (next.token == IDENTIFIER && last_was_dot) { /* Update the partial name we are constructing. */ obstack_grow_str (&name_obstack, "."); - obstack_grow (&name_obstack, next->value.sval.ptr, - next->value.sval.length); + obstack_grow (&name_obstack, next.value.sval.ptr, + next.value.sval.length); yylval.sval.ptr = (char *) obstack_base (&name_obstack); yylval.sval.length = obstack_object_size (&name_obstack); @@ -1510,13 +1497,13 @@ yylex (void) if (current.token == TYPENAME) { /* Install it as the first token in the FIFO. */ - VEC_replace (token_and_value, token_fifo, 0, ¤t); - VEC_block_remove (token_and_value, token_fifo, 1, - next_to_examine - 1); + token_fifo[0] = current; + token_fifo.erase (token_fifo.begin () + 1, + token_fifo.begin () + next_to_examine); break; } } - else if (next->token == '.' && !last_was_dot) + else if (next.token == '.' && !last_was_dot) last_was_dot = 1; else { @@ -1527,7 +1514,7 @@ yylex (void) /* Reset our current token back to the start, if we found nothing this means that we will just jump to do pop. */ - current = *VEC_index (token_and_value, token_fifo, 0); + current = token_fifo[0]; next_to_examine = 1; } if (current.token != TYPENAME && current.token != '.') @@ -1551,16 +1538,16 @@ yylex (void) while (next_to_examine <= last_to_examine) { - token_and_value *next; + token_and_value next; - next = VEC_index (token_and_value, token_fifo, next_to_examine); + next = token_fifo[next_to_examine]; ++next_to_examine; - if (next->token == IDENTIFIER && last_was_dot) + if (next.token == IDENTIFIER && last_was_dot) { int classification; - yylval = next->value; + yylval = next.value; classification = classify_inner_name (pstate, search_block, context_type); /* We keep going until we either run out of names, or until @@ -1577,8 +1564,8 @@ yylex (void) /* We don't want to put a leading "." into the name. */ obstack_grow_str (&name_obstack, "."); } - obstack_grow (&name_obstack, next->value.sval.ptr, - next->value.sval.length); + obstack_grow (&name_obstack, next.value.sval.ptr, + next.value.sval.length); yylval.sval.ptr = (char *) obstack_base (&name_obstack); yylval.sval.length = obstack_object_size (&name_obstack); @@ -1592,7 +1579,7 @@ yylex (void) context_type = yylval.tsym.type; } - else if (next->token == '.' && !last_was_dot) + else if (next.token == '.' && !last_was_dot) last_was_dot = 1; else { @@ -1605,14 +1592,15 @@ yylex (void) the FIFO, and delete the other constituent tokens. */ if (checkpoint > 0) { - VEC_replace (token_and_value, token_fifo, 0, ¤t); + token_fifo[0] = current; if (checkpoint > 1) - VEC_block_remove (token_and_value, token_fifo, 1, checkpoint - 1); + token_fifo.erase (token_fifo.begin () + 1, + token_fifo.begin () + checkpoint); } do_pop: - current = *VEC_index (token_and_value, token_fifo, 0); - VEC_ordered_remove (token_and_value, token_fifo, 0); + current = token_fifo[0]; + token_fifo.erase (token_fifo.begin ()); yylval = current.value; return current.token; } @@ -1620,40 +1608,31 @@ yylex (void) int d_parse (struct parser_state *par_state) { - int result; - struct cleanup *back_to; - /* Setting up the parser state. */ + scoped_restore pstate_restore = make_scoped_restore (&pstate); gdb_assert (par_state != NULL); pstate = par_state; - /* Note that parsing (within yyparse) freely installs cleanups - assuming they're run here (below). */ - back_to = make_cleanup (null_cleanup, NULL); - scoped_restore restore_yydebug = make_scoped_restore (&yydebug, parser_debug); - make_cleanup_clear_parser_state (&pstate); /* Initialize some state used by the lexer. */ last_was_structop = 0; saw_name_at_eof = 0; - VEC_free (token_and_value, token_fifo); + token_fifo.clear (); popping = 0; name_obstack.clear (); - result = yyparse (); - do_cleanups (back_to); - return result; + return yyparse (); } -void +static void yyerror (const char *msg) { if (prev_lexptr) lexptr = prev_lexptr; - error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr); + error (_("A %s in expression, near `%s'."), msg, lexptr); }