gdb/expprint.c

   1 /* Print in infix form a struct expression.
   2    Copyright (C) 1986, 1989, 1991 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include "defs.h"
  21 #include "symtab.h"
  22 #include "gdbtypes.h"
  23 #include "expression.h"
  24 #include "value.h"
  25 #include "language.h"
  26 #include "parser-defs.h"
  27
  28 /* Prototypes for local functions */
  29
  30 static void
  31 print_subexp PARAMS ((struct expression *, int *, FILE *, enum precedence));
  32
  33 static void
  34 print_simple_m2_func PARAMS ((char *, struct expression *, int *, FILE *));
  35
  36 void
  37 print_expression (exp, stream)
  38      struct expression *exp;
  39      FILE *stream;
  40 {
  41   int pc = 0;
  42   print_subexp (exp, &pc, stream, PREC_NULL);
  43 }
  44
  45 /* Print the subexpression of EXP that starts in position POS, on STREAM.
  46    PREC is the precedence of the surrounding operator;
  47    if the precedence of the main operator of this subexpression is less,
  48    parentheses are needed here.  */
  49
  50 static void
  51 print_subexp (exp, pos, stream, prec)
  52      register struct expression *exp;
  53      register int *pos;
  54      FILE *stream;
  55      enum precedence prec;
  56 {
  57   register unsigned tem;
  58   register const struct op_print *op_print_tab;
  59   register int pc;
  60   unsigned nargs;
  61   register char *op_str;
  62   int assign_modify = 0;
  63   enum exp_opcode opcode;
  64   enum precedence myprec;
  65   /* Set to 1 for a right-associative operator.  */
  66   int assoc;
  67   value val;
  68
  69   op_print_tab = exp->language_defn->la_op_print_tab;
  70   pc = (*pos)++;
  71   opcode = exp->elts[pc].opcode;
  72   switch (opcode)
  73     {
  74     /* Common ops */
  75
  76     case OP_SCOPE:
  77       (*pos) += 2;
  78       type_print (exp->elts[pc + 1].type, "", stream, 0);
  79       fputs_filtered ("::", stream);
  80       nargs = strlen (&exp->elts[pc + 2].string);
  81       (*pos) += 1 + (nargs + sizeof (union exp_element)) / sizeof (union exp_element);
  82
  83       fputs_filtered (&exp->elts[pc + 2].string, stream);
  84       return;
  85
  86     case OP_LONG:
  87       (*pos) += 3;
  88       value_print (value_from_longest (exp->elts[pc + 1].type,
  89                                     exp->elts[pc + 2].longconst),
  90                    stream, 0, Val_no_prettyprint);
  91       return;
  92
  93     case OP_DOUBLE:
  94       (*pos) += 3;
  95       value_print (value_from_double (exp->elts[pc + 1].type,
  96                                       exp->elts[pc + 2].doubleconst),
  97                    stream, 0, Val_no_prettyprint);
  98       return;
  99
 100     case OP_VAR_VALUE:
 101       (*pos) += 2;
 102       fputs_filtered (SYMBOL_NAME (exp->elts[pc + 1].symbol), stream);
 103       return;
 104
 105     case OP_LAST:
 106       (*pos) += 2;
 107       fprintf_filtered (stream, "$%d",
 108                         longest_to_int (exp->elts[pc + 1].longconst));
 109       return;
 110
 111     case OP_REGISTER:
 112       (*pos) += 2;
 113       fprintf_filtered (stream, "$%s",
 114                reg_names[longest_to_int (exp->elts[pc + 1].longconst)]);
 115       return;
 116
 117     case OP_INTERNALVAR:
 118       (*pos) += 2;
 119       fprintf_filtered (stream, "$%s",
 120                internalvar_name (exp->elts[pc + 1].internalvar));
 121       return;
 122
 123     case OP_FUNCALL:
 124       (*pos) += 2;
 125       nargs = longest_to_int (exp->elts[pc + 1].longconst);
 126       print_subexp (exp, pos, stream, PREC_SUFFIX);
 127       fputs_filtered (" (", stream);
 128       for (tem = 0; tem < nargs; tem++)
 129         {
 130           if (tem != 0)
 131             fputs_filtered (", ", stream);
 132           print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
 133         }
 134       fputs_filtered (")", stream);
 135       return;
 136
 137     case OP_STRING:
 138       nargs = strlen (&exp->elts[pc + 1].string);
 139       (*pos) += 2 + (nargs + sizeof (union exp_element)) / sizeof (union exp_element);
 140       fputs_filtered ("\"", stream);
 141       for (tem = 0; tem < nargs; tem++)
 142         printchar ((&exp->elts[pc + 1].string)[tem], stream, '"');
 143       fputs_filtered ("\"", stream);
 144       return;
 145
 146     case TERNOP_COND:
 147       if ((int) prec > (int) PREC_COMMA)
 148         fputs_filtered ("(", stream);
 149       /* Print the subexpressions, forcing parentheses
 150          around any binary operations within them.
 151          This is more parentheses than are strictly necessary,
 152          but it looks clearer.  */
 153       print_subexp (exp, pos, stream, PREC_HYPER);
 154       fputs_filtered (" ? ", stream);
 155       print_subexp (exp, pos, stream, PREC_HYPER);
 156       fputs_filtered (" : ", stream);
 157       print_subexp (exp, pos, stream, PREC_HYPER);
 158       if ((int) prec > (int) PREC_COMMA)
 159         fputs_filtered (")", stream);
 160       return;
 161
 162     case STRUCTOP_STRUCT:
 163       tem = strlen (&exp->elts[pc + 2].string);
 164       (*pos) += 3 + (tem + sizeof (union exp_element)) / sizeof (union exp_element);
 165       print_subexp (exp, pos, stream, PREC_SUFFIX);
 166       fputs_filtered (".", stream);
 167       if (exp->elts[pc + 1].type)
 168         {
 169           type_print (exp->elts[pc + 1].type, "", stream, 0);
 170           fputs_filtered ("::", stream);
 171         }
 172       fputs_filtered (&exp->elts[pc + 2].string, stream);
 173       return;
 174
 175     /* Will not occur for Modula-2 */
 176     case STRUCTOP_PTR:
 177       tem = strlen (&exp->elts[pc + 2].string);
 178       (*pos) += 3 + (tem + sizeof (union exp_element)) / sizeof (union exp_element);
 179       print_subexp (exp, pos, stream, PREC_SUFFIX);
 180       fputs_filtered ("->", stream);
 181       if (exp->elts[pc + 1].type)
 182         {
 183           type_print (exp->elts[pc + 1].type, "", stream, 0);
 184           fputs_filtered ("::", stream);
 185         }
 186       fputs_filtered (&exp->elts[pc + 2].string, stream);
 187       return;
 188
 189     case BINOP_SUBSCRIPT:
 190       print_subexp (exp, pos, stream, PREC_SUFFIX);
 191       fputs_filtered ("[", stream);
 192       print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
 193       fputs_filtered ("]", stream);
 194       return;
 195
 196     case UNOP_POSTINCREMENT:
 197       print_subexp (exp, pos, stream, PREC_SUFFIX);
 198       fputs_filtered ("++", stream);
 199       return;
 200
 201     case UNOP_POSTDECREMENT:
 202       print_subexp (exp, pos, stream, PREC_SUFFIX);
 203       fputs_filtered ("--", stream);
 204       return;
 205
 206     case UNOP_CAST:
 207       (*pos) += 2;
 208       if ((int) prec > (int) PREC_PREFIX)
 209         fputs_filtered ("(", stream);
 210       fputs_filtered ("(", stream);
 211       type_print (exp->elts[pc + 1].type, "", stream, 0);
 212       fputs_filtered (") ", stream);
 213       print_subexp (exp, pos, stream, PREC_PREFIX);
 214       if ((int) prec > (int) PREC_PREFIX)
 215         fputs_filtered (")", stream);
 216       return;
 217
 218     case UNOP_MEMVAL:
 219       (*pos) += 2;
 220       if ((int) prec > (int) PREC_PREFIX)
 221         fputs_filtered ("(", stream);
 222       if (exp->elts[pc + 1].type->code == TYPE_CODE_FUNC &&
 223           exp->elts[pc + 3].opcode == OP_LONG) {
 224         /* We have a minimal symbol fn, probably.  It's encoded
 225            as a UNOP_MEMVAL (function-type) of an OP_LONG (int, address).
 226            Swallow the OP_LONG (including both its opcodes); ignore
 227            its type; print the value in the type of the MEMVAL.  */
 228         (*pos) += 4;
 229         val = value_at_lazy (exp->elts[pc + 1].type,
 230                              (CORE_ADDR) exp->elts[pc + 5].longconst);
 231         value_print (val, stream, 0, Val_no_prettyprint);
 232       } else {
 233         fputs_filtered ("{", stream);
 234         type_print (exp->elts[pc + 1].type, "", stream, 0);
 235         fputs_filtered ("} ", stream);
 236         print_subexp (exp, pos, stream, PREC_PREFIX);
 237       }
 238       if ((int) prec > (int) PREC_PREFIX)
 239         fputs_filtered (")", stream);
 240       return;
 241
 242     case BINOP_ASSIGN_MODIFY:
 243       opcode = exp->elts[pc + 1].opcode;
 244       (*pos) += 2;
 245       myprec = PREC_ASSIGN;
 246       assoc = 1;
 247       assign_modify = 1;
 248       op_str = "???";
 249       for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
 250         if (op_print_tab[tem].opcode == opcode)
 251           {
 252             op_str = op_print_tab[tem].string;
 253             break;
 254           }
 255       break;
 256
 257     /* C++ ops */
 258
 259     case OP_THIS:
 260       ++(*pos);
 261       fputs_filtered ("this", stream);
 262       return;
 263
 264     /* Modula-2 ops */
 265
 266     case BINOP_MULTI_SUBSCRIPT:
 267       (*pos) += 2;
 268       nargs = longest_to_int (exp->elts[pc + 1].longconst);
 269       print_subexp (exp, pos, stream, PREC_SUFFIX);
 270       fprintf (stream, " [");
 271       for (tem = 0; tem < nargs; tem++)
 272         {
 273           if (tem != 0)
 274             fprintf (stream, ", ");
 275           print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
 276         }
 277       fprintf (stream, "]");
 278       return;
 279
 280     case BINOP_VAL:
 281       (*pos)+=2;
 282       fprintf(stream,"VAL(");
 283       type_print(exp->elts[pc+1].type,"",stream,0);
 284       fprintf(stream,",");
 285       print_subexp(exp,pos,stream,PREC_PREFIX);
 286       fprintf(stream,")");
 287       return;
 288
 289     case UNOP_CAP:
 290       print_simple_m2_func("CAP",exp,pos,stream);
 291       return;
 292
 293     case UNOP_CHR:
 294       print_simple_m2_func("CHR",exp,pos,stream);
 295       return;
 296
 297     case UNOP_ORD:
 298       print_simple_m2_func("ORD",exp,pos,stream);
 299       return;
 300
 301     case UNOP_ABS:
 302       print_simple_m2_func("ABS",exp,pos,stream);
 303       return;
 304
 305     case UNOP_FLOAT:
 306       print_simple_m2_func("FLOAT",exp,pos,stream);
 307       return;
 308
 309     case UNOP_HIGH:
 310       print_simple_m2_func("HIGH",exp,pos,stream);
 311       return;
 312
 313     case UNOP_MAX:
 314       print_simple_m2_func("MAX",exp,pos,stream);
 315       return;
 316
 317     case UNOP_MIN:
 318       print_simple_m2_func("MIN",exp,pos,stream);
 319       return;
 320
 321     case UNOP_ODD:
 322       print_simple_m2_func("ODD",exp,pos,stream);
 323       return;
 324
 325     case UNOP_TRUNC:
 326       print_simple_m2_func("TRUNC",exp,pos,stream);
 327       return;
 328
 329     case BINOP_INCL:
 330     case BINOP_EXCL:
 331       error("print_subexp:  Not implemented.");
 332
 333     /* Default ops */
 334
 335     default:
 336       op_str = "???";
 337       for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
 338         if (op_print_tab[tem].opcode == opcode)
 339           {
 340             op_str = op_print_tab[tem].string;
 341             myprec = op_print_tab[tem].precedence;
 342             assoc = op_print_tab[tem].right_assoc;
 343             break;
 344           }
 345    }
 346
 347   if ((int) myprec < (int) prec)
 348     fputs_filtered ("(", stream);
 349   if ((int) opcode > (int) BINOP_END)
 350     {
 351       /* Unary prefix operator.  */
 352       fputs_filtered (op_str, stream);
 353       print_subexp (exp, pos, stream, PREC_PREFIX);
 354     }
 355   else
 356     {
 357       /* Binary operator.  */
 358       /* Print left operand.
 359          If operator is right-associative,
 360          increment precedence for this operand.  */
 361       print_subexp (exp, pos, stream,
 362                     (enum precedence) ((int) myprec + assoc));
 363       /* Print the operator itself.  */
 364       if (assign_modify)
 365         fprintf_filtered (stream, " %s= ", op_str);
 366       else if (op_str[0] == ',')
 367         fprintf_filtered (stream, "%s ", op_str);
 368       else
 369         fprintf_filtered (stream, " %s ", op_str);
 370       /* Print right operand.
 371          If operator is left-associative,
 372          increment precedence for this operand.  */
 373       print_subexp (exp, pos, stream,
 374                     (enum precedence) ((int) myprec + !assoc));
 375     }
 376
 377   if ((int) myprec < (int) prec)
 378     fputs_filtered (")", stream);
 379 }
 380
 381 /* Print out something of the form <s>(<arg>).
 382    This is used to print out some builtin Modula-2
 383    functions.
 384    FIXME:  There is probably some way to get the precedence
 385    rules to do this (print a unary operand with parens around it).  */
 386 static void
 387 print_simple_m2_func(s,exp,pos,stream)
 388    char *s;
 389    register struct expression *exp;
 390    register int *pos;
 391    FILE *stream;
 392 {
 393    fprintf(stream,"%s(",s);
 394    print_subexp(exp,pos,stream,PREC_PREFIX);
 395    fprintf(stream,")");
 396 }
 397
 398 /* Return the operator corresponding to opcode OP as
 399    a string.   NULL indicates that the opcode was not found in the
 400    current language table.  */
 401 char *
 402 op_string(op)
 403    enum exp_opcode op;
 404 {
 405   int tem;
 406   register const struct op_print *op_print_tab;
 407
 408   op_print_tab = current_language->la_op_print_tab;
 409   for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
 410     if (op_print_tab[tem].opcode == op)
 411       return op_print_tab[tem].string;
 412   return NULL;
 413 }