/* Print in infix form a struct expression.
- Copyright (C) 1986-2013 Free Software Foundation, Inc.
+ Copyright (C) 1986-2020 Free Software Foundation, Inc.
This file is part of GDB.
#include "parser-defs.h"
#include "user-regs.h" /* For user_reg_map_regnum_to_name. */
#include "target.h"
-#include <string.h>
#include "block.h"
#include "objfiles.h"
-#include "gdb_assert.h"
#include "valprint.h"
+#include "cli/cli-style.h"
#include <ctype.h>
print_subexp (struct expression *exp, int *pos,
struct ui_file *stream, enum precedence prec)
{
- exp->language_defn->la_exp_desc->print_subexp (exp, pos, stream, prec);
+ exp->language_defn->expression_ops ()->print_subexp (exp, pos, stream,
+ prec);
+}
+
+/* See parser-defs.h. */
+
+void
+print_subexp_funcall (struct expression *exp, int *pos,
+ struct ui_file *stream)
+{
+ (*pos) += 2;
+ unsigned nargs = longest_to_int (exp->elts[*pos].longconst);
+ print_subexp (exp, pos, stream, PREC_SUFFIX);
+ fputs_filtered (" (", stream);
+ for (unsigned tem = 0; tem < nargs; tem++)
+ {
+ if (tem != 0)
+ fputs_filtered (", ", stream);
+ print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
+ }
+ fputs_filtered (")", stream);
}
/* Standard implementation of print_subexp for use in language_defn
const struct op_print *op_print_tab;
int pc;
unsigned nargs;
- char *op_str;
+ const char *op_str;
int assign_modify = 0;
enum exp_opcode opcode;
enum precedence myprec = PREC_NULL;
struct value *val;
char *tempstr = NULL;
- op_print_tab = exp->language_defn->la_op_print_tab;
+ op_print_tab = exp->language_defn->opcode_print_table ();
pc = (*pos)++;
opcode = exp->elts[pc].opcode;
switch (opcode)
case OP_SCOPE:
myprec = PREC_PREFIX;
assoc = 0;
- fputs_filtered (type_name_no_tag (exp->elts[pc + 1].type), stream);
+ fputs_filtered (exp->elts[pc + 1].type->name (), stream);
fputs_filtered ("::", stream);
nargs = longest_to_int (exp->elts[pc + 2].longconst);
(*pos) += 4 + BYTES_TO_EXP_ELEM (nargs + 1);
}
return;
- case OP_DOUBLE:
+ case OP_FLOAT:
{
struct value_print_options opts;
get_no_prettyformat_print_options (&opts);
(*pos) += 3;
- value_print (value_from_double (exp->elts[pc + 1].type,
- exp->elts[pc + 2].doubleconst),
+ value_print (value_from_contents (exp->elts[pc + 1].type,
+ exp->elts[pc + 2].floatconst),
stream, &opts);
}
return;
b = exp->elts[pc + 1].block;
if (b != NULL
&& BLOCK_FUNCTION (b) != NULL
- && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)) != NULL)
+ && BLOCK_FUNCTION (b)->print_name () != NULL)
{
- fputs_filtered (SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)), stream);
+ fputs_filtered (BLOCK_FUNCTION (b)->print_name (), stream);
fputs_filtered ("::", stream);
}
- fputs_filtered (SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol), stream);
+ fputs_filtered (exp->elts[pc + 2].symbol->print_name (), stream);
+ }
+ return;
+
+ case OP_VAR_MSYM_VALUE:
+ {
+ (*pos) += 3;
+ fputs_filtered (exp->elts[pc + 2].msymbol->print_name (), stream);
+ }
+ return;
+
+ case OP_FUNC_STATIC_VAR:
+ {
+ tem = longest_to_int (exp->elts[pc + 1].longconst);
+ (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
+ fputs_filtered (&exp->elts[pc + 1].string, stream);
}
return;
{
(*pos) += 2;
fprintf_filtered (stream, "%s@entry",
- SYMBOL_PRINT_NAME (exp->elts[pc + 1].symbol));
+ exp->elts[pc + 1].symbol->print_name ());
}
return;
return;
case OP_FUNCALL:
- (*pos) += 2;
- nargs = longest_to_int (exp->elts[pc + 1].longconst);
- print_subexp (exp, pos, stream, PREC_SUFFIX);
- fputs_filtered (" (", stream);
- for (tem = 0; tem < nargs; tem++)
- {
- if (tem != 0)
- fputs_filtered (", ", stream);
- print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
- }
- fputs_filtered (")", stream);
+ print_subexp_funcall (exp, pos, stream);
return;
case OP_NAME:
case OP_OBJC_MSGCALL:
{ /* Objective C message (method) call. */
- char *selector;
-
(*pos) += 3;
nargs = longest_to_int (exp->elts[pc + 2].longconst);
fprintf_unfiltered (stream, "[");
print_subexp (exp, pos, stream, PREC_SUFFIX);
- if (0 == target_read_string (exp->elts[pc + 1].longconst,
- &selector, 1024, NULL))
- {
- error (_("bad selector"));
- return;
- }
+ gdb::unique_xmalloc_ptr<char> selector
+ = target_read_string (exp->elts[pc + 1].longconst, 1024);
+ if (selector == nullptr)
+ error (_("bad selector"));
if (nargs)
{
char *s, *nextS;
- s = alloca (strlen (selector) + 1);
- strcpy (s, selector);
+ s = selector.get ();
for (tem = 0; tem < nargs; tem++)
{
nextS = strchr (s, ':');
}
else
{
- fprintf_unfiltered (stream, " %s", selector);
+ fprintf_unfiltered (stream, " %s", selector.get ());
}
fprintf_unfiltered (stream, "]");
- /* "selector" was malloc'd by target_read_string. Free it. */
- xfree (selector);
return;
}
a simple string, revert back to array printing. Note that
the last expression element is an explicit null terminator
byte, which doesn't get printed. */
- tempstr = alloca (nargs);
+ tempstr = (char *) alloca (nargs);
pc += 4;
while (tem < nargs)
{
(*pos) += 2;
if ((int) prec > (int) PREC_PREFIX)
fputs_filtered ("(", stream);
- if (TYPE_CODE (exp->elts[pc + 1].type) == TYPE_CODE_FUNC
+ if (exp->elts[pc + 1].type->code () == TYPE_CODE_FUNC
&& exp->elts[pc + 3].opcode == OP_LONG)
{
struct value_print_options opts;
fputs_filtered (")", stream);
return;
- case UNOP_MEMVAL_TLS:
- (*pos) += 3;
- if ((int) prec > (int) PREC_PREFIX)
- fputs_filtered ("(", stream);
- fputs_filtered ("{", stream);
- type_print (exp->elts[pc + 2].type, "", stream, 0);
- fputs_filtered ("} ", stream);
- print_subexp (exp, pos, stream, PREC_PREFIX);
- if ((int) prec > (int) PREC_PREFIX)
- fputs_filtered (")", stream);
- return;
-
case BINOP_ASSIGN_MODIFY:
opcode = exp->elts[pc + 1].opcode;
(*pos) += 2;
case OP_THIS:
++(*pos);
- if (exp->language_defn->la_name_of_this)
- fputs_filtered (exp->language_defn->la_name_of_this, stream);
+ if (exp->language_defn->name_of_this () != NULL)
+ fputs_filtered (exp->language_defn->name_of_this (), stream);
else
- fprintf_filtered (stream, _("<language %s has no 'this'>"),
- exp->language_defn->la_name);
+ fprintf_styled (stream, metadata_style.style (),
+ _("<language %s has no 'this'>"),
+ exp->language_defn->name ());
return;
/* Modula-2 ops */
case TYPE_INSTANCE:
{
- LONGEST count = exp->elts[pc + 1].longconst;
+ type_instance_flags flags
+ = (type_instance_flag_value) longest_to_int (exp->elts[pc + 1].longconst);
+ LONGEST count = exp->elts[pc + 2].longconst;
+ /* The FLAGS. */
+ (*pos)++;
/* The COUNT. */
(*pos)++;
- fputs_unfiltered ("TypesInstance(", stream);
+ fputs_unfiltered ("TypeInstance(", stream);
while (count-- > 0)
{
type_print (exp->elts[(*pos)++].type, "", stream, 0);
/* Ending COUNT and ending TYPE_INSTANCE. */
(*pos) += 2;
print_subexp (exp, pos, stream, PREC_PREFIX);
+
+ if (flags & TYPE_INSTANCE_FLAG_CONST)
+ fputs_unfiltered (",const", stream);
+ if (flags & TYPE_INSTANCE_FLAG_VOLATILE)
+ fputs_unfiltered (",volatile", stream);
+
fputs_unfiltered (")", stream);
return;
}
+ case OP_RANGE:
+ {
+ enum range_type range_type;
+
+ range_type = (enum range_type)
+ longest_to_int (exp->elts[pc + 1].longconst);
+ *pos += 2;
+
+ if (range_type == NONE_BOUND_DEFAULT_EXCLUSIVE
+ || range_type == LOW_BOUND_DEFAULT_EXCLUSIVE)
+ fputs_filtered ("EXCLUSIVE_", stream);
+ fputs_filtered ("RANGE(", stream);
+ if (range_type == HIGH_BOUND_DEFAULT
+ || range_type == NONE_BOUND_DEFAULT
+ || range_type == NONE_BOUND_DEFAULT_EXCLUSIVE)
+ print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
+ fputs_filtered ("..", stream);
+ if (range_type == LOW_BOUND_DEFAULT
+ || range_type == NONE_BOUND_DEFAULT)
+ print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
+ fputs_filtered (")", stream);
+ return;
+ }
+
/* Default ops */
default:
/* Return the operator corresponding to opcode OP as
a string. NULL indicates that the opcode was not found in the
current language table. */
-char *
+const char *
op_string (enum exp_opcode op)
{
int tem;
const struct op_print *op_print_tab;
- op_print_tab = current_language->la_op_print_tab;
+ op_print_tab = current_language->opcode_print_table ();
for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
if (op_print_tab[tem].opcode == op)
return op_print_tab[tem].string;
/* Name for OPCODE, when it appears in expression EXP. */
-char *
+const char *
op_name (struct expression *exp, enum exp_opcode opcode)
{
- return exp->language_defn->la_exp_desc->op_name (opcode);
+ if (opcode >= OP_UNUSED_LAST)
+ {
+ char *cell = get_print_cell ();
+ xsnprintf (cell, PRINT_CELL_SIZE, "unknown opcode: %u",
+ unsigned (opcode));
+ return cell;
+ }
+ return exp->language_defn->expression_ops ()->op_name (opcode);
}
/* Default name for the standard operator OPCODE (i.e., one defined in
the definition of enum exp_opcode). */
-char *
+const char *
op_name_standard (enum exp_opcode opcode)
{
switch (opcode)
void
dump_raw_expression (struct expression *exp, struct ui_file *stream,
- char *note)
+ const char *note)
{
int elt;
- char *opcode_name;
char *eltscan;
int eltsize;
if (note)
fprintf_filtered (stream, ", %s:", note);
fprintf_filtered (stream, "\n\tLanguage %s, %d elements, %ld bytes each.\n",
- exp->language_defn->la_name, exp->nelts,
+ exp->language_defn->name (), exp->nelts,
(long) sizeof (union exp_element));
fprintf_filtered (stream, "\t%5s %20s %16s %s\n", "Index", "Opcode",
"Hex Value", "String Value");
for (elt = 0; elt < exp->nelts; elt++)
{
fprintf_filtered (stream, "\t%5d ", elt);
- opcode_name = op_name (exp, exp->elts[elt].opcode);
+ const char *opcode_name = op_name (exp, exp->elts[elt].opcode);
fprintf_filtered (stream, "%20s ", opcode_name);
+
print_longest (stream, 'd', 0, exp->elts[elt].longconst);
fprintf_filtered (stream, " ");
static int
dump_subexp_body (struct expression *exp, struct ui_file *stream, int elt)
{
- return exp->language_defn->la_exp_desc->dump_subexp_body (exp, stream, elt);
+ return exp->language_defn->expression_ops ()->dump_subexp_body (exp, stream,
+ elt);
+}
+
+/* See parser-defs.h. */
+
+int
+dump_subexp_body_funcall (struct expression *exp,
+ struct ui_file *stream, int elt)
+{
+ int nargs = longest_to_int (exp->elts[elt].longconst);
+ fprintf_filtered (stream, "Number of args: %d", nargs);
+ elt += 2;
+
+ for (int i = 1; i <= nargs + 1; i++)
+ elt = dump_subexp (exp, stream, elt);
+
+ return elt;
}
/* Default value for subexp_body in exp_descriptor vector. */
case BINOP_ASSIGN_MODIFY:
case BINOP_VAL:
case BINOP_CONCAT:
- case BINOP_IN:
- case BINOP_RANGE:
case BINOP_END:
case STRUCTOP_MEMBER:
case STRUCTOP_MPTR:
case UNOP_PREDECREMENT:
case UNOP_POSTDECREMENT:
case UNOP_SIZEOF:
+ case UNOP_ALIGNOF:
case UNOP_PLUS:
case UNOP_CAP:
case UNOP_CHR:
(long) exp->elts[elt + 1].longconst);
elt += 3;
break;
- case OP_DOUBLE:
+ case OP_FLOAT:
fprintf_filtered (stream, "Type @");
gdb_print_host_address (exp->elts[elt].type, stream);
fprintf_filtered (stream, " (");
type_print (exp->elts[elt].type, NULL, stream, 0);
- fprintf_filtered (stream, "), value %g",
- (double) exp->elts[elt + 1].doubleconst);
+ fprintf_filtered (stream, "), value ");
+ print_floating (exp->elts[elt + 1].floatconst,
+ exp->elts[elt].type, stream);
elt += 3;
break;
case OP_VAR_VALUE:
fprintf_filtered (stream, ", symbol @");
gdb_print_host_address (exp->elts[elt + 1].symbol, stream);
fprintf_filtered (stream, " (%s)",
- SYMBOL_PRINT_NAME (exp->elts[elt + 1].symbol));
+ exp->elts[elt + 1].symbol->print_name ());
+ elt += 3;
+ break;
+ case OP_VAR_MSYM_VALUE:
+ fprintf_filtered (stream, "Objfile @");
+ gdb_print_host_address (exp->elts[elt].objfile, stream);
+ fprintf_filtered (stream, ", msymbol @");
+ gdb_print_host_address (exp->elts[elt + 1].msymbol, stream);
+ fprintf_filtered (stream, " (%s)",
+ exp->elts[elt + 1].msymbol->print_name ());
elt += 3;
break;
case OP_VAR_ENTRY_VALUE:
fprintf_filtered (stream, "Entry value of symbol @");
gdb_print_host_address (exp->elts[elt].symbol, stream);
fprintf_filtered (stream, " (%s)",
- SYMBOL_PRINT_NAME (exp->elts[elt].symbol));
+ exp->elts[elt].symbol->print_name ());
elt += 2;
break;
case OP_LAST:
elt += 2;
break;
case OP_FUNCALL:
- {
- int i, nargs;
-
- nargs = longest_to_int (exp->elts[elt].longconst);
-
- fprintf_filtered (stream, "Number of args: %d", nargs);
- elt += 2;
-
- for (i = 1; i <= nargs + 1; i++)
- elt = dump_subexp (exp, stream, elt);
- }
+ elt = dump_subexp_body_funcall (exp, stream, elt);
break;
case OP_ARRAY:
{
fprintf_filtered (stream, ")");
elt = dump_subexp (exp, stream, elt + 2);
break;
- case UNOP_MEMVAL_TLS:
- fprintf_filtered (stream, "TLS type @");
- gdb_print_host_address (exp->elts[elt + 1].type, stream);
- fprintf_filtered (stream, " (__thread /* \"%s\" */ ",
- (exp->elts[elt].objfile == NULL ? "(null)"
- : objfile_name (exp->elts[elt].objfile)));
- type_print (exp->elts[elt + 1].type, NULL, stream, 0);
- fprintf_filtered (stream, ")");
- elt = dump_subexp (exp, stream, elt + 3);
- break;
case OP_TYPE:
fprintf_filtered (stream, "Type @");
gdb_print_host_address (exp->elts[elt].type, stream);
elt += 4 + BYTES_TO_EXP_ELEM (len + 1);
}
break;
- case TYPE_INSTANCE:
+
+ case OP_FUNC_STATIC_VAR:
{
- LONGEST len;
+ int len = longest_to_int (exp->elts[elt].longconst);
+ const char *var_name = &exp->elts[elt + 1].string;
+ fprintf_filtered (stream, "Field name: `%.*s'", len, var_name);
+ elt += 3 + BYTES_TO_EXP_ELEM (len + 1);
+ }
+ break;
- len = exp->elts[elt++].longconst;
+ case TYPE_INSTANCE:
+ {
+ type_instance_flags flags
+ = (type_instance_flag_value) longest_to_int (exp->elts[elt++].longconst);
+ LONGEST len = exp->elts[elt++].longconst;
fprintf_filtered (stream, "%s TypeInstance: ", plongest (len));
while (len-- > 0)
{
if (len > 0)
fputs_filtered (", ", stream);
}
+
+ fprintf_filtered (stream, " Flags: %s (", hex_string (flags));
+ bool space = false;
+ auto print_one = [&] (const char *mod)
+ {
+ if (space)
+ fputs_filtered (" ", stream);
+ space = true;
+ fprintf_filtered (stream, "%s", mod);
+ };
+ if (flags & TYPE_INSTANCE_FLAG_CONST)
+ print_one ("const");
+ if (flags & TYPE_INSTANCE_FLAG_VOLATILE)
+ print_one ("volatile");
+ fprintf_filtered (stream, ")");
+
/* Ending LEN and ending TYPE_INSTANCE. */
elt += 2;
elt = dump_subexp (exp, stream, elt);
}
break;
+ case OP_STRING:
+ {
+ LONGEST len = exp->elts[elt].longconst;
+ LONGEST type = exp->elts[elt + 1].longconst;
+
+ fprintf_filtered (stream, "Language-specific string type: %s",
+ plongest (type));
+
+ /* Skip length. */
+ elt += 1;
+
+ /* Skip string content. */
+ elt += BYTES_TO_EXP_ELEM (len);
+
+ /* Skip length and ending OP_STRING. */
+ elt += 2;
+ }
+ break;
+ case OP_RANGE:
+ {
+ enum range_type range_type;
+
+ range_type = (enum range_type)
+ longest_to_int (exp->elts[elt].longconst);
+ elt += 2;
+
+ switch (range_type)
+ {
+ case BOTH_BOUND_DEFAULT:
+ fputs_filtered ("Range '..'", stream);
+ break;
+ case LOW_BOUND_DEFAULT:
+ fputs_filtered ("Range '..EXP'", stream);
+ break;
+ case LOW_BOUND_DEFAULT_EXCLUSIVE:
+ fputs_filtered ("ExclusiveRange '..EXP'", stream);
+ break;
+ case HIGH_BOUND_DEFAULT:
+ fputs_filtered ("Range 'EXP..'", stream);
+ break;
+ case NONE_BOUND_DEFAULT:
+ fputs_filtered ("Range 'EXP..EXP'", stream);
+ break;
+ case NONE_BOUND_DEFAULT_EXCLUSIVE:
+ fputs_filtered ("ExclusiveRange 'EXP..EXP'", stream);
+ break;
+ default:
+ fputs_filtered ("Invalid Range!", stream);
+ break;
+ }
+
+ if (range_type == HIGH_BOUND_DEFAULT
+ || range_type == NONE_BOUND_DEFAULT)
+ elt = dump_subexp (exp, stream, elt);
+ if (range_type == LOW_BOUND_DEFAULT
+ || range_type == NONE_BOUND_DEFAULT)
+ elt = dump_subexp (exp, stream, elt);
+ }
+ break;
+
default:
case OP_NULL:
case MULTI_SUBSCRIPT:
- case OP_F77_UNDETERMINED_ARGLIST:
case OP_COMPLEX:
- case OP_STRING:
case OP_BOOL:
case OP_M2_STRING:
case OP_THIS:
fputs_filtered (", after conversion to prefix form:\nExpression: `", stream);
print_expression (exp, stream);
fprintf_filtered (stream, "'\n\tLanguage %s, %d elements, %ld bytes each.\n",
- exp->language_defn->la_name, exp->nelts,
+ exp->language_defn->name (), exp->nelts,
(long) sizeof (union exp_element));
fputs_filtered ("\n", stream);
projects / deliverable / binutils-gdb.git / blobdiff