if (TREE_CODE (fn) == ADDR_EXPR)	  fn = TREE_OPERAND (fn, 0);	if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)	  {	    tree ob = TREE_VALUE (args);	    if (TREE_CODE (ob) == ADDR_EXPR)	      {		dump_expr (TREE_OPERAND (ob, 0), 0);		OB_PUTC ('.');	      }	    else if (TREE_CODE (ob) != PARM_DECL		     || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))	      {		dump_expr (ob, 0);		OB_PUTC2 ('-', '>');	      }	    args = TREE_CHAIN (args);	  }	dump_expr (fn, 0);	OB_PUTC ('(');	dump_expr_list (args);	OB_PUTC (')');      }      break;    case TARGET_EXPR:      /* Note that this only works for G++ target exprs.  If somebody	 builds a general TARGET_EXPR, there's no way to represent that	 it initializes anything other that the parameter slot for the	 default argument.  Note we may have cleared out the first	 operand in expand_expr, so don't go killing ourselves.  */      if (TREE_OPERAND (t, 1))	dump_expr (TREE_OPERAND (t, 1), 0);      break;    case MODIFY_EXPR:    case PLUS_EXPR:    case MINUS_EXPR:    case MULT_EXPR:    case TRUNC_DIV_EXPR:    case TRUNC_MOD_EXPR:    case MIN_EXPR:    case MAX_EXPR:    case LSHIFT_EXPR:    case RSHIFT_EXPR:    case BIT_IOR_EXPR:    case BIT_XOR_EXPR:    case BIT_AND_EXPR:    case BIT_ANDTC_EXPR:    case TRUTH_ANDIF_EXPR:    case TRUTH_ORIF_EXPR:    case LT_EXPR:    case LE_EXPR:    case GT_EXPR:    case GE_EXPR:    case EQ_EXPR:    case NE_EXPR:      dump_binary_op (opname_tab[(int) TREE_CODE (t)], t);      break;    case CEIL_DIV_EXPR:    case FLOOR_DIV_EXPR:    case ROUND_DIV_EXPR:      dump_binary_op ("/", t);      break;    case CEIL_MOD_EXPR:    case FLOOR_MOD_EXPR:    case ROUND_MOD_EXPR:      dump_binary_op ("%", t);      break;    case COMPONENT_REF:      {	tree ob = TREE_OPERAND (t, 0);	if (TREE_CODE (ob) == INDIRECT_REF)	  {	    ob = TREE_OPERAND (ob, 0);	    if (TREE_CODE (ob) != PARM_DECL		|| strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))	      {		dump_expr (ob, 0);		OB_PUTC2 ('-', '>');	      }	  }	else	  {	    dump_expr (ob, 0);	    OB_PUTC ('.');	  }	dump_expr (TREE_OPERAND (t, 1), 1);      }      break;    case ARRAY_REF:      dump_expr (TREE_OPERAND (t, 0), 0);      OB_PUTC ('[');      dump_expr (TREE_OPERAND (t, 1), 0);      OB_PUTC (']');      break;    case CONVERT_EXPR:      dump_unary_op ("+", t, nop);      break;    case ADDR_EXPR:      if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL	  || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST)	dump_expr (TREE_OPERAND (t, 0), 0);      else	dump_unary_op ("&", t, nop);      break;    case INDIRECT_REF:      if (TREE_HAS_CONSTRUCTOR (t))	{	  t = TREE_OPERAND (t, 0);	  my_friendly_assert (TREE_CODE (t) == CALL_EXPR, 237);	  dump_expr (TREE_OPERAND (t, 0), 0);	  OB_PUTC ('(');	  dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)));	  OB_PUTC (')');	}      else	{	  if (TREE_OPERAND (t,0) != NULL_TREE	      && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)	    dump_expr (TREE_OPERAND (t, 0), nop);	  else	    dump_unary_op ("*", t, nop);	}      break;    case NEGATE_EXPR:    case BIT_NOT_EXPR:    case TRUTH_NOT_EXPR:    case PREDECREMENT_EXPR:    case PREINCREMENT_EXPR:      dump_unary_op (opname_tab [(int)TREE_CODE (t)], t, nop);      break;    case POSTDECREMENT_EXPR:    case POSTINCREMENT_EXPR:      OB_PUTC ('(');      dump_expr (TREE_OPERAND (t, 0), 0);      OB_PUTCP (opname_tab[(int)TREE_CODE (t)]);      OB_PUTC (')');      break;    case NON_LVALUE_EXPR:      /* FIXME: This is a KLUDGE workaround for a parsing problem.  There	 should be another level of INDIRECT_REF so that I don't have to do	 this.  */      if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)	{	  tree next = TREE_TYPE (TREE_TYPE (t));	  while (TREE_CODE (next) == POINTER_TYPE)	    next = TREE_TYPE (next);	  	  if (TREE_CODE (next) == FUNCTION_TYPE)	    {	      if (!nop) OB_PUTC ('(');	      OB_PUTC ('*');	      dump_expr (TREE_OPERAND (t, 0), 1);	      if (!nop) OB_PUTC (')');	      break;	    }	  /* else FALLTHRU */	}      dump_expr (TREE_OPERAND (t, 0), 0);      break;    case NOP_EXPR:      dump_expr (TREE_OPERAND (t, 0), nop);      break;    case CONSTRUCTOR:      if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))	{	  tree idx = build_component_ref (t, index_identifier, NULL_TREE, 0);	  if (integer_all_onesp (idx))	    {	      tree pfn = PFN_FROM_PTRMEMFUNC (t);	      dump_expr (pfn, 0);	      break;	    }	  if (TREE_CODE (idx) == INTEGER_CST	      && TREE_INT_CST_HIGH (idx) == 0)	    {	      tree virtuals;	      unsigned HOST_WIDE_INT n;	      t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));	      t = TYPE_METHOD_BASETYPE (t);	      virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));	      	      n = TREE_INT_CST_LOW (idx);	      /* Map vtable index back one, to allow for the null pointer to		 member.  */	      --n;	      while (n > 0 && virtuals)		{		  --n;		  virtuals = TREE_CHAIN (virtuals);		}	      if (virtuals)		{		  dump_expr (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals)), 0);		  break;		}	    }	}      OB_PUTC ('{');      dump_expr_list (CONSTRUCTOR_ELTS (t));      OB_PUTC ('}');      break;    case OFFSET_REF:      {	tree ob = TREE_OPERAND (t, 0);	if (TREE_CODE (ob) == NOP_EXPR	    && TREE_OPERAND (ob, 0) == error_mark_node	    && TREE_CODE (TREE_OPERAND (t, 1)) == FUNCTION_DECL)	    /* A::f */	  dump_expr (TREE_OPERAND (t, 1), 0);	else	  {	    dump_expr (TREE_OPERAND (t, 0), 0);	    OB_PUTS (" .* ");	    dump_expr (TREE_OPERAND (t, 1), 0);	  }	break;      }    case TEMPLATE_CONST_PARM:      {	int l = current_template_parms ? 	  list_length (current_template_parms) : 0;	if (l >= TEMPLATE_CONST_LEVEL (t))	  {	    int i;	    tree parms = current_template_parms;	    tree r;	    	    for (i = 0; i < l - TEMPLATE_CONST_LEVEL (t); ++i)	      {		parms = TREE_CHAIN (parms);		my_friendly_assert (parms != NULL_TREE, 0);	      }	    	    r = TREE_VEC_ELT (TREE_VALUE (parms),			      TEMPLATE_CONST_IDX (t));	    dump_decl (TREE_VALUE (r), -1);	  }	else	  {	    OB_PUTS ("<tparm ");	    OB_PUTI (TEMPLATE_CONST_IDX (t));	    OB_PUTS (">");	  }      }      break;    case IDENTIFIER_NODE:      OB_PUTID (t);      break;    case SCOPE_REF:      dump_type (TREE_OPERAND (t, 0), 0);      OB_PUTS ("::");      dump_expr (TREE_OPERAND (t, 1), 0);      break;    case CAST_EXPR:      if (TREE_OPERAND (t, 0) == NULL_TREE	  || TREE_CHAIN (TREE_OPERAND (t, 0)))	{	  dump_type (TREE_TYPE (t), 0);	  OB_PUTC ('(');	  dump_expr_list (TREE_OPERAND (t, 0));	  OB_PUTC (')');	}      else	{	  OB_PUTC ('(');	  dump_type (TREE_TYPE (t), 0);	  OB_PUTC (')');	  OB_PUTC ('(');	  dump_expr_list (TREE_OPERAND (t, 0));	  OB_PUTC (')');	}      break;    case LOOKUP_EXPR:      OB_PUTID (TREE_OPERAND (t, 0));      break;    case SIZEOF_EXPR:      OB_PUTS ("sizeof (");      if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t, 0))) == 't')	dump_type (TREE_OPERAND (t, 0), 0);      else	dump_unary_op ("*", t, 0);      OB_PUTC (')');      break;    case DEFAULT_ARG:      OB_PUTS ("{unparsed}");      break;    case TREE_LIST:      if (TREE_VALUE (t) && TREE_CODE (TREE_VALUE (t)) == FUNCTION_DECL)	{	  OB_PUTID (DECL_NAME (TREE_VALUE (t)));	  break;	}      /* else fall through */	      /*  This list is incomplete, but should suffice for now.	  It is very important that `sorry' does not call	  `report_error_function'.  That could cause an infinite loop.  */    default:      sorry ("`%s' not supported by dump_expr",	     tree_code_name[(int) TREE_CODE (t)]);      /* fall through to ERROR_MARK...  */    case ERROR_MARK:    error:      OB_PUTCP ("{error}");      break;    }}static voiddump_binary_op (opstring, t)     char *opstring;     tree t;{  OB_PUTC ('(');  dump_expr (TREE_OPERAND (t, 0), 1);  OB_PUTC (' ');  OB_PUTCP (opstring);  OB_PUTC (' ');  dump_expr (TREE_OPERAND (t, 1), 1);  OB_PUTC (')');}static voiddump_unary_op (opstring, t, nop)     char *opstring;     tree t;     int nop;{  if (!nop) OB_PUTC ('(');  OB_PUTCP (opstring);  dump_expr (TREE_OPERAND (t, 0), 1);  if (!nop) OB_PUTC (')');}char *fndecl_as_string (fndecl, print_ret_type_p)     tree fndecl;     int print_ret_type_p;{  return decl_as_string (fndecl, print_ret_type_p);}/* Same, but handtype a _TYPE.   Called from convert_to_reference, mangle_class_name_for_template,   build_unary_op, and GNU_xref_decl.  */char *type_as_string (typ, v)     tree typ;     int v;{  OB_INIT ();  dump_type (typ, v);  OB_FINISH ();  return (char *)obstack_base (&scratch_obstack);}char *expr_as_string (decl, v)     tree decl;     int v;{  OB_INIT ();  dump_expr (decl, 1);  OB_FINISH ();  return (char *)obstack_base (&scratch_obstack);}/* A cross between type_as_string and fndecl_as_string.   Only called from substitute_nice_name.  */char *decl_as_string (decl, v)     tree decl;     int v;{  OB_INIT ();  dump_decl (decl, v);  OB_FINISH ();  return (char *)obstack_base (&scratch_obstack);}/* Generate the three forms of printable names for lang_printable_name.  */char *lang_decl_name (decl, v)     tree decl;     int v;{  if (v >= 2)    return decl_as_string (decl, 1);  OB_INIT ();  if (v == 1 && DECL_CONTEXT (decl)      && TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (decl))) == 't')    {      tree cname;      if (TREE_CODE (decl) == FUNCTION_DECL)	cname = DECL_CLASS_CONTEXT (decl);      else	cname = DECL_CONTEXT (decl);      dump_type (cname, 0);      OB_PUTC2 (':', ':');    }  if (TREE_CODE (decl) == FUNCTION_DECL)    dump_function_name (decl);  else    dump_decl (DECL_NAME (decl), 0);  OB_FINISH ();  return (char *)obstack_base (&scratch_obstack);}  char *cp_file_of (t)     tree t;{  if (TREE_CODE (t) == PARM_DECL)    return DECL_SOURCE_FILE (DECL_CONTEXT (t));  else if (TREE_CODE_CLASS (TREE_CODE (t)) == 't')    return DECL_SOURCE_FILE (TYPE_MAIN_DECL (t));  else    return DECL_SOURCE_FILE (t);}intcp_line_of (t)     tree t;{  int line = 0;  if (TREE_CODE (t) == PARM_DECL)    line = DECL_SOURCE_LINE (DECL_CONTEXT (t));  if (TREE_CODE (t) == TYPE_DECL && DECL_ARTIFICIAL (t))    t = TREE_TYPE (t);  if (TREE_CODE_CLASS (TREE_CODE (t)) == 't')    line = DECL_SOURCE_LINE (TYPE_MAIN_DECL (t));  else    line = DECL_SOURCE_LINE (t);  if (line == 0)    return lineno;  return line;}char *code_as_string (c, v)     enum tree_code c;     int v;{  return tree_code_name [c];}char *language_as_string (c, v)     enum languages c;     int v;{  switch (c)    {    case lang_c:      return "C";    case lang_cplusplus:      return "C++";    default:      my_friendly_abort (355);      return 0;    }}/* Return the proper printed version of a parameter to a C++ function.  */char *parm_as_string (p, v)     int p, v;{  if (p < 0)    return "`this'";  sprintf (digit_buffer, "%d", p+1);  return digit_buffer;}char *op_as_string (p, v)     enum tree_code p;     int v;{  static char buf[] = "operator                ";  if (p == 0)    return "{unknown}";    strcpy (buf + 9, opname_tab [p]);  return buf;}char *assop_as_string (p, v)     enum tree_code p;     int v;{  static char buf[] = "operator                ";  if (p == 0)    return "{unknown}";    strcpy (buf + 9, assignop_tab [p]);  return buf;}char *args_as_string (p, v)     tree p;     int v;{  if (p == NULL_TREE)    return "";  if (TREE_CODE_CLASS (TREE_CODE (TREE_VALUE (p))) == 't')    return type_as_string (p, v);  OB_INIT ();  for (; p; p = TREE_CHAIN (p))    {      if (TREE_VALUE (p) == null_node)	OB_PUTS ("NULL");      else	dump_type (error_type (TREE_VALUE (p)), v);      if (TREE_CHAIN (p))	OB_PUTS (", ");    }  OB_FINISH ();  return (char *)obstack_base (&scratch_obstack);}char *cv_as_string (p, v)     tree p;     int v;{  OB_INIT ();  dump_readonly_or_volatile (p, before);  OB_FINISH ();  return (char *)obstack_base (&scratch_obstack);}