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.
This commit is contained in:
parent
d1dc824fa9
commit
28de880c48
|
@ -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))
|
||||
|
|
218
gdb/expprint.c
218
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 };
|
||||
/* Prototypes for local functions */
|
||||
|
||||
/* Table mapping opcodes into strings for printing operators
|
||||
and precedences of the operators. */
|
||||
static void
|
||||
print_subexp PARAMS ((struct expression *, int *, FILE *, enum precedence));
|
||||
|
||||
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 ();
|
||||
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;
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue