gcc/libjava/gnu/gcj/util/Debug.java

/*  Copyright (C) 2004  Free Software Foundation

This file is part of libgcj.

This software is copyrighted work licensed under the terms of the
Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
details.  */

/* Utility methods that allow an object to be converted to a textual
   representation on an OutputStream.  The intention here is that this
   class be used for debugging, so we provide information about all
   fields, public or otherwise. */

package gnu.gcj.util;

import java.lang.reflect.*;
import java.io.*;
import java.util.*;

class Debug 
{
  private final PrintStream p;
  private final int maxdepth;
  private final int maxArrayLength;
  private final boolean printStaticFields;
  private int depth; 

  Debug(PrintStream writer, int maxdepth, int maxArrayLength, boolean printStaticFields)
  {
    p = writer;
    this.maxdepth = maxdepth;
    this.maxArrayLength = maxArrayLength;
    this.printStaticFields = printStaticFields;
  }

  Debug(PrintStream writer)
  {
    this(writer, 0, 10, false);
  }

  Debug(int maxdepth, boolean printStaticFields)
  {
    this(new PrintStream
	 (new FileOutputStream(FileDescriptor.err), true), 
	 maxdepth, 
	 maxdepth > 0 ? 1000 : 10, printStaticFields);
  }

  Debug(int maxdepth)
  {
    this(maxdepth, false);
  }

  Debug()
  {
    this(0, false);
  }
  
  private final void indent()
  {
    for (int i = 0; i < depth; i++)
      p.print("  ");
  }

  private final java.util.IdentityHashMap h = 
  new java.util.IdentityHashMap();

  private static native Field[] getDeclaredFields(Class c);
  private static native Object getField(Object o, Field f);
  private static native long getAddr(Object o);

  // Return an array containing all the fields of a class and its
  // superclasses.
  private Field[] internalGetFields(Class c)
  {
    HashSet set = new HashSet();
    set.addAll(Arrays.asList(getDeclaredFields(c)));
    Class[] interfaces = c.getInterfaces();
    for (int i = 0; i < interfaces.length; i++)
      set.addAll(Arrays.asList(internalGetFields(interfaces[i])));
    Class superClass = c.getSuperclass();
    if (superClass != null)
      set.addAll(Arrays.asList(internalGetFields(superClass)));
    return (Field[])set.toArray(new Field[set.size()]);
  }

  // FIXME: We could just use getClass() here, but this is a
  // workaround for a C++ bug that is causing getClass() to be
  // miscompiled.
  static private Class getItsClass(Object O)
  {
    return O.getClass();
  }

  // Print a reasonably readable textual representation of an object
  // on our OutputStream.  Objects are only printed once, no matter
  // how many references point to them.
  private void print(Object O)
  {
    int savedDepth = depth;
    h.put(O, O);
    try
      {
	Class C = getItsClass(O);
	p.print(C.getName() + "@");
	p.println(Long.toHexString(getAddr(O)));

	if (C.isArray())
	  {
	    indent(); p.println("{");
	    depth++;
	    indent();
	    C = C.getComponentType();

	    int len = Array.getLength(O);
	    for (int i = 0; i < len; i++)
	      {
		Object thing = Array.get(O, i);
		print0(thing, C);
		p.print(", ");
		if (i > maxArrayLength)
		  {
		    p.print("...");
		    break;
		  }
	      }
	    depth--;
	    p.println();
	    indent(); p.print("}");
	    return;
	  }

	indent(); p.println("{");
	depth++;
	if (C == java.lang.Class.class)
	  {
	    indent();
	    p.println ("class = " + O.toString() + ",");
	  }
	else if (C == java.lang.reflect.Field.class)
	  {
	    indent();
	    p.println ("<field> = \"" + O.toString() + "\",");
	  }
	else if (C == java.lang.String.class)
	  {
	    indent();
	    p.println ("<string> = \"" + O.toString() + "\",");
	  }
	Field[] f = internalGetFields(C);
	for (int i = 0; i < f.length; i++)
	  {
	    Class type = f[i].getType();
	    boolean isStatic = (f[i].getModifiers() & Modifier.STATIC) != 0;
 
	    if (isStatic && ! printStaticFields)
	      continue;

	    indent();
	    if (isStatic)
	      p.print("static ");
	    p.print(type.getName() +" " +f[i].getName() + " = ");
	    Object thing = getField(O, f[i]);
	    print0(thing, type);
	    p.println(",");
	  }
	depth--;
	indent(); p.print("}");
      }
    catch (Throwable t)
      {
	p.print("error: 0x" + Long.toHexString(getAddr(O)) + ";");
	depth = savedDepth;
      }
  }

  private void print0(Object thing, Class C)
  {
    try
      {
	if (thing == null)
	  {
	    p.print("null");
	    return;
	  }
	else if (C == gnu.gcj.RawData.class || 
		 C == gnu.gcj.RawDataManaged.class)
	  {
	  }
	else if (C.isPrimitive())
	  {
	    if (getItsClass(thing) == Character.class)				
	      p.print("'" + thing + "'");
	    else
	      p.print(thing);
	    return;
	  }
	else if (getItsClass(thing) == String.class)
	  {			  
	    p.print("\"" + thing + "\"");
	    return;
	  }
	else if (depth < maxdepth && h.get(thing) == null)
	  {
	    depth++;
	    print(thing);
	    depth--;
	    return;
	  }
      }
    catch (Throwable t)
      {
      }
    
    // The default action: just print the address.
    p.print("0x"+ Long.toHexString(getAddr(thing)));    
  }

  // Print the textual representation of an object on System.err.
  public void write(Object O)
  {
    depth = 0;
    print(O);
    p.flush();
  }
}