cp-method.c

早期freebsd实现

      OB_PUTID (TYPE_IDENTIFIER (t));
      OB_PUTC (' ');
      break;

    case REAL_TYPE:
    case VOID_TYPE:
      if (TYPE_READONLY (t) | TYPE_VOLATILE (t))
	dump_readonly_or_volatile (t);
      OB_PUTID (TYPE_IDENTIFIER (t));
      OB_PUTC (' ');
      break;

    case TEMPLATE_TYPE_PARM:
      OB_PUTS ("<template type parm ");
      OB_PUTID (TYPE_IDENTIFIER (t));
      OB_PUTC ('>');
      break;

    case UNINSTANTIATED_P_TYPE:
      OB_PUTID (DECL_NAME (UPT_TEMPLATE (t)));
      OB_PUTS ("<...>");
      break;

    default:
      my_friendly_abort (68);
    }
}

static void
dump_decl (t)
     tree t;
{
  int p = 0;

  if (t == NULL_TREE)
    return;

  switch (TREE_CODE (t))
    {
    case ERROR_MARK:
      OB_PUTS (" /* decl error */ ");
      break;

    case PARM_DECL:
      dump_type_prefix (TREE_TYPE (t), &p);
      if (DECL_NAME (t))
	dump_decl (DECL_NAME (t));
      else
	{
	  sprintf (anon_buffer, ANON_PARMNAME_FORMAT, dummy_name++);
	  OB_PUTCP (anon_buffer);
	  break;
	}
      dump_type_suffix (TREE_TYPE (t), &p);
      return;

    case CALL_EXPR:
      dump_decl (TREE_OPERAND (t, 0));
      OB_PUTC ('(');
      in_parmlist++;
      dump_decl (TREE_OPERAND (t, 1));
      in_parmlist--;
      t = tree_last (TYPE_ARG_TYPES (TREE_TYPE (t)));
      if (!t || t != void_list_node)
	OB_PUTS ("...");
      OB_PUTC (')');
      return;

    case ARRAY_REF:
      dump_decl (TREE_OPERAND (t, 0));
      OB_PUTC ('[');
      dump_decl (TREE_OPERAND (t, 1));
      OB_PUTC (']');
      return;

    case TYPE_DECL:
      OB_PUTID (DECL_NAME (t));
      OB_PUTC (' ');
      break;

    case TYPE_EXPR:
      my_friendly_abort (69);
      break;

    case IDENTIFIER_NODE:
      if (t == ansi_opname[(int) TYPE_EXPR])
	{
	  OB_PUTS ("operator ");
	  /* Not exactly IDENTIFIER_TYPE_VALUE.  */
	  dump_type (TREE_TYPE (t), &p);
	  return;
	}
      else if (IDENTIFIER_OPNAME_P (t))
	{
	  char *name_string = operator_name_string (t);
	  OB_PUTS ("operator ");
	  OB_PUTCP (name_string);
	  OB_PUTC (' ');
	}
      else
	{
	  OB_PUTID (t);
	  OB_PUTC (' ');
	}
      break;

    case BIT_NOT_EXPR:
      OB_PUTC2 ('~', ' ');
      dump_decl (TREE_OPERAND (t, 0));
      return;

    case SCOPE_REF:
      OB_PUTID (TREE_OPERAND (t, 0));
      OB_PUTC2 (':', ':');
      dump_decl (TREE_OPERAND (t, 1));
      return;

    case INDIRECT_REF:
      OB_PUTC ('*');
      dump_decl (TREE_OPERAND (t, 0));
      return;

    case ADDR_EXPR:
      OB_PUTC ('&');
      dump_decl (TREE_OPERAND (t, 0));
      return;

    default:
      my_friendly_abort (70);
    }
}

static void
dump_init_list (l)
     tree l;
{
  while (l)
    {
      dump_init (TREE_VALUE (l));
      if (TREE_CHAIN (l))
	OB_PUTC (',');
      l = TREE_CHAIN (l);
    }
}

