[deliverable/binutils-gdb.git] / gdb / expprint.c

/* Print in infix form a struct expression.
   Copyright (C) 1986, 1989, 1991 Free Software Foundation, Inc.

This file is part of GDB.

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

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 "defs.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "expression.h"
#include "value.h"
#include "language.h"
#include "parser-defs.h"

/* 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)
     struct expression *exp;
     FILE *stream;
{
  int pc = 0;
  print_subexp (exp, &pc, stream, PREC_NULL);
}

/* Print the subexpression of EXP that starts in position POS, on STREAM.
   PREC is the precedence of the surrounding operator;
   if the precedence of the main operator of this subexpression is less,
   parentheses are needed here.  */

static void
print_subexp (exp, pos, stream, prec)
     register struct expression *exp;
     register int *pos;
     FILE *stream;
     enum precedence prec;
{
  register unsigned tem;
  register const struct op_print *op_print_tab;
  register int pc;
  unsigned nargs;
  register char *op_str;
  int assign_modify = 0;
  enum exp_opcode opcode;
  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;
      (*pos) += 3;
      print_subexp (exp, pos, stream,
		    (enum precedence) ((int) myprec + assoc));
      fputs_filtered (" :: ", stream);
      nargs = longest_to_int (exp->elts[pc + 2].longconst);
      (*pos) += 2 + BYTES_TO_EXP_ELEM (nargs + 1);
      fputs_filtered (&exp->elts[pc + 3].string, stream);
      return;

    case OP_LONG:
      (*pos) += 3;
      value_print (value_from_longest (exp->elts[pc + 1].type,
				       exp->elts[pc + 2].longconst),
		   stream, 0, Val_no_prettyprint);
      return;

    case OP_DOUBLE:
      (*pos) += 3;
      value_print (value_from_double (exp->elts[pc + 1].type,
				      exp->elts[pc + 2].doubleconst),
		   stream, 0, Val_no_prettyprint);
      return;

    case OP_VAR_VALUE:
      (*pos) += 2;
      fputs_filtered (SYMBOL_SOURCE_NAME (exp->elts[pc + 1].symbol), stream);
      return;

    case OP_LAST:
      (*pos) += 2;
      fprintf_filtered (stream, "$%d",
			longest_to_int (exp->elts[pc + 1].longconst));
      return;

    case OP_REGISTER:
      (*pos) += 2;
      fprintf_filtered (stream, "$%s",
	       reg_names[longest_to_int (exp->elts[pc + 1].longconst)]);
      return;

    case OP_BOOL:
      (*pos) += 2;
      fprintf_filtered (stream, "%s",
			longest_to_int (exp->elts[pc + 1].longconst)
			? "TRUE" : "FALSE");
      return;

    case OP_INTERNALVAR:
      (*pos) += 2;
      fprintf_filtered (stream, "$%s",
	       internalvar_name (exp->elts[pc + 1].internalvar));
      return;

    case OP_FUNCALL:
      (*pos) += 2;
      nargs = longest_to_int (exp->elts[pc + 1].longconst);
      print_subexp (exp, pos, stream, PREC_SUFFIX);
      fputs_filtered (" (", stream);
      for (tem = 0; tem < nargs; tem++)
	{
	  if (tem != 0)
	    fputs_filtered (", ", stream);
	  print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
	}
      fputs_filtered (")", stream);
      return;

