/* Parse expressions for GDB.
- Copyright (C) 1986-2018 Free Software Foundation, Inc.
+ Copyright (C) 1986-2019 Free Software Foundation, Inc.
Modified from expread.y by the Department of Computer Science at the
State University of New York at Buffalo, 1991.
int
prefixify_expression (struct expression *expr)
{
+ gdb_assert (expr->nelts > 0);
int len = sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
struct expression *temp;
int inpos = expr->nelts, outpos = 0;
prev_lexptr = NULL;
paren_depth = 0;
- type_stack.depth = 0;
+ type_stack.elements.clear ();
expout_last_struct = -1;
expout_tag_completion_type = TYPE_CODE_UNDEF;
expout_completion_name.reset ();
if (!expression_context_block)
expression_context_block = get_selected_block (&expression_context_pc);
else if (pc == 0)
- expression_context_pc = BLOCK_START (expression_context_block);
+ expression_context_pc = BLOCK_ENTRY_PC (expression_context_block);
else
expression_context_pc = pc;
= BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (cursal.symtab),
STATIC_BLOCK);
if (expression_context_block)
- expression_context_pc = BLOCK_START (expression_context_block);
+ expression_context_pc = BLOCK_ENTRY_PC (expression_context_block);
}
if (language_mode == language_mode_auto && block != NULL)
}
CATCH (except, RETURN_MASK_ALL)
{
- if (! parse_completion)
+ /* If parsing for completion, allow this to succeed; but if no
+ expression elements have been written, then there's nothing
+ to do, so fail. */
+ if (! parse_completion || ps.expout_ptr == 0)
throw_exception (except);
}
END_CATCH
/* Stuff for maintaining a stack of types. Currently just used by C, but
probably useful for any language which declares its types "backwards". */
-/* Ensure that there are HOWMUCH open slots on the type stack STACK. */
-
-static void
-type_stack_reserve (struct type_stack *stack, int howmuch)
-{
- if (stack->depth + howmuch >= stack->size)
- {
- stack->size *= 2;
- if (stack->size < howmuch)
- stack->size = howmuch;
- stack->elements = XRESIZEVEC (union type_stack_elt, stack->elements,
- stack->size);
- }
-}
-
-/* Ensure that there is a single open slot in the global type stack. */
-
-static void
-check_type_stack_depth (void)
-{
- type_stack_reserve (&type_stack, 1);
-}
-
/* A helper function for insert_type and insert_type_address_space.
This does work of expanding the type stack and inserting the new
element, ELEMENT, into the stack at location SLOT. */
static void
insert_into_type_stack (int slot, union type_stack_elt element)
{
- check_type_stack_depth ();
-
- if (slot < type_stack.depth)
- memmove (&type_stack.elements[slot + 1], &type_stack.elements[slot],
- (type_stack.depth - slot) * sizeof (union type_stack_elt));
- type_stack.elements[slot] = element;
- ++type_stack.depth;
+ gdb_assert (slot <= type_stack.elements.size ());
+ type_stack.elements.insert (type_stack.elements.begin () + slot, element);
}
/* Insert a new type, TP, at the bottom of the type stack. If TP is
/* If there is anything on the stack (we know it will be a
tp_pointer), insert the qualifier above it. Otherwise, simply
push this on the top of the stack. */
- if (type_stack.depth && (tp == tp_const || tp == tp_volatile))
+ if (!type_stack.elements.empty () && (tp == tp_const || tp == tp_volatile))
slot = 1;
else
slot = 0;
void
push_type (enum type_pieces tp)
{
- check_type_stack_depth ();
- type_stack.elements[type_stack.depth++].piece = tp;
+ type_stack_elt elt;
+ elt.piece = tp;
+ type_stack.elements.push_back (elt);
}
void
push_type_int (int n)
{
- check_type_stack_depth ();
- type_stack.elements[type_stack.depth++].int_val = n;
+ type_stack_elt elt;
+ elt.int_val = n;
+ type_stack.elements.push_back (elt);
}
/* Insert a tp_space_identifier and the corresponding address space
/* If there is anything on the stack (we know it will be a
tp_pointer), insert the address space qualifier above it.
Otherwise, simply push this on the top of the stack. */
- if (type_stack.depth)
+ if (!type_stack.elements.empty ())
slot = 1;
else
slot = 0;
enum type_pieces
pop_type (void)
{
- if (type_stack.depth)
- return type_stack.elements[--type_stack.depth].piece;
+ if (!type_stack.elements.empty ())
+ {
+ type_stack_elt elt = type_stack.elements.back ();
+ type_stack.elements.pop_back ();
+ return elt.piece;
+ }
return tp_end;
}
int
pop_type_int (void)
{
- if (type_stack.depth)
- return type_stack.elements[--type_stack.depth].int_val;
+ if (!type_stack.elements.empty ())
+ {
+ type_stack_elt elt = type_stack.elements.back ();
+ type_stack.elements.pop_back ();
+ return elt.int_val;
+ }
/* "Can't happen". */
return 0;
}
/* Pop a type list element from the global type stack. */
-static VEC (type_ptr) *
+static std::vector<struct type *> *
pop_typelist (void)
{
- gdb_assert (type_stack.depth);
- return type_stack.elements[--type_stack.depth].typelist_val;
+ gdb_assert (!type_stack.elements.empty ());
+ type_stack_elt elt = type_stack.elements.back ();
+ type_stack.elements.pop_back ();
+ return elt.typelist_val;
}
/* Pop a type_stack element from the global type stack. */
static struct type_stack *
pop_type_stack (void)
{
- gdb_assert (type_stack.depth);
- return type_stack.elements[--type_stack.depth].stack_val;
+ gdb_assert (!type_stack.elements.empty ());
+ type_stack_elt elt = type_stack.elements.back ();
+ type_stack.elements.pop_back ();
+ return elt.stack_val;
}
/* Append the elements of the type stack FROM to the type stack TO.
struct type_stack *
append_type_stack (struct type_stack *to, struct type_stack *from)
{
- type_stack_reserve (to, from->depth);
-
- memcpy (&to->elements[to->depth], &from->elements[0],
- from->depth * sizeof (union type_stack_elt));
- to->depth += from->depth;
-
+ to->elements.insert (to->elements.end (), from->elements.begin (),
+ from->elements.end ());
return to;
}
void
push_type_stack (struct type_stack *stack)
{
- check_type_stack_depth ();
- type_stack.elements[type_stack.depth++].stack_val = stack;
+ type_stack_elt elt;
+ elt.stack_val = stack;
+ type_stack.elements.push_back (elt);
push_type (tp_type_stack);
}
/* Copy the global type stack into a newly allocated type stack and
return it. The global stack is cleared. The returned type stack
- must be freed with type_stack_cleanup. */
+ must be freed with delete. */
struct type_stack *
get_type_stack (void)
{
- struct type_stack *result = XNEW (struct type_stack);
-
- *result = type_stack;
- type_stack.depth = 0;
- type_stack.size = 0;
- type_stack.elements = NULL;
-
+ struct type_stack *result = new struct type_stack (std::move (type_stack));
+ type_stack.elements.clear ();
return result;
}
-/* A cleanup function that destroys a single type stack. */
-
-void
-type_stack_cleanup (void *arg)
-{
- struct type_stack *stack = (struct type_stack *) arg;
-
- xfree (stack->elements);
- xfree (stack);
-}
-
/* Push a function type with arguments onto the global type stack.
LIST holds the argument types. If the final item in LIST is NULL,
then the function will be varargs. */
void
-push_typelist (VEC (type_ptr) *list)
+push_typelist (std::vector<struct type *> *list)
{
- check_type_stack_depth ();
- type_stack.elements[type_stack.depth++].typelist_val = list;
+ type_stack_elt elt;
+ elt.typelist_val = list;
+ type_stack.elements.push_back (elt);
push_type (tp_function_with_arguments);
}
case tp_function_with_arguments:
{
- VEC (type_ptr) *args = pop_typelist ();
+ std::vector<struct type *> *args = pop_typelist ();
follow_type
= lookup_function_type_with_arguments (follow_type,
- VEC_length (type_ptr, args),
- VEC_address (type_ptr,
- args));
- VEC_free (type_ptr, args);
+ args->size (),
+ args->data ());
}
break;
type_stack = *stack;
follow_type = follow_types (follow_type);
- gdb_assert (type_stack.depth == 0);
+ gdb_assert (type_stack.elements.empty ());
type_stack = save;
}
for (arg = 0; arg < nargs; arg++)
{
- struct type *type = elts[pos + 3 + arg].type;
- struct objfile *objfile = TYPE_OBJFILE (type);
+ struct type *inst_type = elts[pos + 3 + arg].type;
+ struct objfile *inst_objfile = TYPE_OBJFILE (inst_type);
- if (objfile && (*objfile_func) (objfile, data))
+ if (inst_objfile && (*objfile_func) (inst_objfile, data))
return 1;
}
}
void
_initialize_parse (void)
{
- type_stack.size = 0;
- type_stack.depth = 0;
- type_stack.elements = NULL;
-
add_setshow_zuinteger_cmd ("expression", class_maintenance,
&expressiondebug,
_("Set expression debugging."),