static void
dump_init (t)
     tree t;
{
  int dummy;

  switch (TREE_CODE (t))
    {
    case VAR_DECL:
    case PARM_DECL:
      OB_PUTC (' ');
      OB_PUTID (DECL_NAME (t));
      OB_PUTC (' ');
      break;

    case FUNCTION_DECL:
      {
	tree name = DECL_ASSEMBLER_NAME (t);

	if (DESTRUCTOR_NAME_P (name))
	  {
	    OB_PUTC2 (' ', '~');
	    OB_PUTID (DECL_NAME (t));
	  }
	else if (IDENTIFIER_TYPENAME_P (name))
	  {
	    dummy = 0;
	    OB_PUTS ("operator ");
	    dump_type (TREE_TYPE (name), &dummy);
	  }
	else if (IDENTIFIER_OPNAME_P (name))
	  {
	    char *name_string = operator_name_string (name);
	      OB_PUTS ("operator ");
	    OB_PUTCP (name_string);
	    OB_PUTC (' ');
	  }
	else
	  {
	    OB_PUTC (' ');
	    OB_PUTID (DECL_NAME (t));
	  }
	OB_PUTC (' ');
      }
      break;

    case CONST_DECL:
      dummy = 0;
      OB_PUTC2 ('(', '(');
      dump_type (TREE_TYPE (t), &dummy);
      OB_PUTC (')');
      dump_init (DECL_INITIAL (t));
      OB_PUTC (')');
      return;

    case INTEGER_CST:
      sprintf (digit_buffer, " %d ", TREE_INT_CST_LOW (t));
      OB_PUTCP (digit_buffer);
      break;

    case REAL_CST:
      sprintf (digit_buffer, " %g ", TREE_REAL_CST (t));
      OB_PUTCP (digit_buffer);
      break;

    case STRING_CST:
      {
	char *p = TREE_STRING_POINTER (t);
	int len = TREE_STRING_LENGTH (t) - 1;
	int i;

	OB_PUTC ('\"');
	for (i = 0; i < len; i++)
	  {
	    register char c = p[i];
	    if (c == '\"' || c == '\\')
	      OB_PUTC ('\\');
	    if (c >= ' ' && c < 0177)
	      OB_PUTC (c);
	    else
	      {
		sprintf (digit_buffer, "\\%03o", c);
		OB_PUTCP (digit_buffer);
	      }
	  }
	OB_PUTC ('\"');
      }
      return;

    case COMPOUND_EXPR:
      dump_binary_op (",", t, 1);
      break;

    case COND_EXPR:
      OB_PUTC ('(');
      dump_init (TREE_OPERAND (t, 0));
      OB_PUTS (" ? ");
      dump_init (TREE_OPERAND (t, 1));
      OB_PUTS (" : ");
      dump_init (TREE_OPERAND (t, 2));
      OB_PUTC (')');
      return;

    case SAVE_EXPR:
      if (TREE_HAS_CONSTRUCTOR (t))
	{
	  dummy = 0;
	  OB_PUTS ("new ");
	  dump_type (TREE_TYPE (TREE_TYPE (t)), &dummy);
	  PARM_DECL_EXPR (t) = 1;
	}
      else
	{
	  sorry ("operand of SAVE_EXPR not understood");
	  scratch_obstack.next_free
	    = obstack_base (&scratch_obstack) + scratch_error_offset;
	}
      return;

    case NEW_EXPR:
      OB_PUTID (TYPE_IDENTIFIER (TREE_TYPE (t)));
      OB_PUTC ('(');
      dump_init_list (TREE_CHAIN (TREE_OPERAND (t, 1)));
      OB_PUTC (')');
      return;

    case CALL_EXPR:
      OB_PUTC ('(');
      dump_init (TREE_OPERAND (t, 0));
      dump_init_list (TREE_OPERAND (t, 1));
      OB_PUTC (')');
      return;

    case WITH_CLEANUP_EXPR:
      /* Note that this only works for G++ cleanups.  If somebody
	 builds a general cleanup, there's no way to represent it.  */
      dump_init (TREE_OPERAND (t, 0));
      return;

    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.  */
      dump_init (TREE_OPERAND (t, 1));
      return;

    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,
		      strlen (opname_tab[(int) TREE_CODE (t)]));
      return;

    case CEIL_DIV_EXPR:
    case FLOOR_DIV_EXPR:
    case ROUND_DIV_EXPR:
      dump_binary_op ("/", t, 1);
      return;

    case CEIL_MOD_EXPR:
    case FLOOR_MOD_EXPR:
    case ROUND_MOD_EXPR:
      dump_binary_op ("%", t, 1);
      return;

    case COMPONENT_REF:
      dump_binary_op (".", t, 1);
      return;

    case CONVERT_EXPR:
      dump_unary_op ("+", t, 1);
      return;

    case ADDR_EXPR:
      if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
	  || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST)
	dump_init (TREE_OPERAND (t, 0));
      else
	dump_unary_op ("&", t, 1);
      return;

    case INDIRECT_REF:
      if (TREE_HAS_CONSTRUCTOR (t))
	{
	  t = TREE_OPERAND (t, 0);
	  my_friendly_assert (TREE_CODE (t) == CALL_EXPR, 237);
	  dump_init (TREE_OPERAND (t, 0));
	  OB_PUTC ('(');
	  dump_init_list (TREE_CHAIN (TREE_OPERAND (t, 1)));
	  OB_PUTC (')');
	}
      else
	dump_unary_op ("*", t, 1);
      return;

    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,
		     strlen (opname_tab[(int) TREE_CODE (t)]));
      return;

    case POSTDECREMENT_EXPR:
    case POSTINCREMENT_EXPR:
      OB_PUTC ('(');
      dump_init (TREE_OPERAND (t, 0));
      OB_PUTCP (opname_tab[(int)TREE_CODE (t)]);
      OB_PUTC (')');
      return;

    case NOP_EXPR:
      dummy = 0;
      OB_PUTC2 ('(', '(');
      dump_type (TREE_TYPE (t), &dummy);
      OB_PUTC (')');
      dump_init (TREE_OPERAND (t, 0));
      OB_PUTC (')');
      return;

    case CONSTRUCTOR:
      OB_PUTC ('{');
      dump_init_list (CONSTRUCTOR_ELTS (t));
      OB_PUTC ('}');
      return;

      /*  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 for default parameters",
	     tree_code_name[(int) TREE_CODE (t)]);

      /* fall through to ERROR_MARK...  */
    case ERROR_MARK:
      scratch_obstack.next_free
	= obstack_base (&scratch_obstack) + scratch_error_offset;
      return;
    }
}

