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.

1 files changed, 148 insertions, 74 deletions

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;
+}