#include "inferior.h" /* for NUM_PSEUDO_REGS. NOTE: replace
with "gdbarch.h" when appropriate. */
#include "doublest.h"
-#include "builtin-regs.h"
#include "gdb_assert.h"
+#include "block.h"
+/* Standard set of definitions for printing, dumping, prefixifying,
+ * and evaluating expressions. */
+
+const struct exp_descriptor exp_descriptor_standard =
+ {
+ print_subexp_standard,
+ operator_length_standard,
+ op_name_standard,
+ dump_subexp_body_standard,
+ evaluate_subexp_standard
+ };
\f
/* Symbols which architectures can redefine. */
static void prefixify_expression (struct expression *);
-static void
-prefixify_subexp (struct expression *, struct expression *, int, int);
+static void prefixify_subexp (struct expression *, struct expression *, int,
+ int);
void _initialize_parse (void);
static struct funcall *funcall_chain;
-/* The generic method for targets to specify how their registers are
- named. The mapping can be derived from two sources: REGISTER_NAME;
- or builtin regs. */
-
-int
-target_map_name_to_register (char *str, int len)
-{
- int i;
-
- /* Search register name space. */
- for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
- if (REGISTER_NAME (i) && len == strlen (REGISTER_NAME (i))
- && STREQN (str, REGISTER_NAME (i), len))
- {
- return i;
- }
-
- /* Try builtin registers. */
- i = builtin_reg_map_name_to_regnum (str, len);
- if (i >= 0)
- {
- gdb_assert (i >= NUM_REGS + NUM_PSEUDO_REGS);
- return i;
- }
-
- /* Try builtin registers. */
- i = builtin_reg_map_name_to_regnum (str, len);
- if (i >= 0)
- {
- gdb_assert (i >= NUM_REGS + NUM_PSEUDO_REGS);
- return i;
- }
-
- return -1;
-}
-
/* Begin counting arguments for a function call,
saving the data about any containing call. */
void
start_arglist (void)
{
- register struct funcall *new;
+ struct funcall *new;
new = (struct funcall *) xmalloc (sizeof (struct funcall));
new->next = funcall_chain;
int
end_arglist (void)
{
- register int val = arglist_len;
- register struct funcall *call = funcall_chain;
+ int val = arglist_len;
+ struct funcall *call = funcall_chain;
funcall_chain = call->next;
arglist_len = call->arglist_len;
xfree (call);
static void
free_funcalls (void *ignore)
{
- register struct funcall *call, *next;
+ struct funcall *call, *next;
for (call = funcall_chain; call; call = next)
{
void
write_exp_string (struct stoken str)
{
- register int len = str.length;
- register int lenelt;
- register char *strdata;
+ int len = str.length;
+ int lenelt;
+ char *strdata;
/* Compute the number of expression elements required to hold the string
(including a null byte terminator), along with one expression element
void
write_exp_bitstring (struct stoken str)
{
- register int bits = str.length; /* length in bits */
- register int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
- register int lenelt;
- register char *strdata;
+ int bits = str.length; /* length in bits */
+ int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
+ int lenelt;
+ char *strdata;
/* Compute the number of expression elements required to hold the bitstring,
along with one expression element at each end to record the actual
/* Handle tokens that refer to machine registers:
$ followed by a register name. */
- i = target_map_name_to_register (str.ptr + 1, str.length - 1);
+ i = frame_map_name_to_regnum (deprecated_selected_frame,
+ str.ptr + 1, str.length - 1);
if (i >= 0)
goto handle_register;
symbol table lookup performance is awful, to put it mildly. */
sym = lookup_symbol (copy_name (str), (struct block *) NULL,
- VAR_NAMESPACE, (int *) NULL, (struct symtab **) NULL);
+ VAR_DOMAIN, (int *) NULL, (struct symtab **) NULL);
if (sym)
{
write_exp_elt_opcode (OP_VAR_VALUE);
consider *prefixes* of the string; there is no need to look up
"B::C" separately as a symbol in the previous example. */
- register char *p;
+ char *p;
char *start, *end;
char *prefix = NULL;
char *tmp;
if (!done)
{
/* More tokens to process, so this must be a class/namespace */
- sym_class = lookup_symbol (prefix, 0, STRUCT_NAMESPACE,
+ sym_class = lookup_symbol (prefix, 0, STRUCT_DOMAIN,
0, (struct symtab **) NULL);
}
else
{
/* No more tokens, so try as a variable first */
- sym_var = lookup_symbol (prefix, 0, VAR_NAMESPACE,
+ sym_var = lookup_symbol (prefix, 0, VAR_DOMAIN,
0, (struct symtab **) NULL);
/* If failed, try as class/namespace */
if (!sym_var)
- sym_class = lookup_symbol (prefix, 0, STRUCT_NAMESPACE,
+ sym_class = lookup_symbol (prefix, 0, STRUCT_DOMAIN,
0, (struct symtab **) NULL);
}
to prefix form (in which we can conveniently print or execute it). */
static void
-prefixify_expression (register struct expression *expr)
+prefixify_expression (struct expression *expr)
{
- register int len =
+ int len =
sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
- register struct expression *temp;
- register int inpos = expr->nelts, outpos = 0;
+ struct expression *temp;
+ int inpos = expr->nelts, outpos = 0;
temp = (struct expression *) alloca (len);
prefixify_subexp (temp, expr, inpos, outpos);
}
-/* Return the number of exp_elements in the subexpression of EXPR
- whose last exp_element is at index ENDPOS - 1 in EXPR. */
+/* Return the number of exp_elements in the postfix subexpression
+ of EXPR whose operator is at index ENDPOS - 1 in EXPR. */
int
-length_of_subexp (register struct expression *expr, register int endpos)
+length_of_subexp (struct expression *expr, int endpos)
{
- register int oplen = 1;
- register int args = 0;
- register int i;
+ int oplen, args, i;
+
+ operator_length (expr, endpos, &oplen, &args);
+
+ while (args > 0)
+ {
+ oplen += length_of_subexp (expr, endpos - oplen);
+ args--;
+ }
+
+ return oplen;
+}
+
+/* Sets *OPLENP to the length of the operator whose (last) index is
+ ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
+ operator takes. */
+
+void
+operator_length (struct expression *expr, int endpos, int *oplenp, int *argsp)
+{
+ expr->language_defn->la_exp_desc->operator_length (expr, endpos,
+ oplenp, argsp);
+}
+
+/* Default value for operator_length in exp_descriptor vectors. */
+
+void
+operator_length_standard (struct expression *expr, int endpos,
+ int *oplenp, int *argsp)
+{
+ int oplen = 1;
+ int args = 0;
+ int i;
if (endpos < 1)
- error ("?error in length_of_subexp");
+ error ("?error in operator_length_standard");
i = (int) expr->elts[endpos - 1].opcode;
args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
break;
- case OP_MSGCALL: /* Objective C message (method) call */
+ case OP_OBJC_MSGCALL: /* Objective C message (method) call */
oplen = 4;
args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
break;
/* fall through */
case OP_M2_STRING:
case OP_STRING:
- case OP_NSSTRING: /* Objective C Foundation Class NSString constant */
- case OP_SELECTOR: /* Objective C "@selector" pseudo-op */
+ case OP_OBJC_NSSTRING: /* Objective C Foundation Class NSString constant */
+ case OP_OBJC_SELECTOR: /* Objective C "@selector" pseudo-op */
case OP_NAME:
case OP_EXPRSTRING:
oplen = longest_to_int (expr->elts[endpos - 2].longconst);
/* C++ */
case OP_THIS:
- case OP_SELF:
+ case OP_OBJC_SELF:
oplen = 2;
break;
args = 1 + (i < (int) BINOP_END);
}
- while (args > 0)
- {
- oplen += length_of_subexp (expr, endpos - oplen);
- args--;
- }
-
- return oplen;
+ *oplenp = oplen;
+ *argsp = args;
}
/* Copy the subexpression ending just before index INEND in INEXPR
In the process, convert it from suffix to prefix form. */
static void
-prefixify_subexp (register struct expression *inexpr,
- struct expression *outexpr, register int inend, int outbeg)
+prefixify_subexp (struct expression *inexpr,
+ struct expression *outexpr, int inend, int outbeg)
{
- register int oplen = 1;
- register int args = 0;
- register int i;
+ int oplen;
+ int args;
+ int i;
int *arglens;
enum exp_opcode opcode;
- /* Compute how long the last operation is (in OPLEN),
- and also how many preceding subexpressions serve as
- arguments for it (in ARGS). */
-
- opcode = inexpr->elts[inend - 1].opcode;
- switch (opcode)
- {
- /* C++ */
- case OP_SCOPE:
- oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
- oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
- break;
-
- case OP_LONG:
- case OP_DOUBLE:
- case OP_VAR_VALUE:
- oplen = 4;
- break;
-
- case OP_TYPE:
- case OP_BOOL:
- case OP_LAST:
- case OP_REGISTER:
- case OP_INTERNALVAR:
- oplen = 3;
- break;
-
- case OP_COMPLEX:
- oplen = 1;
- args = 2;
- break;
-
- case OP_FUNCALL:
- case OP_F77_UNDETERMINED_ARGLIST:
- oplen = 3;
- args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst);
- break;
-
- case OP_MSGCALL: /* Objective C message (method) call */
- oplen = 4;
- args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst);
- break;
-
- case UNOP_MIN:
- case UNOP_MAX:
- oplen = 3;
- break;
-
- case UNOP_CAST:
- case UNOP_MEMVAL:
- oplen = 3;
- args = 1;
- break;
-
- case UNOP_ABS:
- case UNOP_CAP:
- case UNOP_CHR:
- case UNOP_FLOAT:
- case UNOP_HIGH:
- case UNOP_ODD:
- case UNOP_ORD:
- case UNOP_TRUNC:
- oplen = 1;
- args = 1;
- break;
-
- case STRUCTOP_STRUCT:
- case STRUCTOP_PTR:
- case OP_LABELED:
- args = 1;
- /* fall through */
- case OP_M2_STRING:
- case OP_STRING:
- case OP_NSSTRING: /* Objective C Foundation Class NSString constant */
- case OP_SELECTOR: /* Objective C "@selector" pseudo-op */
- case OP_NAME:
- case OP_EXPRSTRING:
- oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
- oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
- break;
-
- case OP_BITSTRING:
- oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
- oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
- oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
- break;
-
- case OP_ARRAY:
- oplen = 4;
- args = longest_to_int (inexpr->elts[inend - 2].longconst);
- args -= longest_to_int (inexpr->elts[inend - 3].longconst);
- args += 1;
- break;
-
- case TERNOP_COND:
- case TERNOP_SLICE:
- case TERNOP_SLICE_COUNT:
- args = 3;
- break;
-
- case BINOP_ASSIGN_MODIFY:
- oplen = 3;
- args = 2;
- break;
-
- /* Modula-2 */
- case MULTI_SUBSCRIPT:
- oplen = 3;
- args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst);
- break;
-
- /* C++ */
- case OP_THIS:
- case OP_SELF:
- oplen = 2;
- break;
-
- default:
- args = 1 + ((int) opcode < (int) BINOP_END);
- }
+ operator_length (inexpr, inend, &oplen, &args);
/* Copy the final operator itself, from the end of the input
to the beginning of the output. */
if (block)
{
expression_context_block = block;
- expression_context_pc = block->startaddr;
+ expression_context_pc = BLOCK_START (block);
}
else
expression_context_block = get_selected_block (&expression_context_pc);
parser, to a prefix form. */
if (expressiondebug)
- dump_prefix_expression (expout, gdb_stdlog,
- "before conversion to prefix form");
+ dump_raw_expression (expout, gdb_stdlog,
+ "before conversion to prefix form");
prefixify_expression (expout);
if (expressiondebug)
- dump_postfix_expression (expout, gdb_stdlog,
- "after conversion to prefix form");
+ dump_prefix_expression (expout, gdb_stdlog);
*stringptr = lexptr;
return expout;
struct expression *
parse_expression (char *string)
{
- register struct expression *exp;
+ struct expression *exp;
exp = parse_exp_1 (&string, 0, 0);
if (*string)
error ("Junk after end of expression.");
/* FIXME - For the moment, handle types by swapping them in and out.
Should be using the per-architecture data-pointer and a large
struct. */
- register_gdbarch_swap (&msym_text_symbol_type, sizeof (msym_text_symbol_type), NULL);
- register_gdbarch_swap (&msym_data_symbol_type, sizeof (msym_data_symbol_type), NULL);
- register_gdbarch_swap (&msym_unknown_symbol_type, sizeof (msym_unknown_symbol_type), NULL);
-
- register_gdbarch_swap (NULL, 0, build_parse);
+ DEPRECATED_REGISTER_GDBARCH_SWAP (msym_text_symbol_type);
+ DEPRECATED_REGISTER_GDBARCH_SWAP (msym_data_symbol_type);
+ DEPRECATED_REGISTER_GDBARCH_SWAP (msym_unknown_symbol_type);
+ deprecated_register_gdbarch_swap (NULL, 0, build_parse);
add_show_from_set (
add_set_cmd ("expression", class_maintenance, var_zinteger,
projects / deliverable / binutils-gdb.git / blobdiff