+/* 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();
+ }
+}
OSDN Git Service