static void
dump_binary_op (opstring, t, len)
     char *opstring;
     tree t;
     int len;
{
  OB_PUTC ('(');
  dump_init (TREE_OPERAND (t, 0));
  OB_PUTC (' ');
  OB_PUTCP (opstring);
  OB_PUTC (' ');
  dump_init (TREE_OPERAND (t, 1));
  OB_PUTC (')');
}

static void
dump_unary_op (opstring, t, len)
     char *opstring;
     tree t;
     int len;
{
  OB_PUTC ('(');
  OB_PUTC (' ');
  OB_PUTCP (opstring);
  OB_PUTC (' ');
  dump_init (TREE_OPERAND (t, 0));
  OB_PUTC (')');
}

/* Pretty printing for announce_function.  CNAME is the TYPE_DECL for
   the class that FNDECL belongs to, if we could not figure that out
   from FNDECL itself.  FNDECL is the declaration of the function we
   are interested in seeing.  PRINT_RET_TYPE_P is non-zero if we
   should print the type that this function returns.  */

char *
fndecl_as_string (cname, fndecl, print_ret_type_p)
     tree cname, fndecl;
     int print_ret_type_p;
{
  tree name = DECL_ASSEMBLER_NAME (fndecl);
  tree fntype = TREE_TYPE (fndecl);
  tree parmtypes = TYPE_ARG_TYPES (fntype);
  int p = 0;
  int spaces = 0;

  OB_INIT ();

  if (DECL_CLASS_CONTEXT (fndecl))
    cname = TYPE_NAME (DECL_CLASS_CONTEXT (fndecl));

  if (DECL_STATIC_FUNCTION_P (fndecl))
      OB_PUTS ("static ");
    
  if (print_ret_type_p && ! IDENTIFIER_TYPENAME_P (name))
    {
      dump_type_prefix (TREE_TYPE (fntype), &p);
      OB_PUTC (' ');
    }

  if (cname)
    {
      dump_type (cname, &p);
      *((char *) obstack_next_free (&scratch_obstack) - 1) = ':';
      OB_PUTC (':');
      if (TREE_CODE (fntype) == METHOD_TYPE && parmtypes)
	parmtypes = TREE_CHAIN (parmtypes);
      if (DECL_CONSTRUCTOR_FOR_VBASE_P (fndecl))
	/* Skip past "in_charge" identifier.  */
	parmtypes = TREE_CHAIN (parmtypes);
    }

  if (DESTRUCTOR_NAME_P (name))
    {
      OB_PUTC ('~');
      parmtypes = TREE_CHAIN (parmtypes);
      dump_decl (DECL_NAME (fndecl));
    }
  else if (IDENTIFIER_TYPENAME_P (name))
    {
      /* This cannot use the hack that the operator's return
	 type is stashed off of its name because it may be
	 used for error reporting.  In the case of conflicting
	 declarations, both will have the same name, yet
	 the types will be different, hence the TREE_TYPE field
	 of the first name will be clobbered by the second.  */
      OB_PUTS ("operator ");
      dump_type (TREE_TYPE (TREE_TYPE (fndecl)), &p);
    }
  else if (IDENTIFIER_OPNAME_P (name))
    {
      char *name_string = operator_name_string (name);
      OB_PUTS ("operator ");
      OB_PUTCP (name_string);
      OB_PUTC (' ');
    }
  else if (DECL_CONSTRUCTOR_P (fndecl))
    {
#ifdef SOS
      if (TYPE_DYNAMIC (IDENTIFIER_TYPE_VALUE (cname)))
	{
	  OB_PUTS ("dynamic ");
	  parmtypes = TREE_CHAIN (parmtypes);
	}
#endif
      dump_decl (DECL_NAME (fndecl));
    }
  else
    dump_decl (DECL_NAME (fndecl));

  OB_PUTC ('(');
  if (parmtypes)
    {
      in_parmlist++;
      if (parmtypes != void_list_node)
	spaces = 2;
      while (parmtypes && parmtypes != void_list_node)
	{