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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 #ifdef HAVE_CTYPE_H
  29 #include <ctype.h>
  30 #endif
  31
  32 /* Prototypes for local functions */
  33
  34 static void
  35 print_subexp PARAMS ((struct expression *, int *, GDB_FILE *, enum precedence));
  36
  37 void
  38 print_expression (exp, stream)
  39      struct expression *exp;
  40      GDB_FILE *stream;
  41 {
  42   int pc = 0;
  43   print_subexp (exp, &pc, stream, PREC_NULL);
  44 }
  45
  46 /* Print the subexpression of EXP that starts in position POS, on STREAM.
  47    PREC is the precedence of the surrounding operator;
  48    if the precedence of the main operator of this subexpression is less,
  49    parentheses are needed here.  */
  50
  51 static void
  52 print_subexp (exp, pos, stream, prec)
  53      register struct expression *exp;
  54      register int *pos;
  55      GDB_FILE *stream;
  56      enum precedence prec;
  57 {
  58   register unsigned tem;
  59   register const struct op_print *op_print_tab;
  60   register int pc;
  61   unsigned nargs;
  62   register char *op_str;
  63   int assign_modify = 0;
  64   enum exp_opcode opcode;
  65   enum precedence myprec = PREC_NULL;
  66   /* Set to 1 for a right-associative operator.  */
  67   int assoc = 0;
  68   value_ptr val;
  69   char *tempstr = NULL;
  70
  71   op_print_tab = exp->language_defn->la_op_print_tab;
  72   pc = (*pos)++;
  73   opcode = exp->elts[pc].opcode;
  74   switch (opcode)
  75     {
  76     /* Common ops */
  77
  78     case OP_SCOPE:
  79       myprec = PREC_PREFIX;
  80       assoc = 0;
  81       fputs_filtered (type_name_no_tag (exp->elts[pc + 1].type), stream);
  82       fputs_filtered ("::", stream);
  83       nargs = longest_to_int (exp->elts[pc + 2].longconst);
  84       (*pos) += 4 + BYTES_TO_EXP_ELEM (nargs + 1);
  85       fputs_filtered (&exp->elts[pc + 3].string, stream);
  86       return;
  87
  88     case OP_LONG:
  89       (*pos) += 3;
  90       value_print (value_from_longest (exp->elts[pc + 1].type,
  91                                        exp->elts[pc + 2].longconst),
  92                    stream, 0, Val_no_prettyprint);
  93       return;
  94
  95     case OP_DOUBLE:
  96       (*pos) += 3;
  97       value_print (value_from_double (exp->elts[pc + 1].type,
  98                                       exp->elts[pc + 2].doubleconst),
  99                    stream, 0, Val_no_prettyprint);
 100       return;
 101
 102     case OP_VAR_VALUE:
 103       {
 104         struct block *b;
 105         (*pos) += 3;
 106         b = exp->elts[pc + 1].block;
 107         if (b != NULL
 108             && BLOCK_FUNCTION (b) != NULL
 109             && SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b)) != NULL)
 110           {
 111             fputs_filtered (SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b)), stream);
 112             fputs_filtered ("::", stream);
 113           }
 114         fputs_filtered (SYMBOL_SOURCE_NAME (exp->elts[pc + 2].symbol), stream);
 115       }
 116       return;
 117
 118     case OP_LAST:
 119       (*pos) += 2;
 120       fprintf_filtered (stream, "$%d",
 121                         longest_to_int (exp->elts[pc + 1].longconst));
 122       return;
 123
 124     case OP_REGISTER:
 125       (*pos) += 2;
 126       fprintf_filtered (stream, "$%s",
 127                REGISTER_NAME (longest_to_int (exp->elts[pc + 1].longconst)));
 128       return;
 129
 130     case OP_BOOL:
 131       (*pos) += 2;
 132       fprintf_filtered (stream, "%s",
 133                         longest_to_int (exp->elts[pc + 1].longconst)
 134                         ? "TRUE" : "FALSE");
 135       return;
 136
 137     case OP_INTERNALVAR:
 138       (*pos) += 2;
 139       fprintf_filtered (stream, "$%s",
 140                internalvar_name (exp->elts[pc + 1].internalvar));
 141       return;
 142
 143     case OP_FUNCALL:
 144       (*pos) += 2;
 145       nargs = longest_to_int (exp->elts[pc + 1].longconst);
 146       print_subexp (exp, pos, stream, PREC_SUFFIX);
 147       fputs_filtered (" (", stream);
 148       for (tem = 0; tem < nargs; tem++)
 149         {
 150           if (tem != 0)
 151             fputs_filtered (", ", stream);
 152           print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
 153         }
 154       fputs_filtered (")", stream);
 155       return;
 156
 157     case OP_NAME:
 158     case OP_EXPRSTRING:
 159       nargs = longest_to_int (exp -> elts[pc + 1].longconst);
 160       (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
 161       fputs_filtered (&exp->elts[pc + 2].string, stream);
 162       return;
 163
 164     case OP_STRING:
 165       nargs = longest_to_int (exp -> elts[pc + 1].longconst);
 166       (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
 167       /* LA_PRINT_STRING will print using the current repeat count threshold.
 168          If necessary, we can temporarily set it to zero, or pass it as an
 169          additional parameter to LA_PRINT_STRING.  -fnf */
 170       LA_PRINT_STRING (stream, &exp->elts[pc + 2].string, nargs, 1, 0);
 171       return;
 172
 173     case OP_BITSTRING:
 174       nargs = longest_to_int (exp -> elts[pc + 1].longconst);
 175       (*pos)
 176         += 3 + BYTES_TO_EXP_ELEM ((nargs + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT);
 177       fprintf_unfiltered (stream, "B'<unimplemented>'");
 178       return;
 179
 180     case OP_ARRAY:
 181       (*pos) += 3;
 182       nargs = longest_to_int (exp->elts[pc + 2].longconst);
 183       nargs -= longest_to_int (exp->elts[pc + 1].longconst);
 184       nargs++;
 185       tem = 0;
 186       if (exp->elts[pc + 4].opcode == OP_LONG
 187           && exp->elts[pc + 5].type == builtin_type_char
 188           && exp->language_defn->la_language == language_c)
 189         {
 190           /* Attempt to print C character arrays using string syntax.
 191              Walk through the args, picking up one character from each
 192              of the OP_LONG expression elements.  If any array element
 193              does not match our expection of what we should find for
 194              a simple string, revert back to array printing.  Note that
 195              the last expression element is an explicit null terminator
 196              byte, which doesn't get printed. */
 197           tempstr = alloca (nargs);
 198           pc += 4;
 199           while (tem < nargs)
 200             {
 201               if (exp->elts[pc].opcode != OP_LONG
 202                   || exp->elts[pc + 1].type != builtin_type_char)
 203                 {
 204                   /* Not a simple array of char, use regular array printing. */
 205                   tem = 0;
 206                   break;
 207                 }
 208               else
 209                 {
 210                   tempstr[tem++] =
 211                     longest_to_int (exp->elts[pc + 2].longconst);
 212                   pc += 4;
 213                 }
 214             }
 215         }
 216       if (tem > 0)
 217         {
 218           LA_PRINT_STRING (stream, tempstr, nargs - 1, 1, 0);
 219           (*pos) = pc;
 220         }
 221       else
 222         {
 223           int is_chill = exp->language_defn->la_language == language_chill;
 224           fputs_filtered (is_chill ? " [" : " {", stream);
 225           for (tem = 0; tem < nargs; tem++)
 226             {
 227               if (tem != 0)
 228                 {
 229                   fputs_filtered (", ", stream);
 230                 }
 231               print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
 232             }
 233           fputs_filtered (is_chill ? "]" : "}", stream);
 234         }
 235       return;
 236
 237     case OP_LABELED:
 238       tem = longest_to_int (exp->elts[pc + 1].longconst);
 239       (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
 240
 241       if (exp->language_defn->la_language == language_chill)
 242         {
 243           fputs_filtered (".", stream);
 244           fputs_filtered (&exp->elts[pc + 2].string, stream);
 245           fputs_filtered (exp->elts[*pos].opcode == OP_LABELED ? ", "
 246                           : ": ",
 247                           stream);
 248         }
 249       else
 250         {
 251           /* Gcc support both these syntaxes.  Unsure which is preferred.  */
 252 #if 1
 253           fputs_filtered (&exp->elts[pc + 2].string, stream);
 254           fputs_filtered (": ", stream);
 255 #else
 256           fputs_filtered (".", stream);
 257           fputs_filtered (&exp->elts[pc + 2].string, stream);
 258           fputs_filtered ("=", stream);
 259 #endif
 260         }
 261       print_subexp (exp, pos, stream, PREC_SUFFIX);
 262       return;
 263
 264     case TERNOP_COND:
 265       if ((int) prec > (int) PREC_COMMA)
 266         fputs_filtered ("(", stream);
 267       /* Print the subexpressions, forcing parentheses
 268          around any binary operations within them.
 269          This is more parentheses than are strictly necessary,
 270          but it looks clearer.  */
 271       print_subexp (exp, pos, stream, PREC_HYPER);
 272       fputs_filtered (" ? ", stream);
 273       print_subexp (exp, pos, stream, PREC_HYPER);
 274       fputs_filtered (" : ", stream);
 275       print_subexp (exp, pos, stream, PREC_HYPER);
 276       if ((int) prec > (int) PREC_COMMA)
 277         fputs_filtered (")", stream);
 278       return;
 279
 280     case TERNOP_SLICE:
 281     case TERNOP_SLICE_COUNT:
 282       print_subexp (exp, pos, stream, PREC_SUFFIX);
 283       fputs_filtered ("(", stream);
 284       print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
 285       fputs_filtered (opcode == TERNOP_SLICE ? " : " : " UP ", stream);
 286       print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
 287       fputs_filtered (")", stream);
 288       return;
 289
 290     case STRUCTOP_STRUCT:
 291       tem = longest_to_int (exp->elts[pc + 1].longconst);
 292       (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
 293       print_subexp (exp, pos, stream, PREC_SUFFIX);
 294       fputs_filtered (".", stream);
 295       fputs_filtered (&exp->elts[pc + 2].string, stream);
 296       return;
 297
 298     /* Will not occur for Modula-2 */
 299     case STRUCTOP_PTR:
 300       tem = longest_to_int (exp->elts[pc + 1].longconst);
 301       (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
 302       print_subexp (exp, pos, stream, PREC_SUFFIX);
 303       fputs_filtered ("->", stream);
 304       fputs_filtered (&exp->elts[pc + 2].string, stream);
 305       return;
 306
 307     case BINOP_SUBSCRIPT:
 308       print_subexp (exp, pos, stream, PREC_SUFFIX);
 309       fputs_filtered ("[", stream);
 310       print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
 311       fputs_filtered ("]", stream);
 312       return;
 313
 314     case UNOP_POSTINCREMENT:
 315       print_subexp (exp, pos, stream, PREC_SUFFIX);
 316       fputs_filtered ("++", stream);
 317       return;
 318
 319     case UNOP_POSTDECREMENT:
 320       print_subexp (exp, pos, stream, PREC_SUFFIX);
 321       fputs_filtered ("--", stream);
 322       return;
 323
 324     case UNOP_CAST:
 325       (*pos) += 2;
 326       if ((int) prec > (int) PREC_PREFIX)
 327         fputs_filtered ("(", stream);
 328       fputs_filtered ("(", stream);
 329       type_print (exp->elts[pc + 1].type, "", stream, 0);
 330       fputs_filtered (") ", stream);
 331       print_subexp (exp, pos, stream, PREC_PREFIX);
 332       if ((int) prec > (int) PREC_PREFIX)
 333         fputs_filtered (")", stream);
 334       return;
 335
 336     case UNOP_MEMVAL:
 337       (*pos) += 2;
 338       if ((int) prec > (int) PREC_PREFIX)
 339         fputs_filtered ("(", stream);
 340       if (exp->elts[pc + 1].type->code == TYPE_CODE_FUNC &&
 341           exp->elts[pc + 3].opcode == OP_LONG) {
 342         /* We have a minimal symbol fn, probably.  It's encoded
 343            as a UNOP_MEMVAL (function-type) of an OP_LONG (int, address).
 344            Swallow the OP_LONG (including both its opcodes); ignore
 345            its type; print the value in the type of the MEMVAL.  */
 346         (*pos) += 4;
 347         val = value_at_lazy (exp->elts[pc + 1].type,
 348                              (CORE_ADDR) exp->elts[pc + 5].longconst,
 349                              NULL);
 350         value_print (val, stream, 0, Val_no_prettyprint);
 351       } else {
 352         fputs_filtered ("{", stream);
 353         type_print (exp->elts[pc + 1].type, "", stream, 0);
 354         fputs_filtered ("} ", stream);
 355         print_subexp (exp, pos, stream, PREC_PREFIX);
 356       }
 357       if ((int) prec > (int) PREC_PREFIX)
 358         fputs_filtered (")", stream);
 359       return;
 360
 361     case BINOP_ASSIGN_MODIFY:
 362       opcode = exp->elts[pc + 1].opcode;
 363       (*pos) += 2;
 364       myprec = PREC_ASSIGN;
 365       assoc = 1;
 366       assign_modify = 1;
 367       op_str = "???";
 368       for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
 369         if (op_print_tab[tem].opcode == opcode)
 370           {
 371             op_str = op_print_tab[tem].string;
 372             break;
 373           }
 374       if (op_print_tab[tem].opcode != opcode)
 375         /* Not found; don't try to keep going because we don't know how
 376            to interpret further elements.  */
 377         error ("Invalid expression");
 378       break;
 379
 380     /* C++ ops */
 381
 382     case OP_THIS:
 383       ++(*pos);
 384       fputs_filtered ("this", stream);
 385       return;
 386
 387     /* Modula-2 ops */
 388
 389     case MULTI_SUBSCRIPT:
 390       (*pos) += 2;
 391       nargs = longest_to_int (exp->elts[pc + 1].longconst);
 392       print_subexp (exp, pos, stream, PREC_SUFFIX);
 393       fprintf_unfiltered (stream, " [");
 394       for (tem = 0; tem < nargs; tem++)
 395         {
 396           if (tem != 0)
 397             fprintf_unfiltered (stream, ", ");
 398           print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
 399         }
 400       fprintf_unfiltered (stream, "]");
 401       return;
 402
 403     case BINOP_VAL:
 404       (*pos)+=2;
 405       fprintf_unfiltered(stream,"VAL(");
 406       type_print(exp->elts[pc+1].type,"",stream,0);
 407       fprintf_unfiltered(stream,",");
 408       print_subexp(exp,pos,stream,PREC_PREFIX);
 409       fprintf_unfiltered(stream,")");
 410       return;
 411
 412     case BINOP_INCL:
 413     case BINOP_EXCL:
 414       error("print_subexp:  Not implemented.");
 415
 416     /* Default ops */
 417
 418     default:
 419       op_str = "???";
 420       for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
 421         if (op_print_tab[tem].opcode == opcode)
 422           {
 423             op_str = op_print_tab[tem].string;
 424             myprec = op_print_tab[tem].precedence;
 425             assoc = op_print_tab[tem].right_assoc;
 426             break;
 427           }
 428       if (op_print_tab[tem].opcode != opcode)
 429         /* Not found; don't try to keep going because we don't know how
 430            to interpret further elements.  For example, this happens
 431            if opcode is OP_TYPE.  */
 432         error ("Invalid expression");
 433    }
 434
 435   /* Note that PREC_BUILTIN will always emit parentheses. */
 436   if ((int) myprec < (int) prec)
 437     fputs_filtered ("(", stream);
 438   if ((int) opcode > (int) BINOP_END)
 439     {
 440       if (assoc)
 441         {
 442           /* Unary postfix operator.  */
 443           print_subexp (exp, pos, stream, PREC_SUFFIX);
 444           fputs_filtered (op_str, stream);
 445         }
 446       else
 447         {
 448           /* Unary prefix operator.  */
 449           fputs_filtered (op_str, stream);
 450           if (myprec == PREC_BUILTIN_FUNCTION)
 451             fputs_filtered ("(", stream);
 452           print_subexp (exp, pos, stream, PREC_PREFIX);
 453           if (myprec == PREC_BUILTIN_FUNCTION)
 454             fputs_filtered (")", stream);
 455         }
 456     }
 457   else
 458     {
 459       /* Binary operator.  */
 460       /* Print left operand.
 461          If operator is right-associative,
 462          increment precedence for this operand.  */
 463       print_subexp (exp, pos, stream,
 464                     (enum precedence) ((int) myprec + assoc));
 465       /* Print the operator itself.  */
 466       if (assign_modify)
 467         fprintf_filtered (stream, " %s= ", op_str);
 468       else if (op_str[0] == ',')
 469         fprintf_filtered (stream, "%s ", op_str);
 470       else
 471         fprintf_filtered (stream, " %s ", op_str);
 472       /* Print right operand.
 473          If operator is left-associative,
 474          increment precedence for this operand.  */
 475       print_subexp (exp, pos, stream,
 476                     (enum precedence) ((int) myprec + !assoc));
 477     }
 478
 479   if ((int) myprec < (int) prec)
 480     fputs_filtered (")", stream);
 481 }
 482
 483 /* Return the operator corresponding to opcode OP as
 484    a string.   NULL indicates that the opcode was not found in the
 485    current language table.  */
 486 char *
 487 op_string(op)
 488    enum exp_opcode op;
 489 {
 490   int tem;
 491   register const struct op_print *op_print_tab;
 492
 493   op_print_tab = current_language->la_op_print_tab;
 494   for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
 495     if (op_print_tab[tem].opcode == op)
 496       return op_print_tab[tem].string;
 497   return NULL;
 498 }
 499
 500 /* Support for dumping the raw data from expressions in a human readable
 501    form.  */
 502
 503 static char * op_name PARAMS ((int opcode));
 504
 505 static char *
 506 op_name (opcode)
 507         int opcode;
 508 {
 509   switch (opcode)
 510     {
 511     default:
 512       {
 513         static char buf[30];
 514
 515         sprintf (buf, "<unknown %d>", opcode);
 516         return buf;
 517       }
 518     case OP_NULL: return "OP_NULL";
 519     case BINOP_ADD: return "BINOP_ADD";
 520     case BINOP_SUB: return "BINOP_SUB";
 521     case BINOP_MUL: return "BINOP_MUL";
 522     case BINOP_DIV: return "BINOP_DIV";
 523     case BINOP_REM: return "BINOP_REM";
 524     case BINOP_MOD: return "BINOP_MOD";
 525     case BINOP_LSH: return "BINOP_LSH";
 526     case BINOP_RSH: return "BINOP_RSH";
 527     case BINOP_LOGICAL_AND: return "BINOP_LOGICAL_AND";
 528     case BINOP_LOGICAL_OR: return "BINOP_LOGICAL_OR";
 529     case BINOP_BITWISE_AND: return "BINOP_BITWISE_AND";
 530     case BINOP_BITWISE_IOR: return "BINOP_BITWISE_IOR";
 531     case BINOP_BITWISE_XOR: return "BINOP_BITWISE_XOR";
 532     case BINOP_EQUAL: return "BINOP_EQUAL";
 533     case BINOP_NOTEQUAL: return "BINOP_NOTEQUAL";
 534     case BINOP_LESS: return "BINOP_LESS";
 535     case BINOP_GTR: return "BINOP_GTR";
 536     case BINOP_LEQ: return "BINOP_LEQ";
 537     case BINOP_GEQ: return "BINOP_GEQ";
 538     case BINOP_REPEAT: return "BINOP_REPEAT";
 539     case BINOP_ASSIGN: return "BINOP_ASSIGN";
 540     case BINOP_COMMA: return "BINOP_COMMA";
 541     case BINOP_SUBSCRIPT: return "BINOP_SUBSCRIPT";
 542     case MULTI_SUBSCRIPT: return "MULTI_SUBSCRIPT";
 543     case BINOP_EXP: return "BINOP_EXP";
 544     case BINOP_MIN: return "BINOP_MIN";
 545     case BINOP_MAX: return "BINOP_MAX";
 546     case BINOP_SCOPE: return "BINOP_SCOPE";
 547     case STRUCTOP_MEMBER: return "STRUCTOP_MEMBER";
 548     case STRUCTOP_MPTR: return "STRUCTOP_MPTR";
 549     case BINOP_INTDIV: return "BINOP_INTDIV";
 550     case BINOP_ASSIGN_MODIFY: return "BINOP_ASSIGN_MODIFY";
 551     case BINOP_VAL: return "BINOP_VAL";
 552     case BINOP_INCL: return "BINOP_INCL";
 553     case BINOP_EXCL: return "BINOP_EXCL";
 554     case BINOP_CONCAT: return "BINOP_CONCAT";
 555     case BINOP_RANGE: return "BINOP_RANGE";
 556     case BINOP_END: return "BINOP_END";
 557     case TERNOP_COND: return "TERNOP_COND";
 558     case TERNOP_SLICE: return "TERNOP_SLICE";
 559     case TERNOP_SLICE_COUNT: return "TERNOP_SLICE_COUNT";
 560     case OP_LONG: return "OP_LONG";
 561     case OP_DOUBLE: return "OP_DOUBLE";
 562     case OP_VAR_VALUE: return "OP_VAR_VALUE";
 563     case OP_LAST: return "OP_LAST";
 564     case OP_REGISTER: return "OP_REGISTER";
 565     case OP_INTERNALVAR: return "OP_INTERNALVAR";
 566     case OP_FUNCALL: return "OP_FUNCALL";
 567     case OP_STRING: return "OP_STRING";
 568     case OP_BITSTRING: return "OP_BITSTRING";
 569     case OP_ARRAY: return "OP_ARRAY";
 570     case UNOP_CAST: return "UNOP_CAST";
 571     case UNOP_MEMVAL: return "UNOP_MEMVAL";
 572     case UNOP_NEG: return "UNOP_NEG";
 573     case UNOP_LOGICAL_NOT: return "UNOP_LOGICAL_NOT";
 574     case UNOP_COMPLEMENT: return "UNOP_COMPLEMENT";
 575     case UNOP_IND: return "UNOP_IND";
 576     case UNOP_ADDR: return "UNOP_ADDR";
 577     case UNOP_PREINCREMENT: return "UNOP_PREINCREMENT";
 578     case UNOP_POSTINCREMENT: return "UNOP_POSTINCREMENT";
 579     case UNOP_PREDECREMENT: return "UNOP_PREDECREMENT";
 580     case UNOP_POSTDECREMENT: return "UNOP_POSTDECREMENT";
 581     case UNOP_SIZEOF: return "UNOP_SIZEOF";
 582     case UNOP_LOWER: return "UNOP_LOWER";
 583     case UNOP_UPPER: return "UNOP_UPPER";
 584     case UNOP_LENGTH: return "UNOP_LENGTH";
 585     case UNOP_PLUS: return "UNOP_PLUS";
 586     case UNOP_CAP: return "UNOP_CAP";
 587     case UNOP_CHR: return "UNOP_CHR";
 588     case UNOP_ORD: return "UNOP_ORD";
 589     case UNOP_ABS: return "UNOP_ABS";
 590     case UNOP_FLOAT: return "UNOP_FLOAT";
 591     case UNOP_HIGH: return "UNOP_HIGH";
 592     case UNOP_MAX: return "UNOP_MAX";
 593     case UNOP_MIN: return "UNOP_MIN";
 594     case UNOP_ODD: return "UNOP_ODD";
 595     case UNOP_TRUNC: return "UNOP_TRUNC";
 596     case OP_BOOL: return "OP_BOOL";
 597     case OP_M2_STRING: return "OP_M2_STRING";
 598     case STRUCTOP_STRUCT: return "STRUCTOP_STRUCT";
 599     case STRUCTOP_PTR: return "STRUCTOP_PTR";
 600     case OP_THIS: return "OP_THIS";
 601     case OP_SCOPE: return "OP_SCOPE";
 602     case OP_TYPE: return "OP_TYPE";
 603     case OP_LABELED: return "OP_LABELED";
 604     }
 605 }
 606
 607 void
 608 dump_prefix_expression (exp, stream, note)
 609      struct expression *exp;
 610      GDB_FILE *stream;
 611      char *note;
 612 {
 613   int elt;
 614   char *opcode_name;
 615   char *eltscan;
 616   int eltsize;
 617
 618   fprintf_filtered (stream, "Dump of expression @ ");
 619   gdb_print_address (exp, stream);
 620   fprintf_filtered (stream, ", %s:\nExpression: `", note);
 621   if (exp->elts[0].opcode != OP_TYPE)
 622     print_expression (exp, stream);
 623   else
 624     fprintf_filtered (stream, "Type printing not yet supported....");
 625   fprintf_filtered (stream, "'\n\tLanguage %s, %d elements, %d bytes each.\n",
 626                     exp->language_defn->la_name, exp -> nelts,
 627                     sizeof (union exp_element));
 628   fprintf_filtered (stream, "\t%5s  %20s  %16s  %s\n", "Index", "Opcode",
 629                     "Hex Value", "String Value");
 630   for (elt = 0; elt < exp -> nelts; elt++)
 631     {
 632       fprintf_filtered (stream, "\t%5d  ", elt);
 633       opcode_name = op_name (exp -> elts[elt].opcode);
 634
 635       fprintf_filtered (stream, "%20s  ", opcode_name);
 636       print_longest (stream, 'd', 0, exp -> elts[elt].longconst);
 637       fprintf_filtered (stream, "  ");
 638
 639       for (eltscan = (char *) &exp->elts[elt],
 640              eltsize = sizeof (union exp_element) ;
 641            eltsize-- > 0;
 642            eltscan++)
 643         {
 644           fprintf_filtered (stream, "%c",
 645                             isprint (*eltscan) ? (*eltscan & 0xFF) : '.');
 646         }
 647       fprintf_filtered (stream, "\n");
 648     }
 649 }
 650
 651 static int dump_subexp PARAMS ((struct expression *exp, GDB_FILE *stream, int elt));
 652
 653 static int
 654 dump_subexp (exp, stream, elt)
 655      struct expression *exp;
 656      GDB_FILE *stream;
 657      int elt;
 658 {
 659   static int indent = 0;
 660   int i;
 661
 662   fprintf_filtered (stream, "\n");
 663   fprintf_filtered (stream, "\t%5d  ", elt);
 664
 665   for (i = 1; i <= indent; i++)
 666     fprintf_filtered (stream, " ");
 667   indent += 2;
 668
 669   fprintf_filtered (stream, "%-20s  ", op_name (exp->elts[elt].opcode));
 670
 671   switch (exp -> elts[elt++].opcode)
 672     {
 673     case TERNOP_COND:
 674     case TERNOP_SLICE:
 675     case TERNOP_SLICE_COUNT:
 676       elt = dump_subexp (exp, stream, elt);
 677     case BINOP_ADD:
 678     case BINOP_SUB:
 679     case BINOP_MUL:
 680     case BINOP_DIV:
 681     case BINOP_REM:
 682     case BINOP_MOD:
 683     case BINOP_LSH:
 684     case BINOP_RSH:
 685     case BINOP_LOGICAL_AND:
 686     case BINOP_LOGICAL_OR:
 687     case BINOP_BITWISE_AND:
 688     case BINOP_BITWISE_IOR:
 689     case BINOP_BITWISE_XOR:
 690     case BINOP_EQUAL:
 691     case BINOP_NOTEQUAL:
 692     case BINOP_LESS:
 693     case BINOP_GTR:
 694     case BINOP_LEQ:
 695     case BINOP_GEQ:
 696     case BINOP_REPEAT:
 697     case BINOP_ASSIGN:
 698     case BINOP_COMMA:
 699     case BINOP_SUBSCRIPT:
 700     case BINOP_EXP:
 701     case BINOP_MIN:
 702     case BINOP_MAX:
 703     case BINOP_SCOPE:
 704     case BINOP_INTDIV:
 705     case BINOP_ASSIGN_MODIFY:
 706     case BINOP_VAL:
 707     case BINOP_INCL:
 708     case BINOP_EXCL:
 709     case BINOP_CONCAT:
 710     case BINOP_IN:
 711     case BINOP_RANGE:
 712     case BINOP_END:
 713       elt = dump_subexp (exp, stream, elt);
 714     case UNOP_NEG:
 715     case UNOP_LOGICAL_NOT:
 716     case UNOP_COMPLEMENT:
 717     case UNOP_IND:
 718     case UNOP_ADDR:
 719     case UNOP_PREINCREMENT:
 720     case UNOP_POSTINCREMENT:
 721     case UNOP_PREDECREMENT:
 722     case UNOP_POSTDECREMENT:
 723     case UNOP_SIZEOF:
 724     case UNOP_PLUS:
 725     case UNOP_CAP:
 726     case UNOP_CHR:
 727     case UNOP_ORD:
 728     case UNOP_ABS:
 729     case UNOP_FLOAT:
 730     case UNOP_HIGH:
 731     case UNOP_MAX:
 732     case UNOP_MIN:
 733     case UNOP_ODD:
 734     case UNOP_TRUNC:
 735     case UNOP_LOWER:
 736     case UNOP_UPPER:
 737     case UNOP_LENGTH:
 738     case UNOP_CARD:
 739     case UNOP_CHMAX:
 740     case UNOP_CHMIN:
 741       elt = dump_subexp (exp, stream, elt);
 742       break;
 743     case OP_LONG:
 744       fprintf_filtered (stream, "Type @0x%x (", exp->elts[elt].type);
 745       type_print (exp->elts[elt].type, NULL, stream, 0);
 746       fprintf_filtered (stream, "), value %ld (0x%lx)",
 747                         (long)exp->elts[elt+1].longconst,
 748                         (long)exp->elts[elt+1].longconst);
 749       elt += 3;
 750       break;
 751     case OP_DOUBLE:
 752       fprintf_filtered (stream, "Type @0x%x (", exp->elts[elt].type);
 753       type_print (exp->elts[elt].type, NULL, stream, 0);
 754       fprintf_filtered (stream, "), value %g",
 755                         (double)exp->elts[elt+1].doubleconst);
 756       elt += 3;
 757       break;
 758     case OP_VAR_VALUE:
 759       fprintf_filtered (stream, "Block @0x%x, symbol @0x%x (%s)",
 760                         exp->elts[elt].block,
 761                         exp->elts[elt+1].symbol,
 762                         SYMBOL_NAME (exp->elts[elt+1].symbol));
 763       elt += 3;
 764       break;
 765     case OP_LAST:
 766       fprintf_filtered (stream, "History element %ld",
 767                         (long)exp->elts[elt].longconst);
 768       elt += 2;
 769       break;
 770     case OP_REGISTER:
 771       fprintf_filtered (stream, "Register %ld",
 772                         (long)exp->elts[elt].longconst);
 773       elt += 2;
 774       break;
 775     case OP_INTERNALVAR:
 776       fprintf_filtered (stream, "Internal var @0x%x (%s)",
 777                         exp->elts[elt].internalvar,
 778                         exp->elts[elt].internalvar->name);
 779       elt += 2;
 780       break;
 781     case OP_FUNCALL:
 782       {
 783         int nargs;
 784
 785         nargs = longest_to_int (exp->elts[elt].longconst);
 786
 787         fprintf_filtered (stream, "Number of args: %d", nargs);
 788         elt += 2;
 789
 790         for (i = 1; i <= nargs + 1; i++)
 791           elt = dump_subexp (exp, stream, elt);
 792       }
 793       break;
 794     case OP_ARRAY:
 795       {
 796         int lower, upper;
 797         int i;
 798
 799         lower = longest_to_int (exp->elts[elt].longconst);
 800         upper = longest_to_int (exp->elts[elt + 1].longconst);
 801
 802         fprintf_filtered (stream, "Bounds [%d:%d]", lower, upper);
 803         elt += 3;
 804
 805         for (i = 1; i <= upper - lower + 1; i++)
 806           elt = dump_subexp (exp, stream, elt);
 807       }
 808       break;
 809     case UNOP_MEMVAL:
 810     case UNOP_CAST:
 811       fprintf_filtered (stream, "Type @0x%x (",
 812                           exp->elts[elt].type);
 813       type_print (exp->elts[elt].type, NULL, stream, 0);
 814       fprintf_filtered (stream, ")");
 815       elt = dump_subexp (exp, stream, elt + 2);
 816       break;
 817     case OP_TYPE:
 818       fprintf_filtered (stream, "Type @0x%x (",
 819                           exp->elts[elt].type);
 820       type_print (exp->elts[elt].type, NULL, stream, 0);
 821       fprintf_filtered (stream, ")");
 822       elt += 2;
 823       break;
 824     case STRUCTOP_STRUCT:
 825     case STRUCTOP_PTR:
 826       {
 827         char *elem_name;
 828         int len;
 829
 830         len = longest_to_int (exp->elts[elt].longconst);
 831         elem_name = &exp->elts[elt + 1].string;
 832
 833         fprintf_filtered (stream, "Element name: `%.*s'", len, elem_name);
 834         elt = dump_subexp (exp, stream, elt + 3 + BYTES_TO_EXP_ELEM (len + 1));
 835       }
 836       break;
 837     case OP_SCOPE:
 838       {
 839         char *elem_name;
 840         int len;
 841
 842         fprintf_filtered (stream, "Type @0x%x (", exp->elts[elt].type);
 843         type_print (exp->elts[elt].type, NULL, stream, 0);
 844         fprintf_filtered (stream, ") ");
 845
 846         len = longest_to_int (exp->elts[elt + 1].longconst);
 847         elem_name = &exp->elts[elt + 2].string;
 848
 849         fprintf_filtered (stream, "Field name: `%.*s'", len, elem_name);
 850         elt += 4 + BYTES_TO_EXP_ELEM (len + 1);
 851       }
 852       break;
 853     default:
 854     case OP_NULL:
 855     case STRUCTOP_MEMBER:
 856     case STRUCTOP_MPTR:
 857     case MULTI_SUBSCRIPT:
 858     case OP_F77_UNDETERMINED_ARGLIST:
 859     case OP_COMPLEX:
 860     case OP_STRING:
 861     case OP_BITSTRING:
 862     case OP_BOOL:
 863     case OP_M2_STRING:
 864     case OP_THIS:
 865     case OP_LABELED:
 866     case OP_NAME:
 867     case OP_EXPRSTRING:
 868       fprintf_filtered (stream, "Unknown format");
 869     }
 870
 871   indent -= 2;
 872
 873   return elt;
 874 }
 875
 876 void
 877 dump_postfix_expression (exp, stream, note)
 878      struct expression *exp;
 879      GDB_FILE *stream;
 880      char *note;
 881 {
 882   int elt;
 883
 884   fprintf_filtered (stream, "Dump of expression @ ");
 885   gdb_print_address (exp, stream);
 886   fprintf_filtered (stream, ", %s:\nExpression: `", note);
 887   if (exp->elts[0].opcode != OP_TYPE)
 888     print_expression (exp, stream);
 889   else
 890     fputs_filtered ("Type printing not yet supported....", stream);
 891   fprintf_filtered (stream, "'\n\tLanguage %s, %d elements, %d bytes each.\n",
 892                     exp->language_defn->la_name, exp -> nelts,
 893                     sizeof (union exp_element));
 894   fputs_filtered ("\n", stream);
 895
 896   for (elt = 0; elt < exp -> nelts;)
 897     elt = dump_subexp (exp, stream, elt);
 898   fputs_filtered ("\n", stream);
 899 }