blob: 53f5a709caf7de11e54f36c1d2241360e268e808 [file]
/* Support code for the Ada expression parser, for GDB.
Copyright (C) 1986-2026 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "ada-exp-parser.h"
#include "ada-exp-parser-gen.h"
#include "ada-lang.h"
#include "ada-lex-gen.h"
#include "block.h"
#include "cli/cli-style.h"
#include "gdbsupport/scoped_restore.h"
#include "parser-defs.h"
using namespace expr;
/* The entry point of the bison/yacc-generated parser, defined in
ada-exp-parser-gen.c. Bison produces a declaration for ada_yyparse in
ada-exp-parser-gen.h, but byacc does not, hence this declaration. */
int ada_yyparse ();
/* Likewise, byacc does not produce a declaration for ada_yydebug. */
extern int ada_yydebug;
namespace ada_exp_parser
{
/* See ada-exp-parser.h. */
struct parser_state *pstate;
/* See ada-exp-parser.h. */
struct ada_parse_state *ada_parser;
/* See ada-exp-parser.h. */
void
canonicalizeNumeral (char *s1, const char *s2)
{
for (; *s2 != '\000'; s2 += 1)
{
if (*s2 != '_')
{
*s1 = c_tolower(*s2);
s1 += 1;
}
}
s1[0] = '\000';
}
/* See ada-exp-parser.h. */
int
processInt (struct parser_state *par_state, const char *base0,
const char *num0, const char *exp0)
{
long exp;
int base;
/* For the based literal with an "f" prefix, we'll return a
floating-point number. This counts the number of "l"s seen,
to decide the width of the floating-point number to return. -1
means no "f". */
int floating_point_l_count = -1;
if (base0 == NULL)
base = 10;
else
{
char *end_of_base;
base = strtol (base0, &end_of_base, 10);
if (base < 2 || base > 16)
error (_("Invalid base: %d."), base);
while (*end_of_base == 'l')
{
++floating_point_l_count;
++end_of_base;
}
/* This assertion is ensured by the pattern. */
gdb_assert (floating_point_l_count == -1 || *end_of_base == 'f');
if (*end_of_base == 'f')
{
++end_of_base;
++floating_point_l_count;
}
/* This assertion is ensured by the pattern. */
gdb_assert (*end_of_base == '#');
}
if (exp0 == NULL)
exp = 0;
else
exp = strtol(exp0, (char **) NULL, 10);
gdb_mpz result;
while (c_isxdigit (*num0))
{
int dig = fromhex (*num0);
if (dig >= base)
error (_("Invalid digit \"%c\" in based literal"), *num0);
result *= base;
result += dig;
++num0;
}
while (exp > 0)
{
result *= base;
exp -= 1;
}
if (floating_point_l_count > -1)
{
struct type *fp_type;
if (floating_point_l_count == 0)
fp_type = language_lookup_primitive_type (par_state->language (),
par_state->gdbarch (),
"float");
else if (floating_point_l_count == 1)
fp_type = language_lookup_primitive_type (par_state->language (),
par_state->gdbarch (),
"long_float");
else
{
/* This assertion is ensured by the pattern. */
gdb_assert (floating_point_l_count == 2);
fp_type = language_lookup_primitive_type (par_state->language (),
par_state->gdbarch (),
"long_long_float");
}
ada_yylval.typed_val_float.type = fp_type;
result.write (gdb::make_array_view (ada_yylval.typed_val_float.val,
fp_type->length ()),
type_byte_order (fp_type),
true);
return FLOAT;
}
const gdb_mpz *value = ada_parser->push_integer (std::move (result));
int int_bits = gdbarch_int_bit (par_state->gdbarch ());
int long_bits = gdbarch_long_bit (par_state->gdbarch ());
int long_long_bits = gdbarch_long_long_bit (par_state->gdbarch ());
if (fits_in_type (1, *value, int_bits, true))
ada_yylval.typed_val.type = parse_type (par_state)->builtin_int;
else if (fits_in_type (1, *value, long_bits, true))
ada_yylval.typed_val.type = parse_type (par_state)->builtin_long;
else if (fits_in_type (1, *value, long_bits, false))
ada_yylval.typed_val.type
= builtin_type (par_state->gdbarch ())->builtin_unsigned_long;
else if (fits_in_type (1, *value, long_long_bits, true))
ada_yylval.typed_val.type = parse_type (par_state)->builtin_long_long;
else if (fits_in_type (1, *value, long_long_bits, false))
ada_yylval.typed_val.type
= builtin_type (par_state->gdbarch ())->builtin_unsigned_long_long;
else if (fits_in_type (1, *value, 128, true))
ada_yylval.typed_val.type
= language_lookup_primitive_type (par_state->language (),
par_state->gdbarch (),
"long_long_long_integer");
else if (fits_in_type (1, *value, 128, false))
ada_yylval.typed_val.type
= language_lookup_primitive_type (par_state->language (),
par_state->gdbarch (),
"unsigned_long_long_long_integer");
else
error (_("Integer literal out of range"));
ada_yylval.typed_val.val = value;
return INT;
}
/* See ada-exp-parser.h. */
int
processReal (struct parser_state *par_state, const char *num0)
{
ada_yylval.typed_val_float.type = parse_type (par_state)->builtin_long_double;
bool parsed = parse_float (num0, strlen (num0),
ada_yylval.typed_val_float.type,
ada_yylval.typed_val_float.val);
gdb_assert (parsed);
return FLOAT;
}
/* See ada-exp-parser.h. */
struct stoken
processId (const char *name0, int len)
{
char *name = (char *) obstack_alloc (&ada_parser->temp_space, len + 11);
int i0, i;
struct stoken result;
result.ptr = name;
while (len > 0 && c_isspace (name0[len-1]))
len -= 1;
if (name0[0] == '<' || strstr (name0, "___") != NULL)
{
strncpy (name, name0, len);
name[len] = '\000';
result.length = len;
return result;
}
bool in_quotes = false;
i = i0 = 0;
while (i0 < len)
{
if (name0[i0] == COMPLETE_CHAR)
{
/* Just ignore. */
++i0;
}
else if (in_quotes)
name[i++] = name0[i0++];
else if (c_isalnum (name0[i0]))
{
name[i] = c_tolower (name0[i0]);
i += 1; i0 += 1;
}
else if (c_isspace (name0[i0]))
i0 += 1;
else if (name0[i0] == '\'')
{
/* Copy the starting quote, but not the ending quote. */
if (!in_quotes)
name[i++] = name0[i0++];
in_quotes = !in_quotes;
}
else
name[i++] = name0[i0++];
}
name[i] = '\000';
result.length = i;
return result;
}
/* See ada-exp-parser.h. */
struct stoken
processString (const char *text, int len)
{
const char *p;
char *q;
const char *lim = text + len;
struct stoken result;
q = (char *) obstack_alloc (&ada_parser->temp_space, len);
result.ptr = q;
p = text;
while (p < lim)
{
if (p[0] == '[' && p[1] == '"' && p+2 < lim)
{
if (p[2] == '"') /* "...["""]... */
{
*q = '"';
p += 4;
}
else
{
const char *end;
ULONGEST chr = strtoulst (p + 2, &end, 16);
if (chr > 0xff)
error (_("wide strings are not yet supported"));
*q = (char) chr;
p = end + 1;
}
}
else
*q = *p;
q += 1;
p += 1;
}
result.length = q - result.ptr;
return result;
}
/* See ada-exp-parser.h. */
int
find_dot_all (const char *str)
{
int i;
for (i = 0; str[i] != '\000'; i++)
if (str[i] == '.')
{
int i0 = i;
do
i += 1;
while (c_isspace (str[i]));
if (strncasecmp (str + i, "all", 3) == 0
&& !c_isalnum (str[i + 3]) && str[i + 3] != '_')
return i0;
}
return -1;
}
/* Returns non-zero iff string SUBSEQ matches a subsequence of STR, ignoring
case. */
static int
subseqMatch (const char *subseq, const char *str)
{
if (subseq[0] == '\0')
return 1;
else if (str[0] == '\0')
return 0;
else if (c_tolower (subseq[0]) == c_tolower (str[0]))
return subseqMatch (subseq+1, str+1) || subseqMatch (subseq, str+1);
else
return subseqMatch (subseq, str+1);
}
static const struct { const char *name; int code; }
attributes[] = {
{ "address", TICK_ADDRESS },
{ "unchecked_access", TICK_ACCESS },
{ "unrestricted_access", TICK_ACCESS },
{ "access", TICK_ACCESS },
{ "first", TICK_FIRST },
{ "last", TICK_LAST },
{ "length", TICK_LENGTH },
{ "max", TICK_MAX },
{ "min", TICK_MIN },
{ "modulus", TICK_MODULUS },
{ "object_size", TICK_OBJECT_SIZE },
{ "pos", TICK_POS },
{ "range", TICK_RANGE },
{ "size", TICK_SIZE },
{ "tag", TICK_TAG },
{ "val", TICK_VAL },
{ "enum_rep", TICK_ENUM_REP },
{ "enum_val", TICK_ENUM_VAL },
};
/* See ada-exp-parser.h. */
int
processAttribute (const char *str)
{
gdb_assert (*str == '\'');
++str;
while (c_isspace (*str))
++str;
int len = strlen (str);
if (len > 0 && str[len - 1] == COMPLETE_CHAR)
{
/* This is enforced by YY_INPUT. */
gdb_assert (pstate->parse_completion);
ada_yylval.sval.ptr = obstack_strndup (&ada_parser->temp_space,
str, len - 1);
ada_yylval.sval.length = len - 1;
return TICK_COMPLETE;
}
for (const auto &item : attributes)
if (strcasecmp (str, item.name) == 0)
return item.code;
std::optional<int> found;
for (const auto &item : attributes)
if (subseqMatch (str, item.name))
{
if (!found.has_value ())
found = item.code;
else
error (_("ambiguous attribute name: \"%s\""), str);
}
if (!found.has_value ())
error (_("unrecognized attribute: \"%s\""), str);
return *found;
}
bool
ada_tick_completer::complete (struct expression *exp,
completion_tracker &tracker)
{
completion_list output;
for (const auto &item : attributes)
{
if (strncasecmp (item.name, m_name.c_str (), m_name.length ()) == 0)
output.emplace_back (xstrdup (item.name));
}
tracker.add_completions (std::move (output));
return true;
}
/* See ada-exp-parser.h. */
void
rewind_to_char (int ch)
{
pstate->lexptr -= ada_yyleng;
while (c_toupper (*pstate->lexptr) != c_toupper (ch))
pstate->lexptr -= 1;
ada_yyrestart (NULL);
}
/* See ada-exp-parser.h. */
operation_up
resolve (operation_up &&op, bool deprocedure_p, struct type *context_type)
{
operation_up result = std::move (op);
ada_resolvable *res = dynamic_cast<ada_resolvable *> (result.get ());
if (res != nullptr)
return res->replace (std::move (result),
pstate->expout.get (),
deprocedure_p,
pstate->parse_completion,
pstate->block_tracker,
context_type);
return result;
}
/* See ada-exp-parser.h. */
operation_up
ada_pop (bool deprocedure_p, struct type *context_type)
{
/* Of course it's ok to call parser_state::pop here... */
return resolve (pstate->pop (), deprocedure_p, context_type);
}
/* See ada-exp-parser.h. */
void
ada_addrof (struct type *type)
{
operation_up arg = ada_pop (false);
operation_up addr = make_operation<unop_addr_operation> (std::move (arg));
operation_up wrapped
= make_operation<ada_wrapped_operation> (std::move (addr));
if (type != nullptr)
wrapped = make_operation<unop_cast_operation> (std::move (wrapped), type);
pstate->push (std::move (wrapped));
}
/* See ada-exp-parser.h. */
operation_up
maybe_overload (enum exp_opcode op, operation_up &lhs, operation_up &rhs)
{
struct value *args[2];
int nargs = 1;
args[0] = lhs->evaluate (nullptr, pstate->expout.get (),
EVAL_AVOID_SIDE_EFFECTS);
if (rhs == nullptr)
args[1] = nullptr;
else
{
args[1] = rhs->evaluate (nullptr, pstate->expout.get (),
EVAL_AVOID_SIDE_EFFECTS);
++nargs;
}
block_symbol fn = ada_find_operator_symbol (op, pstate->parse_completion,
nargs, args);
if (fn.symbol == nullptr)
return {};
if (symbol_read_needs_frame (fn.symbol))
pstate->block_tracker->update (fn.block, INNERMOST_BLOCK_FOR_SYMBOLS);
operation_up callee = make_operation<ada_var_value_operation> (fn);
std::vector<operation_up> argvec;
argvec.push_back (std::move (lhs));
if (rhs != nullptr)
argvec.push_back (std::move (rhs));
return make_operation<ada_funcall_operation> (std::move (callee),
std::move (argvec));
}
/* See ada-exp-parser.h. */
void
ada_funcall (int nargs)
{
/* We use the ordinary pop here, because we're going to do
resolution in a separate step, in order to handle array
indices. */
std::vector<operation_up> args = pstate->pop_vector (nargs);
/* Call parser_state::pop here, because we don't want to
function-convert the callee slot of a call we're already
constructing. */
operation_up callee = pstate->pop ();
ada_var_value_operation *vvo
= dynamic_cast<ada_var_value_operation *> (callee.get ());
int array_arity = 0;
struct type *callee_t = nullptr;
if (vvo == nullptr
|| vvo->get_symbol ()->domain () != UNDEF_DOMAIN)
{
struct value *callee_v = callee->evaluate (nullptr,
pstate->expout.get (),
EVAL_AVOID_SIDE_EFFECTS);
callee_t = ada_check_typedef (callee_v->type ());
array_arity = ada_array_arity (callee_t);
}
for (int i = 0; i < nargs; ++i)
{
struct type *subtype = nullptr;
if (i < array_arity)
subtype = ada_index_type (callee_t, i + 1, "array type");
args[i] = resolve (std::move (args[i]), true, subtype);
}
std::unique_ptr<ada_funcall_operation> funcall
(new ada_funcall_operation (std::move (callee), std::move (args)));
funcall->resolve (pstate->expout.get (), true, pstate->parse_completion,
pstate->block_tracker, nullptr);
pstate->push (std::move (funcall));
}
/* See ada-exp-parser.h. */
ada_choices_component *
choice_component ()
{
ada_component *last = ada_parser->components.back ().get ();
return gdb::checked_static_cast<ada_choices_component *> (last);
}
/* See ada-exp-parser.h. */
ada_component_up
pop_component ()
{
ada_component_up result = std::move (ada_parser->components.back ());
ada_parser->components.pop_back ();
return result;
}
/* See ada-exp-parser.h. */
std::vector<ada_component_up>
pop_components (int n)
{
std::vector<ada_component_up> result (n);
for (int i = 1; i <= n; ++i)
result[n - i] = pop_component ();
return result;
}
/* Pop the most recent association from the global stack, and return
it. */
static ada_association_up
pop_association ()
{
ada_association_up result = std::move (ada_parser->associations.back ());
ada_parser->associations.pop_back ();
return result;
}
/* See ada-exp-parser.h. */
std::vector<ada_association_up>
pop_associations (int n)
{
std::vector<ada_association_up> result (n);
for (int i = 1; i <= n; ++i)
result[n - i] = pop_association ();
return result;
}
/* See ada-exp-parser.h. */
std::unique_ptr<expr_completion_base>
make_tick_completer (struct stoken tok)
{
return (std::unique_ptr<expr_completion_base>
(new ada_tick_completer (std::string (tok.ptr, tok.length))));
}
/* Emit expression to access an instance of SYM, in block BLOCK (if
non-NULL). */
static void
write_var_from_sym (struct parser_state *par_state, block_symbol sym)
{
if (symbol_read_needs_frame (sym.symbol))
par_state->block_tracker->update (sym.block, INNERMOST_BLOCK_FOR_SYMBOLS);
par_state->push_new<ada_var_value_operation> (sym);
}
/* See ada-exp-parser.h. */
void
write_int (struct parser_state *par_state, LONGEST arg, struct type *type)
{
pstate->push_new<long_const_operation> (type, arg);
ada_wrap<ada_wrapped_operation> ();
}
/* Emit expression corresponding to the renamed object named
designated by RENAMED_ENTITY[0 .. RENAMED_ENTITY_LEN-1] in the
context of ORIG_LEFT_CONTEXT, to which is applied the operations
encoded by RENAMING_EXPR. MAX_DEPTH is the maximum number of
cascaded renamings to allow. If ORIG_LEFT_CONTEXT is null, it
defaults to the currently selected block. ORIG_SYMBOL is the
symbol that originally encoded the renaming. It is needed only
because its prefix also qualifies any index variables used to index
or slice an array. It should not be necessary once we go to the
new encoding entirely (FIXME pnh 7/20/2007). */
static void
write_object_renaming (struct parser_state *par_state,
const struct block *orig_left_context,
const char *renamed_entity, int renamed_entity_len,
const char *renaming_expr, int max_depth)
{
char *name;
enum { SIMPLE_INDEX, LOWER_BOUND, UPPER_BOUND } slice_state;
if (max_depth <= 0)
error (_("Could not find renamed symbol"));
if (orig_left_context == NULL)
orig_left_context = get_selected_block ();
name = obstack_strndup (&ada_parser->temp_space, renamed_entity,
renamed_entity_len);
block_symbol sym_info = ada_lookup_encoded_symbol (name, orig_left_context,
SEARCH_VFT);
if (sym_info.symbol == NULL)
error (_("Could not find renamed variable: %ps"),
styled_string (variable_name_style.style (),
ada_decode (name).c_str ()));
else if (sym_info.symbol->loc_class () == LOC_TYPEDEF)
/* We have a renaming of an old-style renaming symbol. Don't
trust the block information. */
sym_info.block = orig_left_context;
{
const char *inner_renamed_entity;
int inner_renamed_entity_len;
const char *inner_renaming_expr;
switch (ada_parse_renaming (sym_info.symbol, &inner_renamed_entity,
&inner_renamed_entity_len,
&inner_renaming_expr))
{
case ADA_NOT_RENAMING:
write_var_from_sym (par_state, sym_info);
break;
case ADA_OBJECT_RENAMING:
write_object_renaming (par_state, sym_info.block,
inner_renamed_entity, inner_renamed_entity_len,
inner_renaming_expr, max_depth - 1);
break;
default:
goto BadEncoding;
}
}
slice_state = SIMPLE_INDEX;
while (*renaming_expr == 'X')
{
renaming_expr += 1;
switch (*renaming_expr) {
case 'A':
renaming_expr += 1;
ada_wrap<ada_unop_ind_operation> ();
break;
case 'L':
slice_state = LOWER_BOUND;
[[fallthrough]];
case 'S':
renaming_expr += 1;
if (c_isdigit (*renaming_expr))
{
char *next;
long val = strtol (renaming_expr, &next, 10);
if (next == renaming_expr)
goto BadEncoding;
renaming_expr = next;
write_int (par_state, val, parse_type (par_state)->builtin_int);
}
else
{
const char *end;
char *index_name;
end = strchr (renaming_expr, 'X');
if (end == NULL)
end = renaming_expr + strlen (renaming_expr);
index_name = obstack_strndup (&ada_parser->temp_space,
renaming_expr,
end - renaming_expr);
renaming_expr = end;
block_symbol index_sym_info
= ada_lookup_encoded_symbol (index_name, orig_left_context,
SEARCH_VFT);
if (index_sym_info.symbol == NULL)
error (_("Could not find %s"), index_name);
else if (index_sym_info.symbol->loc_class () == LOC_TYPEDEF)
/* Index is an old-style renaming symbol. */
index_sym_info.block = orig_left_context;
write_var_from_sym (par_state, index_sym_info);
}
if (slice_state == SIMPLE_INDEX)
ada_funcall (1);
else if (slice_state == LOWER_BOUND)
slice_state = UPPER_BOUND;
else if (slice_state == UPPER_BOUND)
{
ada_wrap3<ada_ternop_slice_operation> ();
slice_state = SIMPLE_INDEX;
}
break;
case 'R':
{
const char *end;
renaming_expr += 1;
if (slice_state != SIMPLE_INDEX)
goto BadEncoding;
end = strchr (renaming_expr, 'X');
if (end == NULL)
end = renaming_expr + strlen (renaming_expr);
operation_up arg = ada_pop ();
pstate->push_new<ada_structop_operation>
(std::move (arg), std::string (renaming_expr,
end - renaming_expr));
renaming_expr = end;
break;
}
default:
goto BadEncoding;
}
}
if (slice_state == SIMPLE_INDEX)
return;
BadEncoding:
error (_("Internal error in encoding of renaming declaration"));
}
/* See ada-exp-parser.h. */
const struct block*
block_lookup (const struct block *context, const char *raw_name)
{
const char *name;
struct symtab *symtab;
const struct block *result = NULL;
std::string name_storage;
if (raw_name[0] == '\'')
{
raw_name += 1;
name = raw_name;
}
else
{
name_storage = ada_encode (raw_name);
name = name_storage.c_str ();
}
std::vector<struct block_symbol> syms
= ada_lookup_symbol_list (name, context, SEARCH_FUNCTION_DOMAIN);
if (context == NULL
&& (syms.empty () || syms[0].symbol->loc_class () != LOC_BLOCK))
symtab = lookup_symtab (current_program_space, name);
else
symtab = NULL;
if (symtab != NULL)
result = symtab->compunit ().blockvector ()->static_block ();
else if (syms.empty () || syms[0].symbol->loc_class () != LOC_BLOCK)
{
if (context == NULL)
error (_("No file or function \"%s\"."), raw_name);
else
error (_("No function \"%s\" in specified context."), raw_name);
}
else
{
if (syms.size () > 1)
warning (_("Function name \"%s\" ambiguous here"), raw_name);
result = syms[0].symbol->value_block ();
}
return result;
}
static struct symbol*
select_possible_type_sym (const std::vector<struct block_symbol> &syms)
{
int i;
int preferred_index;
struct type *preferred_type;
preferred_index = -1; preferred_type = NULL;
for (i = 0; i < syms.size (); i += 1)
switch (syms[i].symbol->loc_class ())
{
case LOC_TYPEDEF:
if (ada_prefer_type (syms[i].symbol->type (), preferred_type))
{
preferred_index = i;
preferred_type = syms[i].symbol->type ();
}
break;
case LOC_REGISTER:
case LOC_ARG:
case LOC_REF_ARG:
case LOC_REGPARM_ADDR:
case LOC_LOCAL:
case LOC_COMPUTED:
return NULL;
default:
break;
}
if (preferred_type == NULL)
return NULL;
return syms[preferred_index].symbol;
}
static struct type*
find_primitive_type (struct parser_state *par_state, const char *name)
{
struct type *type;
type = language_lookup_primitive_type (par_state->language (),
par_state->gdbarch (),
name);
if (type == NULL && streq ("system__address", name))
type = type_system_address (par_state);
if (type != NULL)
{
/* Check to see if we have a regular definition of this
type that just didn't happen to have been read yet. */
struct symbol *sym;
char *expanded_name =
(char *) alloca (strlen (name) + sizeof ("standard__"));
strcpy (expanded_name, "standard__");
strcat (expanded_name, name);
sym = ada_lookup_symbol (expanded_name, NULL, SEARCH_TYPE_DOMAIN).symbol;
if (sym != NULL && sym->loc_class () == LOC_TYPEDEF)
type = sym->type ();
}
return type;
}
static int
chop_selector (const char *name, int end)
{
int i;
for (i = end - 1; i > 0; i -= 1)
if (name[i] == '.' || (name[i] == '_' && name[i+1] == '_'))
return i;
return -1;
}
/* If NAME is a string beginning with a separator (either '__', or
'.'), chop this separator and return the result; else, return
NAME. */
static const char *
chop_separator (const char *name)
{
if (*name == '.')
return name + 1;
if (name[0] == '_' && name[1] == '_')
return name + 2;
return name;
}
/* Given that SELS is a string of the form (<sep><identifier>)*, where
<sep> is '__' or '.', write the indicated sequence of
STRUCTOP_STRUCT expression operators. Returns a pointer to the
last operation that was pushed. */
static ada_structop_operation *
write_selectors (struct parser_state *par_state, const char *sels)
{
ada_structop_operation *result = nullptr;
while (*sels != '\0')
{
const char *p = chop_separator (sels);
sels = p;
while (*sels != '\0' && *sels != '.'
&& (sels[0] != '_' || sels[1] != '_'))
sels += 1;
operation_up arg = ada_pop ();
result = new ada_structop_operation (std::move (arg),
std::string (p, sels - p));
pstate->push (operation_up (result));
}
return result;
}
/* Write a variable access (OP_VAR_VALUE) to ambiguous encoded name
NAME[0..LEN-1], in block context BLOCK, to be resolved later. Writes
a temporary symbol that is valid until the next call to ada_parse.
*/
static void
write_ambiguous_var (struct parser_state *par_state,
const struct block *block, const char *name, int len)
{
struct symbol *sym = new (&ada_parser->temp_space) symbol ();
sym->set_domain (UNDEF_DOMAIN);
sym->set_linkage_name (obstack_strndup (&ada_parser->temp_space, name, len));
sym->set_language (language_ada, nullptr);
block_symbol bsym { sym, block };
par_state->push_new<ada_var_value_operation> (bsym);
}
/* A convenient wrapper around ada_get_field_index that takes
a non NUL-terminated FIELD_NAME0 and a FIELD_NAME_LEN instead
of a NUL-terminated field name. */
static int
ada_nget_field_index (const struct type *type, const char *field_name0,
int field_name_len, int maybe_missing)
{
char *field_name = (char *) alloca ((field_name_len + 1) * sizeof (char));
strncpy (field_name, field_name0, field_name_len);
field_name[field_name_len] = '\0';
return ada_get_field_index (type, field_name, maybe_missing);
}
/* If encoded_field_name is the name of a field inside symbol SYM,
then return the type of that field. Otherwise, return NULL.
This function is actually recursive, so if ENCODED_FIELD_NAME
doesn't match one of the fields of our symbol, then try to see
if ENCODED_FIELD_NAME could not be a succession of field names
(in other words, the user entered an expression of the form
TYPE_NAME.FIELD1.FIELD2.FIELD3), in which case we evaluate
each field name sequentially to obtain the desired field type.
In case of failure, we return NULL. */
static struct type *
get_symbol_field_type (struct symbol *sym, const char *encoded_field_name)
{
const char *field_name = encoded_field_name;
const char *subfield_name;
struct type *type = sym->type ();
int fieldno;
if (type == NULL || field_name == NULL)
return NULL;
type = check_typedef (type);
while (field_name[0] != '\0')
{
field_name = chop_separator (field_name);
fieldno = ada_get_field_index (type, field_name, 1);
if (fieldno >= 0)
return type->field (fieldno).type ();
subfield_name = field_name;
while (*subfield_name != '\0' && *subfield_name != '.'
&& (subfield_name[0] != '_' || subfield_name[1] != '_'))
subfield_name += 1;
if (subfield_name[0] == '\0')
return NULL;
fieldno = ada_nget_field_index (type, field_name,
subfield_name - field_name, 1);
if (fieldno < 0)
return NULL;
type = type->field (fieldno).type ();
field_name = subfield_name;
}
return NULL;
}
/* See ada-exp-parser.h. */
struct type*
write_var_or_type (struct parser_state *par_state,
const struct block *block, struct stoken name0)
{
int depth;
char *encoded_name;
int name_len;
std::string name_storage = ada_encode (name0.ptr);
if (block == nullptr)
{
auto iter = ada_parser->iterated_associations.find (name_storage);
if (iter != ada_parser->iterated_associations.end ())
{
auto op = std::make_unique<ada_index_var_operation> ();
iter->second.push_back (op.get ());
par_state->push (std::move (op));
return nullptr;
}
block = par_state->expression_context_block;
}
name_len = name_storage.size ();
encoded_name = obstack_strndup (&ada_parser->temp_space,
name_storage.c_str (),
name_len);
for (depth = 0; depth < MAX_RENAMING_CHAIN_LENGTH; depth += 1)
{
int tail_index;
tail_index = name_len;
while (tail_index > 0)
{
struct symbol *type_sym;
struct symbol *renaming_sym;
const char* renaming;
int renaming_len;
const char* renaming_expr;
int terminator = encoded_name[tail_index];
encoded_name[tail_index] = '\0';
/* In order to avoid double-encoding, we want to only pass
the decoded form to lookup functions. */
std::string decoded_name = ada_decode (encoded_name);
encoded_name[tail_index] = terminator;
std::vector<struct block_symbol> syms
= ada_lookup_symbol_list (decoded_name.c_str (), block,
SEARCH_VFT);
type_sym = select_possible_type_sym (syms);
if (type_sym != NULL)
renaming_sym = type_sym;
else if (syms.size () == 1)
renaming_sym = syms[0].symbol;
else
renaming_sym = NULL;
switch (ada_parse_renaming (renaming_sym, &renaming,
&renaming_len, &renaming_expr))
{
case ADA_NOT_RENAMING:
break;
case ADA_PACKAGE_RENAMING:
case ADA_EXCEPTION_RENAMING:
case ADA_SUBPROGRAM_RENAMING:
{
int alloc_len = renaming_len + name_len - tail_index + 1;
char *new_name
= (char *) obstack_alloc (&ada_parser->temp_space,
alloc_len);
strncpy (new_name, renaming, renaming_len);
strcpy (new_name + renaming_len, encoded_name + tail_index);
encoded_name = new_name;
name_len = renaming_len + name_len - tail_index;
goto TryAfterRenaming;
}
case ADA_OBJECT_RENAMING:
write_object_renaming (par_state, block, renaming, renaming_len,
renaming_expr, MAX_RENAMING_CHAIN_LENGTH);
write_selectors (par_state, encoded_name + tail_index);
return NULL;
default:
internal_error (_("impossible value from ada_parse_renaming"));
}
if (type_sym != NULL)
{
struct type *field_type;
if (tail_index == name_len)
return type_sym->type ();
/* We have some extraneous characters after the type name.
If this is an expression "TYPE_NAME.FIELD0.[...].FIELDN",
then try to get the type of FIELDN. */
field_type
= get_symbol_field_type (type_sym, encoded_name + tail_index);
if (field_type != NULL)
return field_type;
else
error (_("Invalid attempt to select from type: \"%s\"."),
name0.ptr);
}
else if (tail_index == name_len && syms.empty ())
{
struct type *type = find_primitive_type (par_state,
encoded_name);
if (type != NULL)
return type;
}
if (syms.size () == 1)
{
write_var_from_sym (par_state, syms[0]);
write_selectors (par_state, encoded_name + tail_index);
return NULL;
}
else if (syms.empty ())
{
struct objfile *objfile = nullptr;
if (block != nullptr)
objfile = block->objfile ();
bound_minimal_symbol msym
= ada_lookup_simple_minsym (decoded_name.c_str (), objfile);
if (msym.minsym != NULL)
{
par_state->push_new<ada_var_msym_value_operation> (msym);
/* Maybe cause error here rather than later? FIXME? */
write_selectors (par_state, encoded_name + tail_index);
return NULL;
}
if (tail_index == name_len
&& strncmp (encoded_name, "standard__",
sizeof ("standard__") - 1) == 0)
error (_("No definition of \"%s\" found."), name0.ptr);
tail_index = chop_selector (encoded_name, tail_index);
}
else
{
write_ambiguous_var (par_state, block, encoded_name,
tail_index);
write_selectors (par_state, encoded_name + tail_index);
return NULL;
}
}
if (!current_program_space->has_full_symbols ()
&& !current_program_space->has_partial_symbols ()
&& block == NULL)
error (_("No symbol table is loaded. Use the \"%ps\" command."),
styled_string (command_style.style (), "file"));
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);
TryAfterRenaming: ;
}
error (_("Could not find renamed symbol \"%s\""), name0.ptr);
}
/* Because ada_completer_word_break_characters does not contain '.' --
and it cannot easily be added, this breaks other completions -- we
have to recreate the completion word-splitting here, so that we can
provide a prefix that is then used when completing field names.
Without this, an attempt like "complete print abc.d" will give a
result like "print def" rather than "print abc.def". */
std::string
ada_parse_state::find_completion_bounds ()
{
const char *end = pstate->lexptr;
/* First the end of the prefix. Here we stop at the token start or
at '.' or space. */
for (; end > m_original_expr && end[-1] != '.' && !c_isspace (end[-1]); --end)
{
/* Nothing. */
}
/* Now find the start of the prefix. */
const char *ptr = end;
/* Here we allow '.'. */
for (;
ptr > m_original_expr && (ptr[-1] == '.'
|| ptr[-1] == '_'
|| (ptr[-1] >= 'a' && ptr[-1] <= 'z')
|| (ptr[-1] >= 'A' && ptr[-1] <= 'Z')
|| (ptr[-1] & 0xff) >= 0x80);
--ptr)
{
/* Nothing. */
}
/* ... except, skip leading spaces. */
ptr = skip_spaces (ptr);
return std::string (ptr, end);
}
/* See ada-exp-parser.h. */
struct type *
write_var_or_type_completion (struct parser_state *par_state,
const struct block *block, struct stoken name0)
{
int tail_index = chop_selector (name0.ptr, name0.length);
/* If there's no separator, just defer to ordinary symbol
completion. */
if (tail_index == -1)
return write_var_or_type (par_state, block, name0);
std::string copy (name0.ptr, tail_index);
struct type *type = write_var_or_type (par_state, block,
{ copy.c_str (),
(int) copy.length () });
/* For completion purposes, it's enough that we return a type
here. */
if (type != nullptr)
return type;
ada_structop_operation *op = write_selectors (par_state,
name0.ptr + tail_index);
op->set_prefix (ada_parser->find_completion_bounds ());
par_state->mark_struct_expression (op);
return nullptr;
}
/* See ada-exp-parser.h. */
void
write_name_assoc (struct parser_state *par_state, struct stoken name)
{
if (strchr (name.ptr, '.') == NULL)
{
std::vector<struct block_symbol> syms
= ada_lookup_symbol_list (name.ptr,
par_state->expression_context_block,
SEARCH_VFT);
if (syms.size () != 1 || syms[0].symbol->loc_class () == LOC_TYPEDEF)
pstate->push_new<ada_string_operation> (copy_name (name));
else
write_var_from_sym (par_state, syms[0]);
}
else
if (write_var_or_type (par_state, NULL, name) != NULL)
error (_("Invalid use of type."));
push_association<ada_name_association> (ada_pop ());
}
/* See ada-exp-parser.h. */
struct type *
type_for_char (struct parser_state *par_state, ULONGEST value)
{
if (value <= 0xff)
return language_string_char_type (par_state->language (),
par_state->gdbarch ());
else if (value <= 0xffff)
return language_lookup_primitive_type (par_state->language (),
par_state->gdbarch (),
"wide_character");
return language_lookup_primitive_type (par_state->language (),
par_state->gdbarch (),
"wide_wide_character");
}
/* See ada-exp-parser.h. */
struct type *
type_system_address (struct parser_state *par_state)
{
struct type *type
= language_lookup_primitive_type (par_state->language (),
par_state->gdbarch (),
"system__address");
return type != NULL ? type : parse_type (par_state)->builtin_data_ptr;
}
/* See ada-exp-parser.h. */
void
ada_yyerror (const char *msg)
{
ada_exp_parser::pstate->parse_error (msg);
}
} /* namespace ada_exp_parser */
/* See ada-exp-parser.h. */
int
ada_parse (struct parser_state *par_state)
{
using namespace ada_exp_parser;
/* Setting up the parser state. */
scoped_restore pstate_restore = make_scoped_restore (&pstate, par_state);
gdb_assert (par_state != NULL);
ada_parse_state parser (par_state->lexptr);
scoped_restore parser_restore = make_scoped_restore (&ada_parser, &parser);
scoped_restore restore_yydebug = make_scoped_restore (&ada_yydebug,
par_state->debug);
lexer_init (ada_yyin); /* (Re-)initialize lexer. */
int result = ada_yyparse ();
if (!result)
{
struct type *context_type = nullptr;
if (par_state->void_context_p)
context_type = parse_type (par_state)->builtin_void;
pstate->set_operation (ada_pop (true, context_type));
}
return result;
}