/* Print in infix form a struct expression.
- Copyright (C) 1986, 1989, 1991, 2000 Free Software Foundation, Inc.
+
+ Copyright (C) 1986-2022 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "symtab.h"
#include "value.h"
#include "language.h"
#include "parser-defs.h"
+#include "user-regs.h" /* For user_reg_map_regnum_to_name. */
+#include "target.h"
+#include "block.h"
+#include "objfiles.h"
+#include "valprint.h"
+#include "cli/cli-style.h"
+#include "c-lang.h"
+#include "expop.h"
+#include "ada-exp.h"
-#ifdef HAVE_CTYPE_H
#include <ctype.h>
-#endif
-
-/* Prototypes for local functions */
-static void print_subexp (struct expression *, int *, struct ui_file *,
- enum precedence);
+/* Default name for the standard operator OPCODE (i.e., one defined in
+ the definition of enum exp_opcode). */
-void
-print_expression (exp, stream)
- struct expression *exp;
- struct ui_file *stream;
+const char *
+op_name (enum exp_opcode opcode)
{
- int pc = 0;
- print_subexp (exp, &pc, stream, PREC_NULL);
-}
-
-/* Print the subexpression of EXP that starts in position POS, on STREAM.
- PREC is the precedence of the surrounding operator;
- if the precedence of the main operator of this subexpression is less,
- parentheses are needed here. */
-
-static void
-print_subexp (exp, pos, stream, prec)
- register struct expression *exp;
- register int *pos;
- struct ui_file *stream;
- enum precedence prec;
-{
- register unsigned tem;
- register const struct op_print *op_print_tab;
- register int pc;
- unsigned nargs;
- register char *op_str;
- int assign_modify = 0;
- enum exp_opcode opcode;
- enum precedence myprec = PREC_NULL;
- /* Set to 1 for a right-associative operator. */
- int assoc = 0;
- value_ptr val;
- char *tempstr = NULL;
-
- op_print_tab = exp->language_defn->la_op_print_tab;
- pc = (*pos)++;
- opcode = exp->elts[pc].opcode;
switch (opcode)
{
- /* Common ops */
-
- case OP_SCOPE:
- myprec = PREC_PREFIX;
- assoc = 0;
- fputs_filtered (type_name_no_tag (exp->elts[pc + 1].type), stream);
- fputs_filtered ("::", stream);
- nargs = longest_to_int (exp->elts[pc + 2].longconst);
- (*pos) += 4 + BYTES_TO_EXP_ELEM (nargs + 1);
- fputs_filtered (&exp->elts[pc + 3].string, stream);
- return;
-
- case OP_LONG:
- (*pos) += 3;
- value_print (value_from_longest (exp->elts[pc + 1].type,
- exp->elts[pc + 2].longconst),
- stream, 0, Val_no_prettyprint);
- return;
-
- case OP_DOUBLE:
- (*pos) += 3;
- value_print (value_from_double (exp->elts[pc + 1].type,
- exp->elts[pc + 2].doubleconst),
- stream, 0, Val_no_prettyprint);
- return;
-
- case OP_VAR_VALUE:
- {
- struct block *b;
- (*pos) += 3;
- b = exp->elts[pc + 1].block;
- if (b != NULL
- && BLOCK_FUNCTION (b) != NULL
- && SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b)) != NULL)
- {
- fputs_filtered (SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b)), stream);
- fputs_filtered ("::", stream);
- }
- fputs_filtered (SYMBOL_SOURCE_NAME (exp->elts[pc + 2].symbol), stream);
- }
- return;
-
- case OP_LAST:
- (*pos) += 2;
- fprintf_filtered (stream, "$%d",
- longest_to_int (exp->elts[pc + 1].longconst));
- return;
-
- case OP_REGISTER:
- (*pos) += 2;
- fprintf_filtered (stream, "$%s",
- REGISTER_NAME (longest_to_int (exp->elts[pc + 1].longconst)));
- return;
-
- case OP_BOOL:
- (*pos) += 2;
- fprintf_filtered (stream, "%s",
- longest_to_int (exp->elts[pc + 1].longconst)
- ? "TRUE" : "FALSE");
- return;
-
- case OP_INTERNALVAR:
- (*pos) += 2;
- fprintf_filtered (stream, "$%s",
- internalvar_name (exp->elts[pc + 1].internalvar));
- 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);
- return;
-
- case OP_NAME:
- case OP_EXPRSTRING:
- nargs = longest_to_int (exp->elts[pc + 1].longconst);
- (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
- fputs_filtered (&exp->elts[pc + 2].string, stream);
- return;
-
- case OP_STRING:
- nargs = longest_to_int (exp->elts[pc + 1].longconst);
- (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
- /* LA_PRINT_STRING will print using the current repeat count threshold.
- If necessary, we can temporarily set it to zero, or pass it as an
- additional parameter to LA_PRINT_STRING. -fnf */
- LA_PRINT_STRING (stream, &exp->elts[pc + 2].string, nargs, 1, 0);
- return;
-
- case OP_BITSTRING:
- nargs = longest_to_int (exp->elts[pc + 1].longconst);
- (*pos)
- += 3 + BYTES_TO_EXP_ELEM ((nargs + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT);
- fprintf_unfiltered (stream, "B'<unimplemented>'");
- return;
-
- case OP_ARRAY:
- (*pos) += 3;
- nargs = longest_to_int (exp->elts[pc + 2].longconst);
- nargs -= longest_to_int (exp->elts[pc + 1].longconst);
- nargs++;
- tem = 0;
- if (exp->elts[pc + 4].opcode == OP_LONG
- && exp->elts[pc + 5].type == builtin_type_char
- && exp->language_defn->la_language == language_c)
- {
- /* Attempt to print C character arrays using string syntax.
- Walk through the args, picking up one character from each
- of the OP_LONG expression elements. If any array element
- does not match our expection of what we should find for
- 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);
- pc += 4;
- while (tem < nargs)
- {
- if (exp->elts[pc].opcode != OP_LONG
- || exp->elts[pc + 1].type != builtin_type_char)
- {
- /* Not a simple array of char, use regular array printing. */
- tem = 0;
- break;
- }
- else
- {
- tempstr[tem++] =
- longest_to_int (exp->elts[pc + 2].longconst);
- pc += 4;
- }
- }
- }
- if (tem > 0)
- {
- LA_PRINT_STRING (stream, tempstr, nargs - 1, 1, 0);
- (*pos) = pc;
- }
- else
- {
- int is_chill = exp->language_defn->la_language == language_chill;
- fputs_filtered (is_chill ? " [" : " {", stream);
- for (tem = 0; tem < nargs; tem++)
- {
- if (tem != 0)
- {
- fputs_filtered (", ", stream);
- }
- print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
- }
- fputs_filtered (is_chill ? "]" : "}", stream);
- }
- return;
-
- case OP_LABELED:
- tem = longest_to_int (exp->elts[pc + 1].longconst);
- (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
-
- if (exp->language_defn->la_language == language_chill)
- {
- fputs_filtered (".", stream);
- fputs_filtered (&exp->elts[pc + 2].string, stream);
- fputs_filtered (exp->elts[*pos].opcode == OP_LABELED ? ", "
- : ": ",
- stream);
- }
- else
- {
- /* Gcc support both these syntaxes. Unsure which is preferred. */
-#if 1
- fputs_filtered (&exp->elts[pc + 2].string, stream);
- fputs_filtered (": ", stream);
-#else
- fputs_filtered (".", stream);
- fputs_filtered (&exp->elts[pc + 2].string, stream);
- fputs_filtered ("=", stream);
-#endif
- }
- print_subexp (exp, pos, stream, PREC_SUFFIX);
- return;
-
- case TERNOP_COND:
- if ((int) prec > (int) PREC_COMMA)
- fputs_filtered ("(", stream);
- /* Print the subexpressions, forcing parentheses
- around any binary operations within them.
- This is more parentheses than are strictly necessary,
- but it looks clearer. */
- print_subexp (exp, pos, stream, PREC_HYPER);
- fputs_filtered (" ? ", stream);
- print_subexp (exp, pos, stream, PREC_HYPER);
- fputs_filtered (" : ", stream);
- print_subexp (exp, pos, stream, PREC_HYPER);
- if ((int) prec > (int) PREC_COMMA)
- fputs_filtered (")", stream);
- return;
-
- case TERNOP_SLICE:
- case TERNOP_SLICE_COUNT:
- print_subexp (exp, pos, stream, PREC_SUFFIX);
- fputs_filtered ("(", stream);
- print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
- fputs_filtered (opcode == TERNOP_SLICE ? " : " : " UP ", stream);
- print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
- fputs_filtered (")", stream);
- return;
-
- case STRUCTOP_STRUCT:
- tem = longest_to_int (exp->elts[pc + 1].longconst);
- (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
- print_subexp (exp, pos, stream, PREC_SUFFIX);
- fputs_filtered (".", stream);
- fputs_filtered (&exp->elts[pc + 2].string, stream);
- return;
-
- /* Will not occur for Modula-2 */
- case STRUCTOP_PTR:
- tem = longest_to_int (exp->elts[pc + 1].longconst);
- (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
- print_subexp (exp, pos, stream, PREC_SUFFIX);
- fputs_filtered ("->", stream);
- fputs_filtered (&exp->elts[pc + 2].string, stream);
- return;
-
- case BINOP_SUBSCRIPT:
- print_subexp (exp, pos, stream, PREC_SUFFIX);
- fputs_filtered ("[", stream);
- print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
- fputs_filtered ("]", stream);
- return;
-
- case UNOP_POSTINCREMENT:
- print_subexp (exp, pos, stream, PREC_SUFFIX);
- fputs_filtered ("++", stream);
- return;
-
- case UNOP_POSTDECREMENT:
- print_subexp (exp, pos, stream, PREC_SUFFIX);
- fputs_filtered ("--", stream);
- return;
-
- case UNOP_CAST:
- (*pos) += 2;
- if ((int) prec > (int) PREC_PREFIX)
- fputs_filtered ("(", stream);
- fputs_filtered ("(", stream);
- type_print (exp->elts[pc + 1].type, "", stream, 0);
- fputs_filtered (") ", stream);
- print_subexp (exp, pos, stream, PREC_PREFIX);
- if ((int) prec > (int) PREC_PREFIX)
- fputs_filtered (")", stream);
- return;
-
- case UNOP_MEMVAL:
- (*pos) += 2;
- if ((int) prec > (int) PREC_PREFIX)
- fputs_filtered ("(", stream);
- if (exp->elts[pc + 1].type->code == TYPE_CODE_FUNC &&
- exp->elts[pc + 3].opcode == OP_LONG)
- {
- /* We have a minimal symbol fn, probably. It's encoded
- as a UNOP_MEMVAL (function-type) of an OP_LONG (int, address).
- Swallow the OP_LONG (including both its opcodes); ignore
- its type; print the value in the type of the MEMVAL. */
- (*pos) += 4;
- val = value_at_lazy (exp->elts[pc + 1].type,
- (CORE_ADDR) exp->elts[pc + 5].longconst,
- NULL);
- value_print (val, stream, 0, Val_no_prettyprint);
- }
- else
- {
- fputs_filtered ("{", stream);
- type_print (exp->elts[pc + 1].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;
- myprec = PREC_ASSIGN;
- assoc = 1;
- assign_modify = 1;
- op_str = "???";
- for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
- if (op_print_tab[tem].opcode == opcode)
- {
- op_str = op_print_tab[tem].string;
- break;
- }
- if (op_print_tab[tem].opcode != opcode)
- /* Not found; don't try to keep going because we don't know how
- to interpret further elements. */
- error ("Invalid expression");
- break;
-
- /* C++ ops */
-
- case OP_THIS:
- ++(*pos);
- fputs_filtered ("this", stream);
- return;
-
- /* Modula-2 ops */
-
- case MULTI_SUBSCRIPT:
- (*pos) += 2;
- nargs = longest_to_int (exp->elts[pc + 1].longconst);
- print_subexp (exp, pos, stream, PREC_SUFFIX);
- fprintf_unfiltered (stream, " [");
- for (tem = 0; tem < nargs; tem++)
- {
- if (tem != 0)
- fprintf_unfiltered (stream, ", ");
- print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
- }
- fprintf_unfiltered (stream, "]");
- return;
-
- case BINOP_VAL:
- (*pos) += 2;
- fprintf_unfiltered (stream, "VAL(");
- type_print (exp->elts[pc + 1].type, "", stream, 0);
- fprintf_unfiltered (stream, ",");
- print_subexp (exp, pos, stream, PREC_PREFIX);
- fprintf_unfiltered (stream, ")");
- return;
-
- case BINOP_INCL:
- case BINOP_EXCL:
- error ("print_subexp: Not implemented.");
-
- /* Default ops */
-
default:
- op_str = "???";
- for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
- if (op_print_tab[tem].opcode == opcode)
- {
- op_str = op_print_tab[tem].string;
- myprec = op_print_tab[tem].precedence;
- assoc = op_print_tab[tem].right_assoc;
- break;
- }
- if (op_print_tab[tem].opcode != opcode)
- /* Not found; don't try to keep going because we don't know how
- to interpret further elements. For example, this happens
- if opcode is OP_TYPE. */
- error ("Invalid expression");
- }
+ {
+ static char buf[30];
- /* Note that PREC_BUILTIN will always emit parentheses. */
- if ((int) myprec < (int) prec)
- fputs_filtered ("(", stream);
- if ((int) opcode > (int) BINOP_END)
- {
- if (assoc)
- {
- /* Unary postfix operator. */
- print_subexp (exp, pos, stream, PREC_SUFFIX);
- fputs_filtered (op_str, stream);
- }
- else
- {
- /* Unary prefix operator. */
- fputs_filtered (op_str, stream);
- if (myprec == PREC_BUILTIN_FUNCTION)
- fputs_filtered ("(", stream);
- print_subexp (exp, pos, stream, PREC_PREFIX);
- if (myprec == PREC_BUILTIN_FUNCTION)
- fputs_filtered (")", stream);
- }
- }
- else
- {
- /* Binary operator. */
- /* Print left operand.
- If operator is right-associative,
- increment precedence for this operand. */
- print_subexp (exp, pos, stream,
- (enum precedence) ((int) myprec + assoc));
- /* Print the operator itself. */
- if (assign_modify)
- fprintf_filtered (stream, " %s= ", op_str);
- else if (op_str[0] == ',')
- fprintf_filtered (stream, "%s ", op_str);
- else
- fprintf_filtered (stream, " %s ", op_str);
- /* Print right operand.
- If operator is left-associative,
- increment precedence for this operand. */
- print_subexp (exp, pos, stream,
- (enum precedence) ((int) myprec + !assoc));
+ xsnprintf (buf, sizeof (buf), "<unknown %d>", opcode);
+ return buf;
+ }
+#define OP(name) \
+ case name: \
+ return #name ;
+#include "std-operator.def"
+#undef OP
}
-
- if ((int) myprec < (int) prec)
- fputs_filtered (")", stream);
}
-/* Return the operator corresponding to opcode OP as
- a string. NULL indicates that the opcode was not found in the
- current language table. */
-char *
-op_string (op)
- enum exp_opcode op;
+void
+dump_prefix_expression (struct expression *exp, struct ui_file *stream)
{
- int tem;
- register const struct op_print *op_print_tab;
-
- op_print_tab = current_language->la_op_print_tab;
- for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
- if (op_print_tab[tem].opcode == op)
- return op_print_tab[tem].string;
- return NULL;
+ exp->op->dump (stream, 0);
}
-/* Support for dumping the raw data from expressions in a human readable
- form. */
+namespace expr
+{
-static char *op_name PARAMS ((int opcode));
+void
+dump_for_expression (struct ui_file *stream, int depth, enum exp_opcode op)
+{
+ fprintf_filtered (stream, _("%*sOperation: %s\n"), depth, "", op_name (op));
+}
-static char *
-op_name (opcode)
- int opcode;
+void
+dump_for_expression (struct ui_file *stream, int depth, const std::string &str)
{
- switch (opcode)
- {
- default:
- {
- static char buf[30];
+ fprintf_filtered (stream, _("%*sString: %s\n"), depth, "", str.c_str ());
+}
- sprintf (buf, "<unknown %d>", opcode);
- return buf;
- }
- case OP_NULL:
- return "OP_NULL";
- case BINOP_ADD:
- return "BINOP_ADD";
- case BINOP_SUB:
- return "BINOP_SUB";
- case BINOP_MUL:
- return "BINOP_MUL";
- case BINOP_DIV:
- return "BINOP_DIV";
- case BINOP_REM:
- return "BINOP_REM";
- case BINOP_MOD:
- return "BINOP_MOD";
- case BINOP_LSH:
- return "BINOP_LSH";
- case BINOP_RSH:
- return "BINOP_RSH";
- case BINOP_LOGICAL_AND:
- return "BINOP_LOGICAL_AND";
- case BINOP_LOGICAL_OR:
- return "BINOP_LOGICAL_OR";
- case BINOP_BITWISE_AND:
- return "BINOP_BITWISE_AND";
- case BINOP_BITWISE_IOR:
- return "BINOP_BITWISE_IOR";
- case BINOP_BITWISE_XOR:
- return "BINOP_BITWISE_XOR";
- case BINOP_EQUAL:
- return "BINOP_EQUAL";
- case BINOP_NOTEQUAL:
- return "BINOP_NOTEQUAL";
- case BINOP_LESS:
- return "BINOP_LESS";
- case BINOP_GTR:
- return "BINOP_GTR";
- case BINOP_LEQ:
- return "BINOP_LEQ";
- case BINOP_GEQ:
- return "BINOP_GEQ";
- case BINOP_REPEAT:
- return "BINOP_REPEAT";
- case BINOP_ASSIGN:
- return "BINOP_ASSIGN";
- case BINOP_COMMA:
- return "BINOP_COMMA";
- case BINOP_SUBSCRIPT:
- return "BINOP_SUBSCRIPT";
- case MULTI_SUBSCRIPT:
- return "MULTI_SUBSCRIPT";
- case BINOP_EXP:
- return "BINOP_EXP";
- case BINOP_MIN:
- return "BINOP_MIN";
- case BINOP_MAX:
- return "BINOP_MAX";
- case STRUCTOP_MEMBER:
- return "STRUCTOP_MEMBER";
- case STRUCTOP_MPTR:
- return "STRUCTOP_MPTR";
- case BINOP_INTDIV:
- return "BINOP_INTDIV";
- case BINOP_ASSIGN_MODIFY:
- return "BINOP_ASSIGN_MODIFY";
- case BINOP_VAL:
- return "BINOP_VAL";
- case BINOP_INCL:
- return "BINOP_INCL";
- case BINOP_EXCL:
- return "BINOP_EXCL";
- case BINOP_CONCAT:
- return "BINOP_CONCAT";
- case BINOP_RANGE:
- return "BINOP_RANGE";
- case BINOP_END:
- return "BINOP_END";
- case TERNOP_COND:
- return "TERNOP_COND";
- case TERNOP_SLICE:
- return "TERNOP_SLICE";
- case TERNOP_SLICE_COUNT:
- return "TERNOP_SLICE_COUNT";
- case OP_LONG:
- return "OP_LONG";
- case OP_DOUBLE:
- return "OP_DOUBLE";
- case OP_VAR_VALUE:
- return "OP_VAR_VALUE";
- case OP_LAST:
- return "OP_LAST";
- case OP_REGISTER:
- return "OP_REGISTER";
- case OP_INTERNALVAR:
- return "OP_INTERNALVAR";
- case OP_FUNCALL:
- return "OP_FUNCALL";
- case OP_STRING:
- return "OP_STRING";
- case OP_BITSTRING:
- return "OP_BITSTRING";
- case OP_ARRAY:
- return "OP_ARRAY";
- case UNOP_CAST:
- return "UNOP_CAST";
- case UNOP_MEMVAL:
- return "UNOP_MEMVAL";
- case UNOP_NEG:
- return "UNOP_NEG";
- case UNOP_LOGICAL_NOT:
- return "UNOP_LOGICAL_NOT";
- case UNOP_COMPLEMENT:
- return "UNOP_COMPLEMENT";
- case UNOP_IND:
- return "UNOP_IND";
- case UNOP_ADDR:
- return "UNOP_ADDR";
- case UNOP_PREINCREMENT:
- return "UNOP_PREINCREMENT";
- case UNOP_POSTINCREMENT:
- return "UNOP_POSTINCREMENT";
- case UNOP_PREDECREMENT:
- return "UNOP_PREDECREMENT";
- case UNOP_POSTDECREMENT:
- return "UNOP_POSTDECREMENT";
- case UNOP_SIZEOF:
- return "UNOP_SIZEOF";
- case UNOP_LOWER:
- return "UNOP_LOWER";
- case UNOP_UPPER:
- return "UNOP_UPPER";
- case UNOP_LENGTH:
- return "UNOP_LENGTH";
- case UNOP_PLUS:
- return "UNOP_PLUS";
- case UNOP_CAP:
- return "UNOP_CAP";
- case UNOP_CHR:
- return "UNOP_CHR";
- case UNOP_ORD:
- return "UNOP_ORD";
- case UNOP_ABS:
- return "UNOP_ABS";
- case UNOP_FLOAT:
- return "UNOP_FLOAT";
- case UNOP_HIGH:
- return "UNOP_HIGH";
- case UNOP_MAX:
- return "UNOP_MAX";
- case UNOP_MIN:
- return "UNOP_MIN";
- case UNOP_ODD:
- return "UNOP_ODD";
- case UNOP_TRUNC:
- return "UNOP_TRUNC";
- case OP_BOOL:
- return "OP_BOOL";
- case OP_M2_STRING:
- return "OP_M2_STRING";
- case STRUCTOP_STRUCT:
- return "STRUCTOP_STRUCT";
- case STRUCTOP_PTR:
- return "STRUCTOP_PTR";
- case OP_THIS:
- return "OP_THIS";
- case OP_SCOPE:
- return "OP_SCOPE";
- case OP_TYPE:
- return "OP_TYPE";
- case OP_LABELED:
- return "OP_LABELED";
- }
+void
+dump_for_expression (struct ui_file *stream, int depth, struct type *type)
+{
+ fprintf_filtered (stream, _("%*sType: "), depth, "");
+ type_print (type, nullptr, stream, 0);
+ fprintf_filtered (stream, "\n");
}
void
-dump_prefix_expression (exp, stream, note)
- struct expression *exp;
- struct ui_file *stream;
- char *note;
+dump_for_expression (struct ui_file *stream, int depth, CORE_ADDR addr)
{
- int elt;
- char *opcode_name;
- char *eltscan;
- int eltsize;
+ fprintf_filtered (stream, _("%*sConstant: %s\n"), depth, "",
+ core_addr_to_string (addr));
+}
- fprintf_filtered (stream, "Dump of expression @ ");
- gdb_print_host_address (exp, stream);
- fprintf_filtered (stream, ", %s:\nExpression: `", note);
- if (exp->elts[0].opcode != OP_TYPE)
- print_expression (exp, stream);
- else
- fprintf_filtered (stream, "Type printing not yet supported....");
- fprintf_filtered (stream, "'\n\tLanguage %s, %d elements, %d bytes each.\n",
- exp->language_defn->la_name, exp->nelts,
- 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->elts[elt].opcode);
+void
+dump_for_expression (struct ui_file *stream, int depth, internalvar *ivar)
+{
+ fprintf_filtered (stream, _("%*sInternalvar: $%s\n"), depth, "",
+ internalvar_name (ivar));
+}
- fprintf_filtered (stream, "%20s ", opcode_name);
- print_longest (stream, 'd', 0, exp->elts[elt].longconst);
- fprintf_filtered (stream, " ");
+void
+dump_for_expression (struct ui_file *stream, int depth, symbol *sym)
+{
+ fprintf_filtered (stream, _("%*sSymbol: %s\n"), depth, "",
+ sym->print_name ());
+}
- for (eltscan = (char *) &exp->elts[elt],
- eltsize = sizeof (union exp_element);
- eltsize-- > 0;
- eltscan++)
- {
- fprintf_filtered (stream, "%c",
- isprint (*eltscan) ? (*eltscan & 0xFF) : '.');
- }
- fprintf_filtered (stream, "\n");
- }
+void
+dump_for_expression (struct ui_file *stream, int depth,
+ bound_minimal_symbol msym)
+{
+ fprintf_filtered (stream, _("%*sMinsym %s in objfile %s\n"), depth, "",
+ msym.minsym->print_name (), objfile_name (msym.objfile));
}
-static int dump_subexp PARAMS ((struct expression * exp, struct ui_file * stream, int elt));
+void
+dump_for_expression (struct ui_file *stream, int depth, const block *bl)
+{
+ fprintf_filtered (stream, _("%*sBlock: %p\n"), depth, "", bl);
+}
-static int
-dump_subexp (exp, stream, elt)
- struct expression *exp;
- struct ui_file *stream;
- int elt;
+void
+dump_for_expression (struct ui_file *stream, int depth,
+ const block_symbol &sym)
{
- static int indent = 0;
- int i;
+ fprintf_filtered (stream, _("%*sBlock symbol:\n"), depth, "");
+ dump_for_expression (stream, depth + 1, sym.symbol);
+ dump_for_expression (stream, depth + 1, sym.block);
+}
+void
+dump_for_expression (struct ui_file *stream, int depth,
+ type_instance_flags flags)
+{
+ fprintf_filtered (stream, _("%*sType flags: "), depth, "");
+ if (flags & TYPE_INSTANCE_FLAG_CONST)
+ fputs_filtered ("const ", stream);
+ if (flags & TYPE_INSTANCE_FLAG_VOLATILE)
+ fputs_filtered ("volatile", stream);
fprintf_filtered (stream, "\n");
- fprintf_filtered (stream, "\t%5d ", elt);
-
- for (i = 1; i <= indent; i++)
- fprintf_filtered (stream, " ");
- indent += 2;
-
- fprintf_filtered (stream, "%-20s ", op_name (exp->elts[elt].opcode));
+}
- switch (exp->elts[elt++].opcode)
+void
+dump_for_expression (struct ui_file *stream, int depth,
+ enum c_string_type_values flags)
+{
+ fprintf_filtered (stream, _("%*sC string flags: "), depth, "");
+ switch (flags & ~C_CHAR)
{
- case TERNOP_COND:
- case TERNOP_SLICE:
- case TERNOP_SLICE_COUNT:
- elt = dump_subexp (exp, stream, elt);
- case BINOP_ADD:
- case BINOP_SUB:
- case BINOP_MUL:
- case BINOP_DIV:
- case BINOP_REM:
- case BINOP_MOD:
- case BINOP_LSH:
- case BINOP_RSH:
- case BINOP_LOGICAL_AND:
- case BINOP_LOGICAL_OR:
- case BINOP_BITWISE_AND:
- case BINOP_BITWISE_IOR:
- case BINOP_BITWISE_XOR:
- case BINOP_EQUAL:
- case BINOP_NOTEQUAL:
- case BINOP_LESS:
- case BINOP_GTR:
- case BINOP_LEQ:
- case BINOP_GEQ:
- case BINOP_REPEAT:
- case BINOP_ASSIGN:
- case BINOP_COMMA:
- case BINOP_SUBSCRIPT:
- case BINOP_EXP:
- case BINOP_MIN:
- case BINOP_MAX:
- case BINOP_INTDIV:
- case BINOP_ASSIGN_MODIFY:
- case BINOP_VAL:
- case BINOP_INCL:
- case BINOP_EXCL:
- case BINOP_CONCAT:
- case BINOP_IN:
- case BINOP_RANGE:
- case BINOP_END:
- elt = dump_subexp (exp, stream, elt);
- case UNOP_NEG:
- case UNOP_LOGICAL_NOT:
- case UNOP_COMPLEMENT:
- case UNOP_IND:
- case UNOP_ADDR:
- case UNOP_PREINCREMENT:
- case UNOP_POSTINCREMENT:
- case UNOP_PREDECREMENT:
- case UNOP_POSTDECREMENT:
- case UNOP_SIZEOF:
- case UNOP_PLUS:
- case UNOP_CAP:
- case UNOP_CHR:
- case UNOP_ORD:
- case UNOP_ABS:
- case UNOP_FLOAT:
- case UNOP_HIGH:
- case UNOP_MAX:
- case UNOP_MIN:
- case UNOP_ODD:
- case UNOP_TRUNC:
- case UNOP_LOWER:
- case UNOP_UPPER:
- case UNOP_LENGTH:
- case UNOP_CARD:
- case UNOP_CHMAX:
- case UNOP_CHMIN:
- elt = dump_subexp (exp, stream, elt);
- break;
- case OP_LONG:
- 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 %ld (0x%lx)",
- (long) exp->elts[elt + 1].longconst,
- (long) exp->elts[elt + 1].longconst);
- elt += 3;
+ case C_WIDE_STRING:
+ fputs_filtered (_("wide "), stream);
break;
- case OP_DOUBLE:
- 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);
- elt += 3;
+ case C_STRING_16:
+ fputs_filtered (_("u16 "), stream);
break;
- case OP_VAR_VALUE:
- fprintf_filtered (stream, "Block @");
- gdb_print_host_address (exp->elts[elt].block, stream);
- fprintf_filtered (stream, ", symbol @");
- gdb_print_host_address (exp->elts[elt + 1].symbol, stream);
- fprintf_filtered (stream, " (%s)",
- SYMBOL_NAME (exp->elts[elt + 1].symbol));
- elt += 3;
- break;
- case OP_LAST:
- fprintf_filtered (stream, "History element %ld",
- (long) exp->elts[elt].longconst);
- elt += 2;
- break;
- case OP_REGISTER:
- fprintf_filtered (stream, "Register %ld",
- (long) exp->elts[elt].longconst);
- elt += 2;
- break;
- case OP_INTERNALVAR:
- fprintf_filtered (stream, "Internal var @");
- gdb_print_host_address (exp->elts[elt].internalvar, stream);
- fprintf_filtered (stream, " (%s)",
- exp->elts[elt].internalvar->name);
- elt += 2;
- break;
- case OP_FUNCALL:
- {
- int 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);
- }
- break;
- case OP_ARRAY:
- {
- int lower, upper;
- int i;
-
- lower = longest_to_int (exp->elts[elt].longconst);
- upper = longest_to_int (exp->elts[elt + 1].longconst);
-
- fprintf_filtered (stream, "Bounds [%d:%d]", lower, upper);
- elt += 3;
-
- for (i = 1; i <= upper - lower + 1; i++)
- elt = dump_subexp (exp, stream, elt);
- }
- break;
- case UNOP_MEMVAL:
- case UNOP_CAST:
- 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, ")");
- elt = dump_subexp (exp, stream, elt + 2);
- break;
- case OP_TYPE:
- 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, ")");
- elt += 2;
- break;
- case STRUCTOP_STRUCT:
- case STRUCTOP_PTR:
- {
- char *elem_name;
- int len;
-
- len = longest_to_int (exp->elts[elt].longconst);
- elem_name = &exp->elts[elt + 1].string;
-
- fprintf_filtered (stream, "Element name: `%.*s'", len, elem_name);
- elt = dump_subexp (exp, stream, elt + 3 + BYTES_TO_EXP_ELEM (len + 1));
- }
- break;
- case OP_SCOPE:
- {
- char *elem_name;
- int len;
-
- 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, ") ");
-
- len = longest_to_int (exp->elts[elt + 1].longconst);
- elem_name = &exp->elts[elt + 2].string;
-
- fprintf_filtered (stream, "Field name: `%.*s'", len, elem_name);
- elt += 4 + BYTES_TO_EXP_ELEM (len + 1);
- }
+ case C_STRING_32:
+ fputs_filtered (_("u32 "), stream);
break;
default:
- case OP_NULL:
- case STRUCTOP_MEMBER:
- case STRUCTOP_MPTR:
- case MULTI_SUBSCRIPT:
- case OP_F77_UNDETERMINED_ARGLIST:
- case OP_COMPLEX:
- case OP_STRING:
- case OP_BITSTRING:
- case OP_BOOL:
- case OP_M2_STRING:
- case OP_THIS:
- case OP_LABELED:
- case OP_NAME:
- case OP_EXPRSTRING:
- fprintf_filtered (stream, "Unknown format");
+ fputs_filtered (_("ordinary "), stream);
+ break;
}
- indent -= 2;
-
- return elt;
+ if ((flags & C_CHAR) != 0)
+ fputs_filtered (_("char"), stream);
+ else
+ fputs_filtered (_("string"), stream);
+ fputs_filtered ("\n", stream);
}
void
-dump_postfix_expression (exp, stream, note)
- struct expression *exp;
- struct ui_file *stream;
- char *note;
+dump_for_expression (struct ui_file *stream, int depth,
+ enum range_flag flags)
{
- int elt;
+ fprintf_filtered (stream, _("%*sRange:"), depth, "");
+ if ((flags & RANGE_LOW_BOUND_DEFAULT) != 0)
+ fputs_filtered (_("low-default "), stream);
+ if ((flags & RANGE_HIGH_BOUND_DEFAULT) != 0)
+ fputs_filtered (_("high-default "), stream);
+ if ((flags & RANGE_HIGH_BOUND_EXCLUSIVE) != 0)
+ fputs_filtered (_("high-exclusive "), stream);
+ if ((flags & RANGE_HAS_STRIDE) != 0)
+ fputs_filtered (_("has-stride"), stream);
+ fprintf_filtered (stream, "\n");
+}
- fprintf_filtered (stream, "Dump of expression @ ");
- gdb_print_host_address (exp, stream);
- fprintf_filtered (stream, ", %s:\nExpression: `", note);
- if (exp->elts[0].opcode != OP_TYPE)
- print_expression (exp, stream);
- else
- fputs_filtered ("Type printing not yet supported....", stream);
- fprintf_filtered (stream, "'\n\tLanguage %s, %d elements, %d bytes each.\n",
- exp->language_defn->la_name, exp->nelts,
- sizeof (union exp_element));
- fputs_filtered ("\n", stream);
+void
+dump_for_expression (struct ui_file *stream, int depth,
+ const std::unique_ptr<ada_component> &comp)
+{
+ comp->dump (stream, depth);
+}
- for (elt = 0; elt < exp->nelts;)
- elt = dump_subexp (exp, stream, elt);
- fputs_filtered ("\n", stream);
+void
+float_const_operation::dump (struct ui_file *stream, int depth) const
+{
+ fprintf_filtered (stream, _("%*sFloat: "), depth, "");
+ print_floating (m_data.data (), m_type, stream);
+ fprintf_filtered (stream, "\n");
}
+
+} /* namespace expr */