diff options
| -rw-r--r-- | gdb/ChangeLog | 6 | ||||
| -rw-r--r-- | gdb/defs.h | 2 | ||||
| -rw-r--r-- | gdb/expprint.c | 222 |
3 files changed, 155 insertions, 75 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 52fe895..13124c3 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,9 @@ +Thu Jun 11 12:31:50 1992 John Gilmore (gnu at cygnus.com) + + Two `long long' fixes from Robert R. Henry (rrh@dino.tera.com): + * defs.h (longest_to_int): Avoid void arm of ?: in error case. + * expprint.c (print_subexp): Fix printing of register names. + Thu Jun 11 01:33:40 1992 John Gilmore (gnu at cygnus.com) * inferior.h (register_valid): Declare. @@ -492,7 +492,7 @@ local_hex_string_custom PARAMS ((int, char *)); /* language.c */ #if !defined (longest_to_int) #if defined (LONG_LONG) #define longest_to_int(x) (((x) > INT_MAX || (x) < INT_MIN) \ - ? error ("Value out of range.") : (int) (x)) + ? (error ("Value out of range."),0) : (int) (x)) #else /* No LONG_LONG. */ /* Assume sizeof (int) == sizeof (long). */ #define longest_to_int(x) ((int) (x)) diff --git a/gdb/expprint.c b/gdb/expprint.c index e96dc7f..f642ea7 100644 --- a/gdb/expprint.c +++ b/gdb/expprint.c @@ -1,5 +1,5 @@ /* Print in infix form a struct expression. - Copyright (C) 1986, 1989 Free Software Foundation, Inc. + Copyright (C) 1986, 1989, 1991 Free Software Foundation, Inc. This file is part of GDB. @@ -17,75 +17,21 @@ 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., 675 Mass Ave, Cambridge, MA 02139, USA. */ -#include <stdio.h> #include "defs.h" #include "symtab.h" -#include "param.h" +#include "gdbtypes.h" #include "expression.h" #include "value.h" +#include "language.h" +#include "parser-defs.h" - -/* These codes indicate operator precedences, least tightly binding first. */ -/* Adding 1 to a precedence value is done for binary operators, - on the operand which is more tightly bound, so that operators - of equal precedence within that operand will get parentheses. */ -/* PREC_HYPER and PREC_ABOVE_COMMA are not the precedence of any operator; - they are used as the "surrounding precedence" to force - various kinds of things to be parenthesized. */ -enum precedence -{ PREC_NULL, PREC_COMMA, PREC_ABOVE_COMMA, PREC_ASSIGN, PREC_OR, PREC_AND, - PREC_LOGIOR, PREC_LOGAND, PREC_LOGXOR, PREC_EQUAL, PREC_ORDER, - PREC_SHIFT, PREC_ADD, PREC_MUL, PREC_REPEAT, - PREC_HYPER, PREC_PREFIX, PREC_SUFFIX }; - -/* Table mapping opcodes into strings for printing operators - and precedences of the operators. */ - -struct op_print -{ - char *string; - enum exp_opcode opcode; - /* Precedence of operator. These values are used only by comparisons. */ - enum precedence precedence; - int right_assoc; -}; - -const static struct op_print op_print_tab[] = - { - {",", BINOP_COMMA, PREC_COMMA, 0}, - {"=", BINOP_ASSIGN, PREC_ASSIGN, 1}, - {"||", BINOP_OR, PREC_OR, 0}, - {"&&", BINOP_AND, PREC_AND, 0}, - {"|", BINOP_LOGIOR, PREC_LOGIOR, 0}, - {"&", BINOP_LOGAND, PREC_LOGAND, 0}, - {"^", BINOP_LOGXOR, PREC_LOGXOR, 0}, - {"==", BINOP_EQUAL, PREC_EQUAL, 0}, - {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0}, - {"<=", BINOP_LEQ, PREC_ORDER, 0}, - {">=", BINOP_GEQ, PREC_ORDER, 0}, - {">", BINOP_GTR, PREC_ORDER, 0}, - {"<", BINOP_LESS, PREC_ORDER, 0}, - {">>", BINOP_RSH, PREC_SHIFT, 0}, - {"<<", BINOP_LSH, PREC_SHIFT, 0}, - {"+", BINOP_ADD, PREC_ADD, 0}, - {"-", BINOP_SUB, PREC_ADD, 0}, - {"*", BINOP_MUL, PREC_MUL, 0}, - {"/", BINOP_DIV, PREC_MUL, 0}, - {"%", BINOP_REM, PREC_MUL, 0}, - {"@", BINOP_REPEAT, PREC_REPEAT, 0}, - {"-", UNOP_NEG, PREC_PREFIX, 0}, - {"!", UNOP_ZEROP, PREC_PREFIX, 0}, - {"~", UNOP_LOGNOT, PREC_PREFIX, 0}, - {"*", UNOP_IND, PREC_PREFIX, 0}, - {"&", UNOP_ADDR, PREC_PREFIX, 0}, - {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0}, - {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0}, - {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0}, - /* C++ */ - {"::", BINOP_SCOPE, PREC_PREFIX, 0}, - }; - -static void print_subexp (); +/* Prototypes for local functions */ + +static void +print_subexp PARAMS ((struct expression *, int *, FILE *, enum precedence)); + +static void +print_simple_m2_func PARAMS ((char *, struct expression *, int *, FILE *)); void print_expression (exp, stream) @@ -109,6 +55,7 @@ print_subexp (exp, pos, stream, prec) enum precedence prec; { register unsigned tem; + register const struct op_print *op_print_tab; register int pc; unsigned nargs; register char *op_str; @@ -117,11 +64,15 @@ print_subexp (exp, pos, stream, prec) enum precedence myprec; /* Set to 1 for a right-associative operator. */ int assoc; + value val; + 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; @@ -137,7 +88,7 @@ print_subexp (exp, pos, stream, prec) case OP_LONG: (*pos) += 3; - value_print (value_from_long (exp->elts[pc + 1].type, + value_print (value_from_longest (exp->elts[pc + 1].type, exp->elts[pc + 2].longconst), stream, 0, Val_no_prettyprint); return; @@ -163,7 +114,7 @@ print_subexp (exp, pos, stream, prec) case OP_REGISTER: (*pos) += 2; fprintf_filtered (stream, "$%s", - longest_to_int (reg_names[exp->elts[pc + 1].longconst])); + reg_names[longest_to_int (exp->elts[pc + 1].longconst)); return; case OP_INTERNALVAR: @@ -219,6 +170,7 @@ print_subexp (exp, pos, stream, prec) fputs_filtered (&exp->elts[pc + 1].string, stream); return; + /* Will not occur for Modula-2 */ case STRUCTOP_PTR: tem = strlen (&exp->elts[pc + 1].string); (*pos) += 2 + (tem + sizeof (union exp_element)) / sizeof (union exp_element); @@ -260,10 +212,22 @@ print_subexp (exp, pos, stream, prec) (*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 (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); + 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; @@ -274,7 +238,8 @@ print_subexp (exp, pos, stream, prec) myprec = PREC_ASSIGN; assoc = 1; assign_modify = 1; - for (tem = 0; tem < sizeof op_print_tab / sizeof op_print_tab[0]; tem++) + 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; @@ -282,13 +247,87 @@ print_subexp (exp, pos, stream, prec) } break; + /* C++ ops */ + case OP_THIS: ++(*pos); fputs_filtered ("this", stream); return; + /* Modula-2 ops */ + + case BINOP_MULTI_SUBSCRIPT: + (*pos) += 2; + nargs = longest_to_int (exp->elts[pc + 1].longconst); + print_subexp (exp, pos, stream, PREC_SUFFIX); + fprintf (stream, " ["); + for (tem = 0; tem < nargs; tem++) + { + if (tem != 0) + fprintf (stream, ", "); + print_subexp (exp, pos, stream, PREC_ABOVE_COMMA); + } + fprintf (stream, "]"); + return; + + case BINOP_VAL: + (*pos)+=2; + fprintf(stream,"VAL("); + type_print(exp->elts[pc+1].type,"",stream,0); + fprintf(stream,","); + print_subexp(exp,pos,stream,PREC_PREFIX); + fprintf(stream,")"); + return; + + case UNOP_CAP: + print_simple_m2_func("CAP",exp,pos,stream); + return; + + case UNOP_CHR: + print_simple_m2_func("CHR",exp,pos,stream); + return; + + case UNOP_ORD: + print_simple_m2_func("ORD",exp,pos,stream); + return; + + case UNOP_ABS: + print_simple_m2_func("ABS",exp,pos,stream); + return; + + case UNOP_FLOAT: + print_simple_m2_func("FLOAT",exp,pos,stream); + return; + + case UNOP_HIGH: + print_simple_m2_func("HIGH",exp,pos,stream); + return; + + case UNOP_MAX: + print_simple_m2_func("MAX",exp,pos,stream); + return; + + case UNOP_MIN: + print_simple_m2_func("MIN",exp,pos,stream); + return; + + case UNOP_ODD: + print_simple_m2_func("ODD",exp,pos,stream); + return; + + case UNOP_TRUNC: + print_simple_m2_func("TRUNC",exp,pos,stream); + return; + + case BINOP_INCL: + case BINOP_EXCL: + error("print_subexp: Not implemented."); + + /* Default ops */ + default: - for (tem = 0; tem < sizeof op_print_tab / sizeof op_print_tab[0]; tem++) + 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; @@ -296,7 +335,7 @@ print_subexp (exp, pos, stream, prec) assoc = op_print_tab[tem].right_assoc; break; } - } + } if ((int) myprec < (int) prec) fputs_filtered ("(", stream); @@ -327,6 +366,41 @@ print_subexp (exp, pos, stream, prec) print_subexp (exp, pos, stream, (enum precedence) ((int) myprec + !assoc)); } + if ((int) myprec < (int) prec) fputs_filtered (")", stream); } + +/* Print out something of the form <s>(<arg>). + This is used to print out some builtin Modula-2 + functions. + FIXME: There is probably some way to get the precedence + rules to do this (print a unary operand with parens around it). */ +static void +print_simple_m2_func(s,exp,pos,stream) + char *s; + register struct expression *exp; + register int *pos; + FILE *stream; +{ + fprintf(stream,"%s(",s); + print_subexp(exp,pos,stream,PREC_PREFIX); + fprintf(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; +{ + 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; +} |