if (noside != EVAL_AVOID_SIDE_EFFECTS)
throw;
- ret = value_zero (SYMBOL_TYPE (var), not_lval);
+ ret = value_zero (var->type (), not_lval);
}
return ret;
enum noside noside)
{
symbol *var = std::get<0> (m_storage).symbol;
- if (SYMBOL_TYPE (var)->code () == TYPE_CODE_ERROR)
+ if (var->type ()->code () == TYPE_CODE_ERROR)
error_unknown_type (var->print_name ());
return evaluate_var_value (noside, std::get<0> (m_storage).block, var);
}
NULL, std::get<0> (m_storage).symbol,
NULL, &symp, NULL, 0, noside);
- if (SYMBOL_TYPE (symp)->code () == TYPE_CODE_ERROR)
+ if (symp->type ()->code () == TYPE_CODE_ERROR)
error_unknown_type (symp->print_name ());
value *callee = evaluate_var_value (noside, std::get<0> (m_storage).block,
symp);
nullptr, expect_type);
}
+/* Helper for structop_base_operation::complete which recursively adds
+ field and method names from TYPE, a struct or union type, to the
+ OUTPUT list. PREFIX is prepended to each result. */
+
+static void
+add_struct_fields (struct type *type, completion_list &output,
+ const char *fieldname, int namelen, const char *prefix)
+{
+ int i;
+ int computed_type_name = 0;
+ const char *type_name = NULL;
+
+ type = check_typedef (type);
+ for (i = 0; i < type->num_fields (); ++i)
+ {
+ if (i < TYPE_N_BASECLASSES (type))
+ add_struct_fields (TYPE_BASECLASS (type, i),
+ output, fieldname, namelen, prefix);
+ else if (type->field (i).name ())
+ {
+ if (type->field (i).name ()[0] != '\0')
+ {
+ if (! strncmp (type->field (i).name (),
+ fieldname, namelen))
+ output.emplace_back (concat (prefix, type->field (i).name (),
+ nullptr));
+ }
+ else if (type->field (i).type ()->code () == TYPE_CODE_UNION)
+ {
+ /* Recurse into anonymous unions. */
+ add_struct_fields (type->field (i).type (),
+ output, fieldname, namelen, prefix);
+ }
+ }
+ }
+
+ for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
+ {
+ const char *name = TYPE_FN_FIELDLIST_NAME (type, i);
+
+ if (name && ! strncmp (name, fieldname, namelen))
+ {
+ if (!computed_type_name)
+ {
+ type_name = type->name ();
+ computed_type_name = 1;
+ }
+ /* Omit constructors from the completion list. */
+ if (!type_name || strcmp (type_name, name))
+ output.emplace_back (concat (prefix, name, nullptr));
+ }
+ }
+}
+
+/* See expop.h. */
+
+bool
+structop_base_operation::complete (struct expression *exp,
+ completion_tracker &tracker,
+ const char *prefix)
+{
+ const std::string &fieldname = std::get<1> (m_storage);
+
+ value *lhs = std::get<0> (m_storage)->evaluate (nullptr, exp,
+ EVAL_AVOID_SIDE_EFFECTS);
+ struct type *type = value_type (lhs);
+ for (;;)
+ {
+ type = check_typedef (type);
+ if (!type->is_pointer_or_reference ())
+ break;
+ type = TYPE_TARGET_TYPE (type);
+ }
+
+ if (type->code () == TYPE_CODE_UNION
+ || type->code () == TYPE_CODE_STRUCT)
+ {
+ completion_list result;
+
+ add_struct_fields (type, result, fieldname.c_str (),
+ fieldname.length (), prefix);
+ tracker.add_completions (std::move (result));
+ return true;
+ }
+
+ return false;
+}
} /* namespace expr */
enum noside noside, symbol *sym)
{
if (noside == EVAL_AVOID_SIDE_EFFECTS)
- return value_zero (SYMBOL_TYPE (sym), not_lval);
+ return value_zero (sym->type (), not_lval);
if (SYMBOL_COMPUTED_OPS (sym) == NULL
|| SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry == NULL)
return val;
}
-/* Helper function that implements the body of OP_STRING. */
+namespace expr
+{
-struct value *
-eval_op_string (struct type *expect_type, struct expression *exp,
- enum noside noside, int len, const char *string)
+value *
+string_operation::evaluate (struct type *expect_type,
+ struct expression *exp,
+ enum noside noside)
{
+ const std::string &str = std::get<0> (m_storage);
struct type *type = language_string_char_type (exp->language_defn,
exp->gdbarch);
- return value_string (string, len, type);
+ return value_string (str.c_str (), str.size (), type);
}
+} /* namespace expr */
+
/* Helper function that implements the body of OP_OBJC_SELECTOR. */
struct value *
lookup_child_selector (exp->gdbarch, sel));
}
-/* Helper function that implements the body of BINOP_CONCAT. */
-
-struct value *
-eval_op_concat (struct type *expect_type, struct expression *exp,
- enum noside noside, struct value *arg1, struct value *arg2)
-{
- if (binop_user_defined_p (BINOP_CONCAT, arg1, arg2))
- return value_x_binop (arg1, arg2, BINOP_CONCAT, OP_NULL, noside);
- else
- return value_concat (arg1, arg2);
-}
-
/* A helper function for TERNOP_SLICE. */
struct value *
NON_METHOD,
nullptr, nullptr,
nullptr, &symp, nullptr, 0, noside);
- if (SYMBOL_TYPE (symp)->code () == TYPE_CODE_ERROR)
+ if (symp->type ()->code () == TYPE_CODE_ERROR)
error_unknown_type (symp->print_name ());
value *callee = evaluate_var_value (noside, std::get<1> (m_storage), symp);
return evaluate_subexp_do_call (exp, noside, callee, args,
return value_array (tem2, tem3, argvec);
}
+value *
+unop_extract_operation::evaluate (struct type *expect_type,
+ struct expression *exp,
+ enum noside noside)
+{
+ value *old_value = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
+ struct type *type = get_type ();
+
+ if (TYPE_LENGTH (type) > TYPE_LENGTH (value_type (old_value)))
+ error (_("length type is larger than the value type"));
+
+ struct value *result = allocate_value (type);
+ value_contents_copy (result, 0, old_value, 0, TYPE_LENGTH (type));
+ return result;
+}
+
}
\f
/* C++: The "address" of a reference should yield the address
* of the object pointed to. Let value_addr() deal with it. */
- if (TYPE_IS_REFERENCE (SYMBOL_TYPE (var)))
+ if (TYPE_IS_REFERENCE (var->type ()))
return operation::evaluate_for_address (exp, noside);
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
- struct type *type = lookup_pointer_type (SYMBOL_TYPE (var));
+ struct type *type = lookup_pointer_type (var->type ());
enum address_class sym_class = var->aclass ();
if (sym_class == LOC_CONST
enum noside noside)
{
struct symbol *var = std::get<0> (m_storage).symbol;
- struct type *type = check_typedef (SYMBOL_TYPE (var));
+ struct type *type = check_typedef (var->type ());
if (type->code () == TYPE_CODE_ARRAY
&& !type->is_vector ()
&& CAST_IS_CONVERSION (exp->language_defn))
var_value_operation::evaluate_for_sizeof (struct expression *exp,
enum noside noside)
{
- struct type *type = SYMBOL_TYPE (std::get<0> (m_storage).symbol);
+ struct type *type = std::get<0> (m_storage).symbol->type ();
if (is_dynamic_type (type))
{
value *val = evaluate (nullptr, exp, EVAL_NORMAL);