X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fada-exp.y;h=2ae9830dbbb865e0cfa02dca3ccec7c3483219e4;hb=refs%2Fheads%2Fconcurrent-displaced-stepping-2020-04-01;hp=8c9004a4d7a4ca9fd5b1258f6cd53a93e5d355d9;hpb=ec6a20c268c3be4c34b951bc7d02543dca956108;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/ada-exp.y b/gdb/ada-exp.y index 8c9004a4d7..2ae9830dbb 100644 --- a/gdb/ada-exp.y +++ b/gdb/ada-exp.y @@ -1,5 +1,5 @@ /* YACC parser for Ada expressions, for GDB. - Copyright (C) 1986-2017 Free Software Foundation, Inc. + Copyright (C) 1986-2020 Free Software Foundation, Inc. This file is part of GDB. @@ -48,7 +48,7 @@ #include "frame.h" #include "block.h" -#define parse_type(ps) builtin_type (parse_gdbarch (ps)) +#define parse_type(ps) builtin_type (ps->gdbarch ()) /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc). */ @@ -77,7 +77,7 @@ int yyparse (void); static int yylex (void); -void yyerror (const char *); +static void yyerror (const char *); static void write_int (struct parser_state *, LONGEST, struct type *); @@ -151,7 +151,7 @@ static struct type *type_system_address (struct parser_state *); /* Special type cases, put in to allow the parser to distinguish different legal basetypes. */ -%token SPECIAL_VARIABLE +%token DOLLAR_VARIABLE %nonassoc ASSIGN %left _AND_ OR XOR THEN ELSE @@ -275,7 +275,7 @@ primary : var_or_type %prec VAR } ; -primary : SPECIAL_VARIABLE /* Various GDB extensions */ +primary : DOLLAR_VARIABLE /* Various GDB extensions */ { write_dollar_variable (pstate, $1); } ; @@ -717,7 +717,6 @@ primary : '*' primary %prec '.' #define yy_switch_to_buffer ada_yy_switch_to_buffer #define yyrestart ada_yyrestart #define yytext ada_yytext -#define yywrap ada_yywrap static struct obstack temp_parse_space; @@ -742,10 +741,10 @@ ada_parse (struct parser_state *par_state) return yyparse (); } -void +static void yyerror (const char *msg) { - error (_("Error in expression, near `%s'."), lexptr); + error (_("Error in expression, near `%s'."), pstate->lexptr); } /* Emit expression to access an instance of SYM, in block BLOCK (if @@ -757,11 +756,7 @@ write_var_from_sym (struct parser_state *par_state, struct symbol *sym) { if (symbol_read_needs_frame (sym)) - { - if (innermost_block == 0 - || contained_in (block, innermost_block)) - innermost_block = block; - } + par_state->block_tracker->update (block, INNERMOST_BLOCK_FOR_SYMBOLS); write_exp_elt_opcode (par_state, OP_VAR_VALUE); write_exp_elt_block (par_state, block); @@ -817,11 +812,11 @@ write_object_renaming (struct parser_state *par_state, if (orig_left_context == NULL) orig_left_context = get_selected_block (NULL); - name = (char *) obstack_copy0 (&temp_parse_space, renamed_entity, - renamed_entity_len); + name = obstack_strndup (&temp_parse_space, renamed_entity, + renamed_entity_len); ada_lookup_encoded_symbol (name, orig_left_context, VAR_DOMAIN, &sym_info); if (sym_info.symbol == NULL) - error (_("Could not find renamed variable: %s"), ada_decode (name)); + error (_("Could not find renamed variable: %s"), ada_decode (name).c_str ()); else if (SYMBOL_CLASS (sym_info.symbol) == LOC_TYPEDEF) /* We have a renaming of an old-style renaming symbol. Don't trust the block information. */ @@ -886,13 +881,12 @@ write_object_renaming (struct parser_state *par_state, if (end == NULL) end = renaming_expr + strlen (renaming_expr); - index_name - = (char *) obstack_copy0 (&temp_parse_space, renaming_expr, - end - renaming_expr); + index_name = obstack_strndup (&temp_parse_space, renaming_expr, + end - renaming_expr); renaming_expr = end; - ada_lookup_encoded_symbol (index_name, NULL, VAR_DOMAIN, - &index_sym_info); + ada_lookup_encoded_symbol (index_name, orig_left_context, + VAR_DOMAIN, &index_sym_info); if (index_sym_info.symbol == NULL) error (_("Could not find %s"), index_name); else if (SYMBOL_CLASS (index_sym_info.symbol) == LOC_TYPEDEF) @@ -954,10 +948,9 @@ static const struct block* block_lookup (const struct block *context, const char *raw_name) { const char *name; - struct block_symbol *syms; + std::vector syms; int nsyms; struct symtab *symtab; - struct cleanup *old_chain; const struct block *result = NULL; if (raw_name[0] == '\'') @@ -969,7 +962,6 @@ block_lookup (const struct block *context, const char *raw_name) name = ada_encode (raw_name); nsyms = ada_lookup_symbol_list (name, context, VAR_DOMAIN, &syms); - old_chain = make_cleanup (xfree, syms); if (context == NULL && (nsyms == 0 || SYMBOL_CLASS (syms[0].symbol) != LOC_BLOCK)) @@ -993,19 +985,18 @@ block_lookup (const struct block *context, const char *raw_name) result = SYMBOL_BLOCK_VALUE (syms[0].symbol); } - do_cleanups (old_chain); return result; } static struct symbol* -select_possible_type_sym (struct block_symbol *syms, int nsyms) +select_possible_type_sym (const std::vector &syms) { int i; int preferred_index; struct type *preferred_type; preferred_index = -1; preferred_type = NULL; - for (i = 0; i < nsyms; i += 1) + for (i = 0; i < syms.size (); i += 1) switch (SYMBOL_CLASS (syms[i].symbol)) { case LOC_TYPEDEF: @@ -1034,8 +1025,8 @@ static struct type* find_primitive_type (struct parser_state *par_state, char *name) { struct type *type; - type = language_lookup_primitive_type (parse_language (par_state), - parse_gdbarch (par_state), + type = language_lookup_primitive_type (par_state->language (), + par_state->gdbarch (), name); if (type == NULL && strcmp ("system__address", name) == 0) type = type_system_address (par_state); @@ -1049,7 +1040,7 @@ find_primitive_type (struct parser_state *par_state, char *name) (char *) alloca (strlen (name) + sizeof ("standard__")); strcpy (expanded_name, "standard__"); strcat (expanded_name, name); - sym = ada_lookup_symbol (expanded_name, NULL, VAR_DOMAIN, NULL).symbol; + sym = ada_lookup_symbol (expanded_name, NULL, VAR_DOMAIN).symbol; if (sym != NULL && SYMBOL_CLASS (sym) == LOC_TYPEDEF) type = SYMBOL_TYPE (sym); } @@ -1111,13 +1102,11 @@ static void write_ambiguous_var (struct parser_state *par_state, const struct block *block, char *name, int len) { - struct symbol *sym = XOBNEW (&temp_parse_space, struct symbol); + struct symbol *sym = new (&temp_parse_space) symbol (); - memset (sym, 0, sizeof (struct symbol)); SYMBOL_DOMAIN (sym) = UNDEF_DOMAIN; - SYMBOL_LINKAGE_NAME (sym) - = (const char *) obstack_copy0 (&temp_parse_space, name, len); - SYMBOL_LANGUAGE (sym) = language_ada; + sym->set_linkage_name (obstack_strndup (&temp_parse_space, name, len)); + sym->set_language (language_ada, nullptr); write_exp_elt_opcode (par_state, OP_VAR_VALUE); write_exp_elt_block (par_state, block); @@ -1208,15 +1197,13 @@ write_var_or_type (struct parser_state *par_state, int depth; char *encoded_name; int name_len; - struct cleanup *old_chain = make_cleanup (null_cleanup, NULL); if (block == NULL) - block = expression_context_block; + block = par_state->expression_context_block; encoded_name = ada_encode (name0.ptr); name_len = strlen (encoded_name); - encoded_name - = (char *) obstack_copy0 (&temp_parse_space, encoded_name, name_len); + encoded_name = obstack_strndup (&temp_parse_space, encoded_name, name_len); for (depth = 0; depth < MAX_RENAMING_CHAIN_LENGTH; depth += 1) { int tail_index; @@ -1225,7 +1212,7 @@ write_var_or_type (struct parser_state *par_state, while (tail_index > 0) { int nsyms; - struct block_symbol *syms; + std::vector syms; struct symbol *type_sym; struct symbol *renaming_sym; const char* renaming; @@ -1236,23 +1223,9 @@ write_var_or_type (struct parser_state *par_state, encoded_name[tail_index] = '\0'; nsyms = ada_lookup_symbol_list (encoded_name, block, VAR_DOMAIN, &syms); - make_cleanup (xfree, syms); encoded_name[tail_index] = terminator; - /* A single symbol may rename a package or object. */ - - /* This should go away when we move entirely to new version. - FIXME pnh 7/20/2007. */ - if (nsyms == 1) - { - struct symbol *ren_sym = - ada_find_renaming_symbol (syms[0].symbol, syms[0].block); - - if (ren_sym != NULL) - syms[0].symbol = ren_sym; - } - - type_sym = select_possible_type_sym (syms, nsyms); + type_sym = select_possible_type_sym (syms); if (type_sym != NULL) renaming_sym = type_sym; @@ -1283,7 +1256,6 @@ write_var_or_type (struct parser_state *par_state, write_object_renaming (par_state, block, renaming, renaming_len, renaming_expr, MAX_RENAMING_CHAIN_LENGTH); write_selectors (par_state, encoded_name + tail_index); - do_cleanups (old_chain); return NULL; default: internal_error (__FILE__, __LINE__, @@ -1295,10 +1267,7 @@ write_var_or_type (struct parser_state *par_state, struct type *field_type; if (tail_index == name_len) - { - do_cleanups (old_chain); - return SYMBOL_TYPE (type_sym); - } + return SYMBOL_TYPE (type_sym); /* We have some extraneous characters after the type name. If this is an expression "TYPE_NAME.FIELD0.[...].FIELDN", @@ -1306,10 +1275,7 @@ write_var_or_type (struct parser_state *par_state, field_type = get_symbol_field_type (type_sym, encoded_name + tail_index); if (field_type != NULL) - { - do_cleanups (old_chain); - return field_type; - } + return field_type; else error (_("Invalid attempt to select from type: \"%s\"."), name0.ptr); @@ -1320,17 +1286,13 @@ write_var_or_type (struct parser_state *par_state, encoded_name); if (type != NULL) - { - do_cleanups (old_chain); - return type; - } + return type; } if (nsyms == 1) { write_var_from_sym (par_state, syms[0].block, syms[0].symbol); write_selectors (par_state, encoded_name + tail_index); - do_cleanups (old_chain); return NULL; } else if (nsyms == 0) @@ -1342,7 +1304,6 @@ write_var_or_type (struct parser_state *par_state, write_exp_msymbol (par_state, msym); /* Maybe cause error here rather than later? FIXME? */ write_selectors (par_state, encoded_name + tail_index); - do_cleanups (old_chain); return NULL; } @@ -1358,14 +1319,13 @@ write_var_or_type (struct parser_state *par_state, write_ambiguous_var (par_state, block, encoded_name, tail_index); write_selectors (par_state, encoded_name + tail_index); - do_cleanups (old_chain); return NULL; } } if (!have_full_symbols () && !have_partial_symbols () && block == NULL) error (_("No symbol table is loaded. Use the \"file\" command.")); - if (block == expression_context_block) + if (block == par_state->expression_context_block) error (_("No definition of \"%s\" in current context."), name0.ptr); else error (_("No definition of \"%s\" in specified context."), name0.ptr); @@ -1397,17 +1357,15 @@ write_name_assoc (struct parser_state *par_state, struct stoken name) { if (strchr (name.ptr, '.') == NULL) { - struct block_symbol *syms; - int nsyms = ada_lookup_symbol_list (name.ptr, expression_context_block, + std::vector syms; + int nsyms = ada_lookup_symbol_list (name.ptr, + par_state->expression_context_block, VAR_DOMAIN, &syms); - struct cleanup *old_chain = make_cleanup (xfree, syms); if (nsyms != 1 || SYMBOL_CLASS (syms[0].symbol) == LOC_TYPEDEF) write_exp_op_with_string (par_state, OP_NAME, name); else write_var_from_sym (par_state, syms[0].block, syms[0].symbol); - - do_cleanups (old_chain); } else if (write_var_or_type (par_state, NULL, name) != NULL) @@ -1428,13 +1386,24 @@ convert_char_literal (struct type *type, LONGEST val) if (type == NULL) return val; type = check_typedef (type); - if (TYPE_CODE (type) != TYPE_CODE_ENUM) + if (type->code () != TYPE_CODE_ENUM) return val; - xsnprintf (name, sizeof (name), "QU%02x", (int) val); - for (f = 0; f < TYPE_NFIELDS (type); f += 1) + if ((val >= 'a' && val <= 'z') || (val >= '0' && val <= '9')) + xsnprintf (name, sizeof (name), "Q%c", (int) val); + else + xsnprintf (name, sizeof (name), "QU%02x", (int) val); + size_t len = strlen (name); + for (f = 0; f < type->num_fields (); f += 1) { - if (strcmp (name, TYPE_FIELD_NAME (type, f)) == 0) + /* Check the suffix because an enum constant in a package will + have a name like "pkg__QUxx". This is safe enough because we + already have the correct type, and because mangling means + there can't be clashes. */ + const char *ename = TYPE_FIELD_NAME (type, f); + size_t elen = strlen (ename); + + if (elen >= len && strcmp (name, ename + elen - len) == 0) return TYPE_FIELD_ENUMVAL (type, f); } return val; @@ -1467,8 +1436,8 @@ type_long_double (struct parser_state *par_state) static struct type * type_char (struct parser_state *par_state) { - return language_string_char_type (parse_language (par_state), - parse_gdbarch (par_state)); + return language_string_char_type (par_state->language (), + par_state->gdbarch ()); } static struct type * @@ -1481,14 +1450,15 @@ static struct type * type_system_address (struct parser_state *par_state) { struct type *type - = language_lookup_primitive_type (parse_language (par_state), - parse_gdbarch (par_state), + = language_lookup_primitive_type (par_state->language (), + par_state->gdbarch (), "system__address"); return type != NULL ? type : parse_type (par_state)->builtin_data_ptr; } +void _initialize_ada_exp (); void -_initialize_ada_exp (void) +_initialize_ada_exp () { obstack_init (&temp_parse_space); }