diff options
Diffstat (limited to 'contrib/gdb/gdb/expprint.c')
| -rw-r--r-- | contrib/gdb/gdb/expprint.c | 485 |
1 files changed, 377 insertions, 108 deletions
diff --git a/contrib/gdb/gdb/expprint.c b/contrib/gdb/gdb/expprint.c index b44ada2..939919a 100644 --- a/contrib/gdb/gdb/expprint.c +++ b/contrib/gdb/gdb/expprint.c @@ -25,6 +25,10 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "language.h" #include "parser-defs.h" +#ifdef HAVE_CTYPE_H +#include <ctype.h> +#endif + /* Prototypes for local functions */ static void @@ -120,7 +124,7 @@ print_subexp (exp, pos, stream, prec) case OP_REGISTER: (*pos) += 2; fprintf_filtered (stream, "$%s", - reg_names[longest_to_int (exp->elts[pc + 1].longconst)]); + REGISTER_NAME (longest_to_int (exp->elts[pc + 1].longconst))); return; case OP_BOOL: @@ -163,14 +167,14 @@ print_subexp (exp, pos, stream, prec) /* 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, 0); + 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 (stream, "B'<unimplemented>'"); + fprintf_unfiltered (stream, "B'<unimplemented>'"); return; case OP_ARRAY: @@ -211,7 +215,7 @@ print_subexp (exp, pos, stream, prec) } if (tem > 0) { - LA_PRINT_STRING (stream, tempstr, nargs - 1, 0); + LA_PRINT_STRING (stream, tempstr, nargs - 1, 1, 0); (*pos) = pc; } else @@ -300,7 +304,6 @@ print_subexp (exp, pos, stream, prec) fputs_filtered (&exp->elts[pc + 2].string, stream); return; - case BINOP_SUBSCRIPT: print_subexp (exp, pos, stream, PREC_SUFFIX); fputs_filtered ("[", stream); @@ -342,7 +345,8 @@ print_subexp (exp, pos, stream, prec) 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); + (CORE_ADDR) exp->elts[pc + 5].longconst, + NULL); value_print (val, stream, 0, Val_no_prettyprint); } else { fputs_filtered ("{", stream); @@ -493,13 +497,117 @@ op_string(op) return NULL; } -#ifdef DEBUG_EXPRESSIONS +#ifdef MAINTENANCE_CMDS /* Support for dumping the raw data from expressions in a human readable form. */ +static char * op_name PARAMS ((int opcode)); + +static char * +op_name (opcode) + int opcode; +{ + switch (opcode) + { + default: + { + static char buf[30]; + + 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 BINOP_SCOPE: return "BINOP_SCOPE"; + 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_expression (exp, stream, note) +dump_prefix_expression (exp, stream, note) struct expression *exp; GDB_FILE *stream; char *note; @@ -511,8 +619,12 @@ dump_expression (exp, stream, note) fprintf_filtered (stream, "Dump of expression @ "); gdb_print_address (exp, stream); - fprintf_filtered (stream, ", %s:\n", note); - fprintf_filtered (stream, "\tLanguage %s, %d elements, %d bytes each.\n", + 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", @@ -520,104 +632,11 @@ dump_expression (exp, stream, note) for (elt = 0; elt < exp -> nelts; elt++) { fprintf_filtered (stream, "\t%5d ", elt); - switch (exp -> elts[elt].opcode) - { - default: opcode_name = "<unknown>"; break; - case OP_NULL: opcode_name = "OP_NULL"; break; - case BINOP_ADD: opcode_name = "BINOP_ADD"; break; - case BINOP_SUB: opcode_name = "BINOP_SUB"; break; - case BINOP_MUL: opcode_name = "BINOP_MUL"; break; - case BINOP_DIV: opcode_name = "BINOP_DIV"; break; - case BINOP_REM: opcode_name = "BINOP_REM"; break; - case BINOP_MOD: opcode_name = "BINOP_MOD"; break; - case BINOP_LSH: opcode_name = "BINOP_LSH"; break; - case BINOP_RSH: opcode_name = "BINOP_RSH"; break; - case BINOP_LOGICAL_AND: opcode_name = "BINOP_LOGICAL_AND"; break; - case BINOP_LOGICAL_OR: opcode_name = "BINOP_LOGICAL_OR"; break; - case BINOP_BITWISE_AND: opcode_name = "BINOP_BITWISE_AND"; break; - case BINOP_BITWISE_IOR: opcode_name = "BINOP_BITWISE_IOR"; break; - case BINOP_BITWISE_XOR: opcode_name = "BINOP_BITWISE_XOR"; break; - case BINOP_EQUAL: opcode_name = "BINOP_EQUAL"; break; - case BINOP_NOTEQUAL: opcode_name = "BINOP_NOTEQUAL"; break; - case BINOP_LESS: opcode_name = "BINOP_LESS"; break; - case BINOP_GTR: opcode_name = "BINOP_GTR"; break; - case BINOP_LEQ: opcode_name = "BINOP_LEQ"; break; - case BINOP_GEQ: opcode_name = "BINOP_GEQ"; break; - case BINOP_REPEAT: opcode_name = "BINOP_REPEAT"; break; - case BINOP_ASSIGN: opcode_name = "BINOP_ASSIGN"; break; - case BINOP_COMMA: opcode_name = "BINOP_COMMA"; break; - case BINOP_SUBSCRIPT: opcode_name = "BINOP_SUBSCRIPT"; break; - case MULTI_SUBSCRIPT: opcode_name = "MULTI_SUBSCRIPT"; break; - case BINOP_EXP: opcode_name = "BINOP_EXP"; break; - case BINOP_MIN: opcode_name = "BINOP_MIN"; break; - case BINOP_MAX: opcode_name = "BINOP_MAX"; break; - case BINOP_SCOPE: opcode_name = "BINOP_SCOPE"; break; - case STRUCTOP_MEMBER: opcode_name = "STRUCTOP_MEMBER"; break; - case STRUCTOP_MPTR: opcode_name = "STRUCTOP_MPTR"; break; - case BINOP_INTDIV: opcode_name = "BINOP_INTDIV"; break; - case BINOP_ASSIGN_MODIFY: opcode_name = "BINOP_ASSIGN_MODIFY"; break; - case BINOP_VAL: opcode_name = "BINOP_VAL"; break; - case BINOP_INCL: opcode_name = "BINOP_INCL"; break; - case BINOP_EXCL: opcode_name = "BINOP_EXCL"; break; - case BINOP_CONCAT: opcode_name = "BINOP_CONCAT"; break; - case BINOP_RANGE: opcode_name = "BINOP_RANGE"; break; - case BINOP_END: opcode_name = "BINOP_END"; break; - case TERNOP_COND: opcode_name = "TERNOP_COND"; break; - case TERNOP_SLICE: opcode_name = "TERNOP_SLICE"; break; - case TERNOP_SLICE_COUNT: opcode_name = "TERNOP_SLICE_COUNT"; break; - case OP_LONG: opcode_name = "OP_LONG"; break; - case OP_DOUBLE: opcode_name = "OP_DOUBLE"; break; - case OP_VAR_VALUE: opcode_name = "OP_VAR_VALUE"; break; - case OP_LAST: opcode_name = "OP_LAST"; break; - case OP_REGISTER: opcode_name = "OP_REGISTER"; break; - case OP_INTERNALVAR: opcode_name = "OP_INTERNALVAR"; break; - case OP_FUNCALL: opcode_name = "OP_FUNCALL"; break; - case OP_STRING: opcode_name = "OP_STRING"; break; - case OP_BITSTRING: opcode_name = "OP_BITSTRING"; break; - case OP_ARRAY: opcode_name = "OP_ARRAY"; break; - case UNOP_CAST: opcode_name = "UNOP_CAST"; break; - case UNOP_MEMVAL: opcode_name = "UNOP_MEMVAL"; break; - case UNOP_NEG: opcode_name = "UNOP_NEG"; break; - case UNOP_LOGICAL_NOT: opcode_name = "UNOP_LOGICAL_NOT"; break; - case UNOP_COMPLEMENT: opcode_name = "UNOP_COMPLEMENT"; break; - case UNOP_IND: opcode_name = "UNOP_IND"; break; - case UNOP_ADDR: opcode_name = "UNOP_ADDR"; break; - case UNOP_PREINCREMENT: opcode_name = "UNOP_PREINCREMENT"; break; - case UNOP_POSTINCREMENT: opcode_name = "UNOP_POSTINCREMENT"; break; - case UNOP_PREDECREMENT: opcode_name = "UNOP_PREDECREMENT"; break; - case UNOP_POSTDECREMENT: opcode_name = "UNOP_POSTDECREMENT"; break; - case UNOP_SIZEOF: opcode_name = "UNOP_SIZEOF"; break; - case UNOP_LOWER: opcode_name = "UNOP_LOWER"; break; - case UNOP_UPPER: opcode_name = "UNOP_UPPER"; break; - case UNOP_LENGTH: opcode_name = "UNOP_LENGTH"; break; - case UNOP_PLUS: opcode_name = "UNOP_PLUS"; break; - case UNOP_CAP: opcode_name = "UNOP_CAP"; break; - case UNOP_CHR: opcode_name = "UNOP_CHR"; break; - case UNOP_ORD: opcode_name = "UNOP_ORD"; break; - case UNOP_ABS: opcode_name = "UNOP_ABS"; break; - case UNOP_FLOAT: opcode_name = "UNOP_FLOAT"; break; - case UNOP_HIGH: opcode_name = "UNOP_HIGH"; break; - case UNOP_MAX: opcode_name = "UNOP_MAX"; break; - case UNOP_MIN: opcode_name = "UNOP_MIN"; break; - case UNOP_ODD: opcode_name = "UNOP_ODD"; break; - case UNOP_TRUNC: opcode_name = "UNOP_TRUNC"; break; - case OP_BOOL: opcode_name = "OP_BOOL"; break; - case OP_M2_STRING: opcode_name = "OP_M2_STRING"; break; - case STRUCTOP_STRUCT: opcode_name = "STRUCTOP_STRUCT"; break; - case STRUCTOP_PTR: opcode_name = "STRUCTOP_PTR"; break; - case OP_THIS: opcode_name = "OP_THIS"; break; - case OP_SCOPE: opcode_name = "OP_SCOPE"; break; - case OP_TYPE: opcode_name = "OP_TYPE"; break; - case OP_LABELED: opcode_name = "OP_LABELED"; break; - } + opcode_name = op_name (exp -> elts[elt].opcode); + fprintf_filtered (stream, "%20s ", opcode_name); - fprintf_filtered (stream, -#if defined (PRINTF_HAS_LONG_LONG) - "%ll16x ", -#else - "%l16x ", -#endif - exp -> elts[elt].longconst); + print_longest (stream, 'd', 0, exp -> elts[elt].longconst); + fprintf_filtered (stream, " "); for (eltscan = (char *) &exp->elts[elt], eltsize = sizeof (union exp_element) ; @@ -631,4 +650,254 @@ dump_expression (exp, stream, note) } } -#endif /* DEBUG_EXPRESSIONS */ +static int dump_subexp PARAMS ((struct expression *exp, GDB_FILE *stream, int elt)); + +static int +dump_subexp (exp, stream, elt) + struct expression *exp; + GDB_FILE *stream; + int elt; +{ + static int indent = 0; + int i; + + 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) + { + 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_SCOPE: + 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 @0x%x (", exp->elts[elt].type); + 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; + break; + case OP_DOUBLE: + fprintf_filtered (stream, "Type @0x%x (", exp->elts[elt].type); + type_print (exp->elts[elt].type, NULL, stream, 0); + fprintf_filtered (stream, "), value %g", + (double)exp->elts[elt+1].doubleconst); + elt += 3; + break; + case OP_VAR_VALUE: + fprintf_filtered (stream, "Block @0x%x, symbol @0x%x (%s)", + exp->elts[elt].block, + exp->elts[elt+1].symbol, + 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 @0x%x (%s)", + exp->elts[elt].internalvar, + 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 @0x%x (", + exp->elts[elt].type); + 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 @0x%x (", + exp->elts[elt].type); + 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 @0x%x (", exp->elts[elt].type); + 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); + } + 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"); + } + + indent -= 2; + + return elt; +} + +void +dump_postfix_expression (exp, stream, note) + struct expression *exp; + GDB_FILE *stream; + char *note; +{ + int elt; + + fprintf_filtered (stream, "Dump of expression @ "); + gdb_print_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); + + for (elt = 0; elt < exp -> nelts;) + elt = dump_subexp (exp, stream, elt); + fputs_filtered ("\n", stream); +} + +#endif /* MAINTENANCE_CMDS */ |
