};
\f
/* Global variables declared in parser-defs.h (and commented there). */
-const struct block *expression_context_block;
-CORE_ADDR expression_context_pc;
innermost_block_tracker innermost_block;
int arglist_len;
static struct type_stack type_stack;
const char *lexptr;
const char *prev_lexptr;
-int paren_depth;
-int comma_terminates;
/* True if parsing an expression to attempt completion. */
int parse_completion;
int, int *,
innermost_block_tracker_types);
+static void increase_expout_size (struct expr_builder *ps, size_t lenelt);
+
+
/* Documented at it's declaration. */
void
/* See definition in parser-defs.h. */
-parser_state::parser_state (size_t initial_size,
- const struct language_defn *lang,
+expr_builder::expr_builder (const struct language_defn *lang,
struct gdbarch *gdbarch)
- : expout_size (initial_size),
+ : expout_size (10),
expout (XNEWVAR (expression,
(sizeof (expression)
+ EXP_ELEM_TO_BYTES (expout_size)))),
}
expression_up
-parser_state::release ()
+expr_builder::release ()
{
/* Record the actual number of expression elements, and then
reallocate the expression memory so that we free up any
a register through here. */
static void
-write_exp_elt (struct parser_state *ps, const union exp_element *expelt)
+write_exp_elt (struct expr_builder *ps, const union exp_element *expelt)
{
if (ps->expout_ptr >= ps->expout_size)
{
}
void
-write_exp_elt_opcode (struct parser_state *ps, enum exp_opcode expelt)
+write_exp_elt_opcode (struct expr_builder *ps, enum exp_opcode expelt)
{
union exp_element tmp;
}
void
-write_exp_elt_sym (struct parser_state *ps, struct symbol *expelt)
+write_exp_elt_sym (struct expr_builder *ps, struct symbol *expelt)
{
union exp_element tmp;
}
void
-write_exp_elt_msym (struct parser_state *ps, minimal_symbol *expelt)
+write_exp_elt_msym (struct expr_builder *ps, minimal_symbol *expelt)
{
union exp_element tmp;
}
void
-write_exp_elt_block (struct parser_state *ps, const struct block *b)
+write_exp_elt_block (struct expr_builder *ps, const struct block *b)
{
union exp_element tmp;
}
void
-write_exp_elt_objfile (struct parser_state *ps, struct objfile *objfile)
+write_exp_elt_objfile (struct expr_builder *ps, struct objfile *objfile)
{
union exp_element tmp;
}
void
-write_exp_elt_longcst (struct parser_state *ps, LONGEST expelt)
+write_exp_elt_longcst (struct expr_builder *ps, LONGEST expelt)
{
union exp_element tmp;
}
void
-write_exp_elt_floatcst (struct parser_state *ps, const gdb_byte expelt[16])
+write_exp_elt_floatcst (struct expr_builder *ps, const gdb_byte expelt[16])
{
union exp_element tmp;
int index;
}
void
-write_exp_elt_type (struct parser_state *ps, struct type *expelt)
+write_exp_elt_type (struct expr_builder *ps, struct type *expelt)
{
union exp_element tmp;
}
void
-write_exp_elt_intern (struct parser_state *ps, struct internalvar *expelt)
+write_exp_elt_intern (struct expr_builder *ps, struct internalvar *expelt)
{
union exp_element tmp;
void
-write_exp_string (struct parser_state *ps, struct stoken str)
+write_exp_string (struct expr_builder *ps, struct stoken str)
{
int len = str.length;
size_t lenelt;
long constant, followed by the contents of the string. */
void
-write_exp_string_vector (struct parser_state *ps, int type,
+write_exp_string_vector (struct expr_builder *ps, int type,
struct stoken_vector *vec)
{
int i, len;
either end of the bitstring. */
void
-write_exp_bitstring (struct parser_state *ps, struct stoken str)
+write_exp_bitstring (struct expr_builder *ps, struct stoken str)
{
int bits = str.length; /* length in bits */
int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
the expression. */
void
-write_exp_msymbol (struct parser_state *ps,
+write_exp_msymbol (struct expr_builder *ps,
struct bound_minimal_symbol bound_msym)
{
write_exp_elt_opcode (ps, OP_VAR_MSYM_VALUE);
expression. This is used when completing on field names. */
void
-mark_struct_expression (struct parser_state *ps)
+mark_struct_expression (struct expr_builder *ps)
{
gdb_assert (parse_completion
&& expout_tag_completion_type == TYPE_CODE_UNDEF);
/* Handle tokens that refer to machine registers:
$ followed by a register name. */
- i = user_reg_map_name_to_regnum (parse_gdbarch (ps),
+ i = user_reg_map_name_to_regnum (ps->gdbarch (),
str.ptr + 1, str.length - 1);
if (i >= 0)
goto handle_register;
str.ptr++;
write_exp_string (ps, str);
write_exp_elt_opcode (ps, OP_REGISTER);
- innermost_block.update (expression_context_block,
+ innermost_block.update (ps->expression_context_block,
INNERMOST_BLOCK_FOR_REGISTERS);
return;
}
lexptr = *stringptr;
prev_lexptr = NULL;
- paren_depth = 0;
type_stack.elements.clear ();
expout_last_struct = -1;
expout_tag_completion_type = TYPE_CODE_UNDEF;
expout_completion_name.reset ();
innermost_block.reset (tracker_types);
- comma_terminates = comma;
-
if (lexptr == 0 || *lexptr == 0)
error_no_arg (_("expression to compute"));
scoped_restore save_funcall_chain = make_scoped_restore (&funcall_chain,
&funcalls);
- expression_context_block = block;
+ const struct block *expression_context_block = block;
+ CORE_ADDR expression_context_pc = 0;
/* If no context specified, try using the current frame, if any. */
if (!expression_context_block)
and others called from *.y) ensure CURRENT_LANGUAGE gets restored
to the value matching SELECTED_FRAME as set by get_current_arch. */
- parser_state ps (10, lang, get_current_arch ());
+ parser_state ps (lang, get_current_arch (), expression_context_block,
+ expression_context_pc, comma);
scoped_restore_current_language lang_saver;
set_language (lang->la_language);
item. */
void
-insert_type_address_space (struct parser_state *pstate, char *string)
+insert_type_address_space (struct expr_builder *pstate, char *string)
{
union type_stack_elt element;
int slot;
element.piece = tp_space_identifier;
insert_into_type_stack (slot, element);
- element.int_val = address_space_name_to_int (parse_gdbarch (pstate),
+ element.int_val = address_space_name_to_int (pstate->gdbarch (),
string);
insert_into_type_stack (slot, element);
}
return exp_iterate (exp, exp_uses_objfile_iter, objfile);
}
-/* See definition in parser-defs.h. */
+/* Reallocate the `expout' pointer inside PS so that it can accommodate
+ at least LENELT expression elements. This function does nothing if
+ there is enough room for the elements. */
-void
-increase_expout_size (struct parser_state *ps, size_t lenelt)
+static void
+increase_expout_size (struct expr_builder *ps, size_t lenelt)
{
if ((ps->expout_ptr + lenelt) >= ps->expout_size)
{
projects / deliverable / binutils-gdb.git / blobdiff