    case OP_STRING:
      nargs = longest_to_int (exp -> elts[pc + 1].longconst);
      (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
      /* LA_PRINT_STRING will print using the current repeat count threshold.
	 If necessary, we can temporarily set it to zero, or pass it as an
	 additional parameter to LA_PRINT_STRING.  -fnf */
      LA_PRINT_STRING (stream, &exp->elts[pc + 2].string, nargs, 0);
      return;

    case OP_BITSTRING:
      error ("support for OP_BITSTRING unimplemented");
      break;

    case OP_ARRAY:
      error ("support for OP_ARRAY unimplemented");
      break;

    case TERNOP_COND:
      if ((int) prec > (int) PREC_COMMA)
	fputs_filtered ("(", stream);
      /* Print the subexpressions, forcing parentheses
	 around any binary operations within them.
	 This is more parentheses than are strictly necessary,
	 but it looks clearer.  */
      print_subexp (exp, pos, stream, PREC_HYPER);
      fputs_filtered (" ? ", stream);
      print_subexp (exp, pos, stream, PREC_HYPER);
      fputs_filtered (" : ", stream);
      print_subexp (exp, pos, stream, PREC_HYPER);
      if ((int) prec > (int) PREC_COMMA)
	fputs_filtered (")", stream);
      return;

    case STRUCTOP_STRUCT:
      tem = longest_to_int (exp->elts[pc + 1].longconst);
      (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
      print_subexp (exp, pos, stream, PREC_SUFFIX);
      fputs_filtered (".", stream);
      fputs_filtered (&exp->elts[pc + 2].string, stream);
      return;

    /* Will not occur for Modula-2 */
    case STRUCTOP_PTR:
      tem = longest_to_int (exp->elts[pc + 1].longconst);
      (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
      print_subexp (exp, pos, stream, PREC_SUFFIX);
      fputs_filtered ("->", stream);
      fputs_filtered (&exp->elts[pc + 2].string, stream);
      return;

    case BINOP_SUBSCRIPT:
      print_subexp (exp, pos, stream, PREC_SUFFIX);
      fputs_filtered ("[", stream);
      print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
      fputs_filtered ("]", stream);
      return;

    case UNOP_POSTINCREMENT:
      print_subexp (exp, pos, stream, PREC_SUFFIX);
      fputs_filtered ("++", stream);
      return;

    case UNOP_POSTDECREMENT:
      print_subexp (exp, pos, stream, PREC_SUFFIX);
      fputs_filtered ("--", stream);
      return;

    case UNOP_CAST:
      (*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 ((int) prec > (int) PREC_PREFIX)
        fputs_filtered (")", stream);
      return;

    case UNOP_MEMVAL:
      (*pos) += 2;
      if ((int) prec > (int) PREC_PREFIX)
        fputs_filtered ("(", stream);
      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;

    case BINOP_ASSIGN_MODIFY:
      opcode = exp->elts[pc + 1].opcode;
      (*pos) += 2;
      myprec = PREC_ASSIGN;
      assoc = 1;
      assign_modify = 1;
      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;
	    break;
	  }
      break;

    /* C++ ops */

    case OP_THIS:
      ++(*pos);
      fputs_filtered ("this", stream);
      return;

    /* Modula-2 ops */

    case 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:
      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;
	    myprec = op_print_tab[tem].precedence;
	    assoc = op_print_tab[tem].right_assoc;
	    break;
	  }
   }

  if ((int) myprec < (int) prec)
    fputs_filtered ("(", stream);
  if ((int) opcode > (int) BINOP_END)
    {
      /* Unary prefix operator.  */
      fputs_filtered (op_str, stream);
      print_subexp (exp, pos, stream, PREC_PREFIX);
    }
  else
    {
      /* Binary operator.  */
      /* Print left operand.
	 If operator is right-associative,
	 increment precedence for this operand.  */
      print_subexp (exp, pos, stream,
		    (enum precedence) ((int) myprec + assoc));
      /* Print the operator itself.  */
      if (assign_modify)
	fprintf_filtered (stream, " %s= ", op_str);
      else if (op_str[0] == ',')
	fprintf_filtered (stream, "%s ", op_str);
      else
	fprintf_filtered (stream, " %s ", op_str);
      /* Print right operand.
	 If operator is left-associative,
	 increment precedence for this operand.  */
      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;
}

#ifdef DEBUG_EXPRESSIONS

/* Support for dumping the raw data from expressions in a human readable
   form.  */

void
dump_expression (exp, stream, note)
     struct expression *exp;
     FILE *stream;
     char *note;
{
  int elt;
  char *opcode_name;
  char *eltscan;
  int eltsize;

  fprintf_filtered (stream, "Dump of expression @ 0x%x, %s:\n", exp, note);
  fprintf_filtered (stream, "\tLanguage %s, %d elements, %d bytes each.\n",
		    exp->language_defn->la_name, exp -> nelts,
		    sizeof (union exp_element));
  fprintf_filtered (stream, "\t%5s  %20s  %16s  %s\n", "Index", "Opcode",
		    "Hex Value", "String Value");
  for (elt = 0; elt < exp -> nelts; elt++)
    {
      fprintf_filtered (stream, "\t%5d  ", elt);
      switch (exp -> elts[elt].opcode)
	{
	  default: opcode_name = "<unknown>"; break;
	  case OP_NULL: opcode_name = "OP_NULL"; break;
	  case BINOP_ADD: opcode_name = "BINOP_ADD"; break;
	  case BINOP_SUB: opcode_name = "BINOP_SUB"; break;
	  case BINOP_MUL: opcode_name = "BINOP_MUL"; break;
	  case BINOP_DIV: opcode_name = "BINOP_DIV"; break;
	  case BINOP_REM: opcode_name = "BINOP_REM"; break;
	  case BINOP_MOD: opcode_name = "BINOP_MOD"; break;
	  case BINOP_LSH: opcode_name = "BINOP_LSH"; break;
	  case BINOP_RSH: opcode_name = "BINOP_RSH"; break;
	  case BINOP_LOGICAL_AND: opcode_name = "BINOP_LOGICAL_AND"; break;
	  case BINOP_LOGICAL_OR: opcode_name = "BINOP_LOGICAL_OR"; break;
	  case BINOP_BITWISE_AND: opcode_name = "BINOP_BITWISE_AND"; break;
	  case BINOP_BITWISE_IOR: opcode_name = "BINOP_BITWISE_IOR"; break;
	  case BINOP_BITWISE_XOR: opcode_name = "BINOP_BITWISE_XOR"; break;
	  case BINOP_EQUAL: opcode_name = "BINOP_EQUAL"; break;
	  case BINOP_NOTEQUAL: opcode_name = "BINOP_NOTEQUAL"; break;
	  case BINOP_LESS: opcode_name = "BINOP_LESS"; break;
	  case BINOP_GTR: opcode_name = "BINOP_GTR"; break;
	  case BINOP_LEQ: opcode_name = "BINOP_LEQ"; break;
	  case BINOP_GEQ: opcode_name = "BINOP_GEQ"; break;
	  case BINOP_REPEAT: opcode_name = "BINOP_REPEAT"; break;
	  case BINOP_ASSIGN: opcode_name = "BINOP_ASSIGN"; break;
	  case BINOP_COMMA: opcode_name = "BINOP_COMMA"; break;
	  case BINOP_SUBSCRIPT: opcode_name = "BINOP_SUBSCRIPT"; break;
	  case MULTI_SUBSCRIPT: opcode_name = "MULTI_SUBSCRIPT"; break;
	  case BINOP_EXP: opcode_name = "BINOP_EXP"; break;
	  case BINOP_MIN: opcode_name = "BINOP_MIN"; break;
	  case BINOP_MAX: opcode_name = "BINOP_MAX"; break;
	  case BINOP_SCOPE: opcode_name = "BINOP_SCOPE"; break;
	  case STRUCTOP_MEMBER: opcode_name = "STRUCTOP_MEMBER"; break;
	  case STRUCTOP_MPTR: opcode_name = "STRUCTOP_MPTR"; break;
	  case BINOP_INTDIV: opcode_name = "BINOP_INTDIV"; break;
	  case BINOP_ASSIGN_MODIFY: opcode_name = "BINOP_ASSIGN_MODIFY"; break;
	  case BINOP_VAL: opcode_name = "BINOP_VAL"; break;
	  case BINOP_INCL: opcode_name = "BINOP_INCL"; break;
	  case BINOP_EXCL: opcode_name = "BINOP_EXCL"; break;
	  case BINOP_END: opcode_name = "BINOP_END"; break;
	  case TERNOP_COND: opcode_name = "TERNOP_COND"; break;
	  case OP_LONG: opcode_name = "OP_LONG"; break;
	  case OP_DOUBLE: opcode_name = "OP_DOUBLE"; break;
	  case OP_VAR_VALUE: opcode_name = "OP_VAR_VALUE"; break;
	  case OP_LAST: opcode_name = "OP_LAST"; break;
	  case OP_REGISTER: opcode_name = "OP_REGISTER"; break;
	  case OP_INTERNALVAR: opcode_name = "OP_INTERNALVAR"; break;
	  case OP_FUNCALL: opcode_name = "OP_FUNCALL"; break;
	  case OP_STRING: opcode_name = "OP_STRING"; break;
	  case OP_BITSTRING: opcode_name = "OP_BITSTRING"; break;
	  case OP_ARRAY: opcode_name = "OP_ARRAY"; break;
	  case UNOP_CAST: opcode_name = "UNOP_CAST"; break;
	  case UNOP_MEMVAL: opcode_name = "UNOP_MEMVAL"; break;
	  case UNOP_NEG: opcode_name = "UNOP_NEG"; break;
	  case UNOP_LOGICAL_NOT: opcode_name = "UNOP_LOGICAL_NOT"; break;
	  case UNOP_COMPLEMENT: opcode_name = "UNOP_COMPLEMENT"; break;
	  case UNOP_IND: opcode_name = "UNOP_IND"; break;
	  case UNOP_ADDR: opcode_name = "UNOP_ADDR"; break;
	  case UNOP_PREINCREMENT: opcode_name = "UNOP_PREINCREMENT"; break;
	  case UNOP_POSTINCREMENT: opcode_name = "UNOP_POSTINCREMENT"; break;
	  case UNOP_PREDECREMENT: opcode_name = "UNOP_PREDECREMENT"; break;
	  case UNOP_POSTDECREMENT: opcode_name = "UNOP_POSTDECREMENT"; break;
	  case UNOP_SIZEOF: opcode_name = "UNOP_SIZEOF"; break;
	  case UNOP_PLUS: opcode_name = "UNOP_PLUS"; break;
	  case UNOP_CAP: opcode_name = "UNOP_CAP"; break;
	  case UNOP_CHR: opcode_name = "UNOP_CHR"; break;
	  case UNOP_ORD: opcode_name = "UNOP_ORD"; break;
	  case UNOP_ABS: opcode_name = "UNOP_ABS"; break;
	  case UNOP_FLOAT: opcode_name = "UNOP_FLOAT"; break;
	  case UNOP_HIGH: opcode_name = "UNOP_HIGH"; break;
	  case UNOP_MAX: opcode_name = "UNOP_MAX"; break;
	  case UNOP_MIN: opcode_name = "UNOP_MIN"; break;
	  case UNOP_ODD: opcode_name = "UNOP_ODD"; break;
	  case UNOP_TRUNC: opcode_name = "UNOP_TRUNC"; break;
	  case OP_BOOL: opcode_name = "OP_BOOL"; break;
	  case OP_M2_STRING: opcode_name = "OP_M2_STRING"; break;
	  case STRUCTOP_STRUCT: opcode_name = "STRUCTOP_STRUCT"; break;
	  case STRUCTOP_PTR: opcode_name = "STRUCTOP_PTR"; break;
	  case OP_THIS: opcode_name = "OP_THIS"; break;
	  case OP_SCOPE: opcode_name = "OP_SCOPE"; break;
	  case OP_TYPE: opcode_name = "OP_TYPE"; break;
	}
      fprintf_filtered (stream, "%20s  ", opcode_name);
      fprintf_filtered (stream,
#if defined (LONG_LONG)
			"%ll16x  ",
#else
			"%l16x  ",
#endif
			exp -> elts[elt].longconst);

      for (eltscan = (char *) &exp->elts[elt],
	     eltsize = sizeof (union exp_element) ;
	   eltsize-- > 0;
	   eltscan++)
	{
	  fprintf_filtered (stream, "%c",
			    isprint (*eltscan) ? (*eltscan & 0xFF) : '.');
	}
      fprintf_filtered (stream, "\n");
    }
}

#endif	/* DEBUG_EXPRESSIONS */
Commit	Line	Data
bd5635a1	1	/* Print in infix form a struct expression.
28de880c	2	Copyright (C) 1986, 1989, 1991 Free Software Foundation, Inc.
bd5635a1 RP	3
	4	This file is part of GDB.
	5
10147c02	6	This program is free software; you can redistribute it and/or modify
bd5635a1	7	it under the terms of the GNU General Public License as published by
10147c02 JG	8	the Free Software Foundation; either version 2 of the License, or
10147c02 JG	9	(at your option) any later version.
bd5635a1	10
10147c02	11	This program is distributed in the hope that it will be useful,
bd5635a1 RP	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
10147c02 JG	17	along with this program; if not, write to the Free Software
10147c02 JG	18	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
bd5635a1	19
bd5635a1 RP	20	#include "defs.h"
bd5635a1 RP	21	#include "symtab.h"
28de880c	22	#include "gdbtypes.h"
bd5635a1 RP	23	#include "expression.h"
bd5635a1 RP	24	#include "value.h"
28de880c JG	25	#include "language.h"
28de880c JG	26	#include "parser-defs.h"
bd5635a1	27
28de880c JG	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 ));
bd5635a1 RP	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;
28de880c	58	register const struct op_print *op_print_tab;
bd5635a1 RP	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;
28de880c	67	value val;
bd5635a1	68
28de880c	69	op_print_tab = exp->language_defn->la_op_print_tab;
bd5635a1 RP	70	pc = (*pos)++;
	71	opcode = exp->elts[pc].opcode;
	72	switch (opcode)
	73	{
28de880c JG	74	/* Common ops */
28de880c JG	75
bd5635a1	76	case OP_SCOPE:
5d074aa9 FF	77	myprec = PREC_PREFIX;
5d074aa9 FF	78	assoc = 0;
a8a69e63	79	(*pos) += 3;
5d074aa9 FF	80	print_subexp (exp, pos, stream,
	81	(enum precedence) ((int) myprec + assoc));
	82	fputs_filtered (" :: ", stream);
a8a69e63	83	nargs = longest_to_int (exp->elts[pc + 2].longconst);
c4413e2c	84	(*pos) += 2 + BYTES_TO_EXP_ELEM (nargs + 1);
a8a69e63	85	fputs_filtered (&exp->elts[pc + 3].string, stream);
bd5635a1 RP	86	return;
	87
	88	case OP_LONG:
	89	(*pos) += 3;
28de880c	90	value_print (value_from_longest (exp->elts[pc + 1].type,
a8a69e63	91	exp->elts[pc + 2].longconst),
bd5635a1 RP	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	(*pos) += 2;
2e4964ad	104	fputs_filtered (SYMBOL_SOURCE_NAME (exp->elts[pc + 1].symbol), stream);
bd5635a1 RP	105	return;
	106
	107	case OP_LAST:
	108	(*pos) += 2;
10147c02 JG	109	fprintf_filtered (stream, "$%d",
10147c02 JG	110	longest_to_int (exp->elts[pc + 1].longconst));
bd5635a1 RP	111	return;
	112
	113	case OP_REGISTER:
	114	(*pos) += 2;
10147c02	115	fprintf_filtered (stream, "$%s",
35fcebce	116	reg_names[longest_to_int (exp->elts[pc + 1].longconst)]);
bd5635a1 RP	117	return;
bd5635a1 RP	118
5d074aa9 FF	119	case OP_BOOL:
	120	(*pos) += 2;
	121	fprintf_filtered (stream, "%s",
	122	longest_to_int (exp->elts[pc + 1].longconst)
	123	? "TRUE" : "FALSE");
	124	return;
	125
bd5635a1 RP	126	case OP_INTERNALVAR:
bd5635a1 RP	127	(*pos) += 2;
10147c02	128	fprintf_filtered (stream, "$%s",
bd5635a1 RP	129	internalvar_name (exp->elts[pc + 1].internalvar));
	130	return;
	131
	132	case OP_FUNCALL:
	133	(*pos) += 2;
10147c02	134	nargs = longest_to_int (exp->elts[pc + 1].longconst);
bd5635a1	135	print_subexp (exp, pos, stream, PREC_SUFFIX);
10147c02	136	fputs_filtered (" (", stream);
bd5635a1 RP	137	for (tem = 0; tem < nargs; tem++)
	138	{
	139	if (tem != 0)
10147c02	140	fputs_filtered (", ", stream);
bd5635a1 RP	141	print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
bd5635a1 RP	142	}
10147c02	143	fputs_filtered (")", stream);
bd5635a1 RP	144	return;
	145
	146	case OP_STRING:
a8a69e63	147	nargs = longest_to_int (exp -> elts[pc + 1].longconst);
c4413e2c	148	(*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
a8a69e63	149	/* LA_PRINT_STRING will print using the current repeat count threshold.
5d074aa9	150	If necessary, we can temporarily set it to zero, or pass it as an
a8a69e63 FF	151	additional parameter to LA_PRINT_STRING. -fnf */
a8a69e63 FF	152	LA_PRINT_STRING (stream, &exp->elts[pc + 2].string, nargs, 0);
bd5635a1 RP	153	return;
bd5635a1 RP	154
c4413e2c FF	155	case OP_BITSTRING:
	156	error ("support for OP_BITSTRING unimplemented");
	157	break;
	158
	159	case OP_ARRAY:
	160	error ("support for OP_ARRAY unimplemented");
	161	break;
	162
bd5635a1 RP	163	case TERNOP_COND:
bd5635a1 RP	164	if ((int) prec > (int) PREC_COMMA)
10147c02	165	fputs_filtered ("(", stream);
bd5635a1 RP	166	/* Print the subexpressions, forcing parentheses
	167	around any binary operations within them.
	168	This is more parentheses than are strictly necessary,
	169	but it looks clearer. */
	170	print_subexp (exp, pos, stream, PREC_HYPER);
10147c02	171	fputs_filtered (" ? ", stream);
bd5635a1	172	print_subexp (exp, pos, stream, PREC_HYPER);
10147c02	173	fputs_filtered (" : ", stream);
bd5635a1 RP	174	print_subexp (exp, pos, stream, PREC_HYPER);
bd5635a1 RP	175	if ((int) prec > (int) PREC_COMMA)
10147c02	176	fputs_filtered (")", stream);
bd5635a1 RP	177	return;
	178
	179	case STRUCTOP_STRUCT:
a8a69e63	180	tem = longest_to_int (exp->elts[pc + 1].longconst);
c4413e2c	181	(*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
bd5635a1	182	print_subexp (exp, pos, stream, PREC_SUFFIX);
10147c02	183	fputs_filtered (".", stream);
a8a69e63	184	fputs_filtered (&exp->elts[pc + 2].string, stream);
bd5635a1 RP	185	return;
bd5635a1 RP	186
28de880c	187	/* Will not occur for Modula-2 */
bd5635a1	188	case STRUCTOP_PTR:
a8a69e63	189	tem = longest_to_int (exp->elts[pc + 1].longconst);
c4413e2c	190	(*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
bd5635a1	191	print_subexp (exp, pos, stream, PREC_SUFFIX);
10147c02	192	fputs_filtered ("->", stream);
a8a69e63	193	fputs_filtered (&exp->elts[pc + 2].string, stream);
bd5635a1 RP	194	return;
	195
	196	case BINOP_SUBSCRIPT:
	197	print_subexp (exp, pos, stream, PREC_SUFFIX);
10147c02	198	fputs_filtered ("[", stream);
bd5635a1	199	print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
10147c02	200	fputs_filtered ("]", stream);
bd5635a1 RP	201	return;
	202
	203	case UNOP_POSTINCREMENT:
	204	print_subexp (exp, pos, stream, PREC_SUFFIX);
10147c02	205	fputs_filtered ("++", stream);
bd5635a1 RP	206	return;
	207
	208	case UNOP_POSTDECREMENT:
	209	print_subexp (exp, pos, stream, PREC_SUFFIX);
10147c02	210	fputs_filtered ("--", stream);
bd5635a1 RP	211	return;
	212
	213	case UNOP_CAST:
	214	(*pos) += 2;
	215	if ((int) prec > (int) PREC_PREFIX)
10147c02 JG	216	fputs_filtered ("(", stream);
10147c02 JG	217	fputs_filtered ("(", stream);
bd5635a1	218	type_print (exp->elts[pc + 1].type, "", stream, 0);
10147c02	219	fputs_filtered (") ", stream);
bd5635a1 RP	220	print_subexp (exp, pos, stream, PREC_PREFIX);
bd5635a1 RP	221	if ((int) prec > (int) PREC_PREFIX)
10147c02	222	fputs_filtered (")", stream);
bd5635a1 RP	223	return;
	224
	225	case UNOP_MEMVAL:
	226	(*pos) += 2;
	227	if ((int) prec > (int) PREC_PREFIX)
10147c02	228	fputs_filtered ("(", stream);
28de880c JG	229	if (exp->elts[pc + 1].type->code == TYPE_CODE_FUNC &&
	230	exp->elts[pc + 3].opcode == OP_LONG) {
	231	/* We have a minimal symbol fn, probably. It's encoded
	232	as a UNOP_MEMVAL (function-type) of an OP_LONG (int, address).
	233	Swallow the OP_LONG (including both its opcodes); ignore
	234	its type; print the value in the type of the MEMVAL. */
	235	(*pos) += 4;
	236	val = value_at_lazy (exp->elts[pc + 1].type,
	237	(CORE_ADDR) exp->elts[pc + 5].longconst);
	238	value_print (val, stream, 0, Val_no_prettyprint);
	239	} else {
	240	fputs_filtered ("{", stream);
	241	type_print (exp->elts[pc + 1].type, "", stream, 0);
	242	fputs_filtered ("} ", stream);
	243	print_subexp (exp, pos, stream, PREC_PREFIX);
	244	}
bd5635a1	245	if ((int) prec > (int) PREC_PREFIX)
10147c02	246	fputs_filtered (")", stream);
bd5635a1 RP	247	return;
	248
	249	case BINOP_ASSIGN_MODIFY:
	250	opcode = exp->elts[pc + 1].opcode;
	251	(*pos) += 2;
	252	myprec = PREC_ASSIGN;
	253	assoc = 1;
	254	assign_modify = 1;
28de880c JG	255	op_str = "???";
28de880c JG	256	for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
bd5635a1 RP	257	if (op_print_tab[tem].opcode == opcode)
	258	{
	259	op_str = op_print_tab[tem].string;
	260	break;
	261	}
81919cc8	262	break;
bd5635a1	263
28de880c JG	264	/* C++ ops */
28de880c JG	265
bd5635a1 RP	266	case OP_THIS:
bd5635a1 RP	267	++(*pos);
10147c02	268	fputs_filtered ("this", stream);
bd5635a1 RP	269	return;
bd5635a1 RP	270
28de880c JG	271	/* Modula-2 ops */
28de880c JG	272
54bbbfb4	273	case MULTI_SUBSCRIPT:
28de880c JG	274	(*pos) += 2;
	275	nargs = longest_to_int (exp->elts[pc + 1].longconst);
	276	print_subexp (exp, pos, stream, PREC_SUFFIX);
	277	fprintf (stream, " [");
	278	for (tem = 0; tem < nargs; tem++)
	279	{
	280	if (tem != 0)
	281	fprintf (stream, ", ");
	282	print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
	283	}
	284	fprintf (stream, "]");
	285	return;
	286
	287	case BINOP_VAL:
	288	(*pos)+=2;
	289	fprintf(stream,"VAL(");
	290	type_print(exp->elts[pc+1].type,"",stream,0);
	291	fprintf(stream,",");
	292	print_subexp(exp,pos,stream,PREC_PREFIX);
	293	fprintf(stream,")");
	294	return;
	295
	296	case UNOP_CAP:
	297	print_simple_m2_func("CAP",exp,pos,stream);
	298	return;
	299
	300	case UNOP_CHR:
	301	print_simple_m2_func("CHR",exp,pos,stream);
	302	return;
	303
	304	case UNOP_ORD:
	305	print_simple_m2_func("ORD",exp,pos,stream);
	306	return;
	307
	308	case UNOP_ABS:
	309	print_simple_m2_func("ABS",exp,pos,stream);
	310	return;
	311
	312	case UNOP_FLOAT:
	313	print_simple_m2_func("FLOAT",exp,pos,stream);
	314	return;
	315
	316	case UNOP_HIGH:
	317	print_simple_m2_func("HIGH",exp,pos,stream);
	318	return;
	319
	320	case UNOP_MAX:
	321	print_simple_m2_func("MAX",exp,pos,stream);
	322	return;
	323
	324	case UNOP_MIN:
	325	print_simple_m2_func("MIN",exp,pos,stream);
	326	return;
	327
	328	case UNOP_ODD:
	329	print_simple_m2_func("ODD",exp,pos,stream);
	330	return;
	331
	332	case UNOP_TRUNC:
	333	print_simple_m2_func("TRUNC",exp,pos,stream);
	334	return;
	335
	336	case BINOP_INCL:
	337	case BINOP_EXCL:
338	error("print_subexp: Not implemented.");
339
340	/* Default ops */
341
bd5635a1	342	default:
28de880c JG	343	op_str = "???";
28de880c JG	344	for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
bd5635a1 RP	345	if (op_print_tab[tem].opcode == opcode)
	346	{
	347	op_str = op_print_tab[tem].string;
	348	myprec = op_print_tab[tem].precedence;
	349	assoc = op_print_tab[tem].right_assoc;
	350	break;
	351	}
28de880c	352	}
bd5635a1 RP	353
bd5635a1 RP	354	if ((int) myprec < (int) prec)
10147c02	355	fputs_filtered ("(", stream);
bd5635a1 RP	356	if ((int) opcode > (int) BINOP_END)
	357	{
	358	/* Unary prefix operator. */
10147c02	359	fputs_filtered (op_str, stream);
bd5635a1 RP	360	print_subexp (exp, pos, stream, PREC_PREFIX);
	361	}
	362	else
	363	{
	364	/* Binary operator. */
	365	/* Print left operand.
	366	If operator is right-associative,
	367	increment precedence for this operand. */
10147c02 JG	368	print_subexp (exp, pos, stream,
10147c02 JG	369	(enum precedence) ((int) myprec + assoc));
bd5635a1 RP	370	/* Print the operator itself. */
bd5635a1 RP	371	if (assign_modify)
10147c02	372	fprintf_filtered (stream, " %s= ", op_str);
bd5635a1	373	else if (op_str[0] == ',')
10147c02	374	fprintf_filtered (stream, "%s ", op_str);
bd5635a1	375	else
10147c02	376	fprintf_filtered (stream, " %s ", op_str);
bd5635a1 RP	377	/* Print right operand.
	378	If operator is left-associative,
	379	increment precedence for this operand. */
10147c02 JG	380	print_subexp (exp, pos, stream,
10147c02 JG	381	(enum precedence) ((int) myprec + !assoc));
bd5635a1	382	}
28de880c	383
bd5635a1	384	if ((int) myprec < (int) prec)
10147c02	385	fputs_filtered (")", stream);
bd5635a1	386	}
28de880c JG	387
	388	/* Print out something of the form <s>(<arg>).
	389	This is used to print out some builtin Modula-2
	390	functions.
	391	FIXME: There is probably some way to get the precedence
	392	rules to do this (print a unary operand with parens around it). */
	393	static void
	394	print_simple_m2_func(s,exp,pos,stream)
	395	char *s;
	396	register struct expression *exp;
	397	register int *pos;
	398	FILE *stream;
	399	{
	400	fprintf(stream,"%s(",s);
	401	print_subexp(exp,pos,stream,PREC_PREFIX);
	402	fprintf(stream,")");
	403	}
	404
	405	/* Return the operator corresponding to opcode OP as
	406	a string. NULL indicates that the opcode was not found in the
	407	current language table. */
	408	char *
	409	op_string(op)
	410	enum exp_opcode op;
	411	{
	412	int tem;
	413	register const struct op_print *op_print_tab;
	414
	415	op_print_tab = current_language->la_op_print_tab;
	416	for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
	417	if (op_print_tab[tem].opcode == op)
	418	return op_print_tab[tem].string;
	419	return NULL;
	420	}
54bbbfb4 FF	421
	422	#ifdef DEBUG_EXPRESSIONS
	423
	424	/* Support for dumping the raw data from expressions in a human readable
	425	form. */
	426
	427	void
	428	dump_expression (exp, stream, note)
	429	struct expression *exp;
	430	FILE *stream;
	431	char *note;
	432	{
	433	int elt;
	434	char *opcode_name;
	435	char *eltscan;
	436	int eltsize;
	437
	438	fprintf_filtered (stream, "Dump of expression @ 0x%x, %s:\n", exp, note);
	439	fprintf_filtered (stream, "\tLanguage %s, %d elements, %d bytes each.\n",
	440	exp->language_defn->la_name, exp -> nelts,
	441	sizeof (union exp_element));
	442	fprintf_filtered (stream, "\t%5s %20s %16s %s\n", "Index", "Opcode",
	443	"Hex Value", "String Value");
	444	for (elt = 0; elt < exp -> nelts; elt++)
	445	{
	446	fprintf_filtered (stream, "\t%5d ", elt);
	447	switch (exp -> elts[elt].opcode)
	448	{
	449	default: opcode_name = "<unknown>"; break;
	450	case OP_NULL: opcode_name = "OP_NULL"; break;
	451	case BINOP_ADD: opcode_name = "BINOP_ADD"; break;
	452	case BINOP_SUB: opcode_name = "BINOP_SUB"; break;
	453	case BINOP_MUL: opcode_name = "BINOP_MUL"; break;
	454	case BINOP_DIV: opcode_name = "BINOP_DIV"; break;
	455	case BINOP_REM: opcode_name = "BINOP_REM"; break;
76a0ffb4	456	case BINOP_MOD: opcode_name = "BINOP_MOD"; break;
54bbbfb4 FF	457	case BINOP_LSH: opcode_name = "BINOP_LSH"; break;
	458	case BINOP_RSH: opcode_name = "BINOP_RSH"; break;
	459	case BINOP_LOGICAL_AND: opcode_name = "BINOP_LOGICAL_AND"; break;
	460	case BINOP_LOGICAL_OR: opcode_name = "BINOP_LOGICAL_OR"; break;
	461	case BINOP_BITWISE_AND: opcode_name = "BINOP_BITWISE_AND"; break;
	462	case BINOP_BITWISE_IOR: opcode_name = "BINOP_BITWISE_IOR"; break;
	463	case BINOP_BITWISE_XOR: opcode_name = "BINOP_BITWISE_XOR"; break;
	464	case BINOP_EQUAL: opcode_name = "BINOP_EQUAL"; break;
	465	case BINOP_NOTEQUAL: opcode_name = "BINOP_NOTEQUAL"; break;
	466	case BINOP_LESS: opcode_name = "BINOP_LESS"; break;
	467	case BINOP_GTR: opcode_name = "BINOP_GTR"; break;
	468	case BINOP_LEQ: opcode_name = "BINOP_LEQ"; break;
	469	case BINOP_GEQ: opcode_name = "BINOP_GEQ"; break;
	470	case BINOP_REPEAT: opcode_name = "BINOP_REPEAT"; break;
	471	case BINOP_ASSIGN: opcode_name = "BINOP_ASSIGN"; break;
	472	case BINOP_COMMA: opcode_name = "BINOP_COMMA"; break;
	473	case BINOP_SUBSCRIPT: opcode_name = "BINOP_SUBSCRIPT"; break;
	474	case MULTI_SUBSCRIPT: opcode_name = "MULTI_SUBSCRIPT"; break;
	475	case BINOP_EXP: opcode_name = "BINOP_EXP"; break;
	476	case BINOP_MIN: opcode_name = "BINOP_MIN"; break;
	477	case BINOP_MAX: opcode_name = "BINOP_MAX"; break;
	478	case BINOP_SCOPE: opcode_name = "BINOP_SCOPE"; break;
	479	case STRUCTOP_MEMBER: opcode_name = "STRUCTOP_MEMBER"; break;
	480	case STRUCTOP_MPTR: opcode_name = "STRUCTOP_MPTR"; break;
	481	case BINOP_INTDIV: opcode_name = "BINOP_INTDIV"; break;
	482	case BINOP_ASSIGN_MODIFY: opcode_name = "BINOP_ASSIGN_MODIFY"; break;
	483	case BINOP_VAL: opcode_name = "BINOP_VAL"; break;
	484	case BINOP_INCL: opcode_name = "BINOP_INCL"; break;
	485	case BINOP_EXCL: opcode_name = "BINOP_EXCL"; break;
	486	case BINOP_END: opcode_name = "BINOP_END"; break;
	487	case TERNOP_COND: opcode_name = "TERNOP_COND"; break;
	488	case OP_LONG: opcode_name = "OP_LONG"; break;
	489	case OP_DOUBLE: opcode_name = "OP_DOUBLE"; break;
	490	case OP_VAR_VALUE: opcode_name = "OP_VAR_VALUE"; break;
	491	case OP_LAST: opcode_name = "OP_LAST"; break;
	492	case OP_REGISTER: opcode_name = "OP_REGISTER"; break;
	493	case OP_INTERNALVAR: opcode_name = "OP_INTERNALVAR"; break;
	494	case OP_FUNCALL: opcode_name = "OP_FUNCALL"; break;
	495	case OP_STRING: opcode_name = "OP_STRING"; break;
c4413e2c FF	496	case OP_BITSTRING: opcode_name = "OP_BITSTRING"; break;
c4413e2c FF	497	case OP_ARRAY: opcode_name = "OP_ARRAY"; break;
54bbbfb4 FF	498	case UNOP_CAST: opcode_name = "UNOP_CAST"; break;
	499	case UNOP_MEMVAL: opcode_name = "UNOP_MEMVAL"; break;
	500	case UNOP_NEG: opcode_name = "UNOP_NEG"; break;
	501	case UNOP_LOGICAL_NOT: opcode_name = "UNOP_LOGICAL_NOT"; break;
	502	case UNOP_COMPLEMENT: opcode_name = "UNOP_COMPLEMENT"; break;
	503	case UNOP_IND: opcode_name = "UNOP_IND"; break;
	504	case UNOP_ADDR: opcode_name = "UNOP_ADDR"; break;
	505	case UNOP_PREINCREMENT: opcode_name = "UNOP_PREINCREMENT"; break;
	506	case UNOP_POSTINCREMENT: opcode_name = "UNOP_POSTINCREMENT"; break;
	507	case UNOP_PREDECREMENT: opcode_name = "UNOP_PREDECREMENT"; break;
	508	case UNOP_POSTDECREMENT: opcode_name = "UNOP_POSTDECREMENT"; break;
	509	case UNOP_SIZEOF: opcode_name = "UNOP_SIZEOF"; break;
	510	case UNOP_PLUS: opcode_name = "UNOP_PLUS"; break;
	511	case UNOP_CAP: opcode_name = "UNOP_CAP"; break;
	512	case UNOP_CHR: opcode_name = "UNOP_CHR"; break;
	513	case UNOP_ORD: opcode_name = "UNOP_ORD"; break;
	514	case UNOP_ABS: opcode_name = "UNOP_ABS"; break;
	515	case UNOP_FLOAT: opcode_name = "UNOP_FLOAT"; break;
	516	case UNOP_HIGH: opcode_name = "UNOP_HIGH"; break;
	517	case UNOP_MAX: opcode_name = "UNOP_MAX"; break;
	518	case UNOP_MIN: opcode_name = "UNOP_MIN"; break;
	519	case UNOP_ODD: opcode_name = "UNOP_ODD"; break;
	520	case UNOP_TRUNC: opcode_name = "UNOP_TRUNC"; break;
	521	case OP_BOOL: opcode_name = "OP_BOOL"; break;
	522	case OP_M2_STRING: opcode_name = "OP_M2_STRING"; break;
	523	case STRUCTOP_STRUCT: opcode_name = "STRUCTOP_STRUCT"; break;
	524	case STRUCTOP_PTR: opcode_name = "STRUCTOP_PTR"; break;
	525	case OP_THIS: opcode_name = "OP_THIS"; break;
	526	case OP_SCOPE: opcode_name = "OP_SCOPE"; break;
	527	case OP_TYPE: opcode_name = "OP_TYPE"; break;
	528	}
	529	fprintf_filtered (stream, "%20s ", opcode_name);
	530	fprintf_filtered (stream,
	531	#if defined (LONG_LONG)
	532	"%ll16x ",
	533	#else
	534	"%l16x ",
	535	#endif
	536	exp -> elts[elt].longconst);
	537
	538	for (eltscan = (char *) &exp->elts[elt],
	539	eltsize = sizeof (union exp_element) ;
	540	eltsize-- > 0;
	541	eltscan++)
	542	{
	543	fprintf_filtered (stream, "%c",
	544	isprint (eltscan) ? (eltscan & 0xFF) : '.');
	545	}
	546	fprintf_filtered (stream, "\n");
	547	}
	548	}
	549
	550	#endif /* DEBUG_EXPRESSIONS */