--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/agent/src/share/classes/sun/jvm/hotspot/utilities/soql/JSJavaInstanceKlass.java	Sat Dec 01 00:00:00 2007 +0000
@@ -0,0 +1,361 @@
+/*
+ * Copyright 2003-2007 Sun Microsystems, Inc.  All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+package sun.jvm.hotspot.utilities.soql;
+
+import java.util.*;
+import sun.jvm.hotspot.oops.*;
+import sun.jvm.hotspot.utilities.*;
+
+/**
+   This is JavaScript wrapper for InstanceKlass.
+*/
+public class JSJavaInstanceKlass extends JSJavaKlass {
+   private static final int FIELD_SOURCE_FILE        = 1;
+   private static final int FIELD_INTERFACES         = 2;
+   private static final int FIELD_FIELDS             = 3;
+   private static final int FIELD_METHODS            = 4;
+   private static final int FIELD_IS_PRIVATE         = 5;
+   private static final int FIELD_IS_PUBLIC          = 6;
+   private static final int FIELD_IS_PROTECTED       = 7;
+   private static final int FIELD_IS_PACKAGE_PRIVATE = 8;
+   private static final int FIELD_IS_STATIC          = 9;
+   private static final int FIELD_IS_FINAL           = 10;
+   private static final int FIELD_IS_ABSTRACT        = 11;
+   private static final int FIELD_IS_STRICT          = 12;
+   private static final int FIELD_IS_SYNTHETIC       = 13;
+   private static final int FIELD_IS_INTERFACE       = 14;
+   private static final int FIELD_CLASS_LOADER       = 15;
+   private static final int FIELD_PROTECTION_DOMAIN  = 16;
+   private static final int FIELD_SIGNERS            = 17;
+   private static final int FIELD_STATICS            = 18;
+   private static final int FIELD_UNDEFINED          = -1;
+
+   public JSJavaInstanceKlass(InstanceKlass kls, JSJavaFactory fac) {
+      super(kls, fac);
+      this.instanceFields = new HashMap();
+      this.staticFields = new HashMap();
+   }
+
+   public final InstanceKlass getInstanceKlass() {
+      return (InstanceKlass) getKlass();
+   }
+
+   public Object getMetaClassFieldValue(String name) {
+      int fieldID = getFieldID(name);
+      InstanceKlass ik = getInstanceKlass();
+      switch (fieldID) {
+      case FIELD_SOURCE_FILE: {
+         Symbol sourceFile = ik.getSourceFileName();
+         return (sourceFile != null)? sourceFile.asString() : "<unknown>";
+      }
+      case FIELD_INTERFACES:
+         return getInterfaces();
+      case FIELD_FIELDS:
+         return factory.newJSList(ik.getImmediateFields());
+      case FIELD_METHODS:
+         return factory.newJSList(ik.getImmediateMethods());
+      case FIELD_IS_PRIVATE:
+         return Boolean.valueOf(getAccessFlags().isPrivate());
+      case FIELD_IS_PUBLIC:
+         return Boolean.valueOf(getAccessFlags().isPublic());
+      case FIELD_IS_PROTECTED:
+         return Boolean.valueOf(getAccessFlags().isProtected());
+      case FIELD_IS_PACKAGE_PRIVATE: {
+         AccessFlags acc = getAccessFlags();
+         return Boolean.valueOf(!acc.isPrivate() && !acc.isPublic() && !acc.isProtected());
+      }
+      case FIELD_IS_STATIC:
+         return Boolean.valueOf(getAccessFlags().isStatic());
+      case FIELD_IS_FINAL:
+         return Boolean.valueOf(getAccessFlags().isFinal());
+      case FIELD_IS_ABSTRACT:
+         return Boolean.valueOf(getAccessFlags().isAbstract());
+      case FIELD_IS_STRICT:
+         return Boolean.valueOf(getAccessFlags().isStrict());
+      case FIELD_IS_SYNTHETIC:
+         return Boolean.valueOf(getAccessFlags().isSynthetic());
+      case FIELD_IS_INTERFACE:
+         return Boolean.valueOf(ik.isInterface());
+      case FIELD_CLASS_LOADER:
+         return factory.newJSJavaObject(ik.getClassLoader());
+      case FIELD_PROTECTION_DOMAIN:
+         return factory.newJSJavaObject(ik.getProtectionDomain());
+      case FIELD_SIGNERS:
+         return factory.newJSJavaObject(ik.getSigners());
+      case FIELD_STATICS:
+         return getStatics();
+      case FIELD_UNDEFINED:
+      default:
+         return super.getMetaClassFieldValue(name);
+      }
+   }
+
+   public boolean hasMetaClassField(String name) {
+      if (getFieldID(name) != FIELD_UNDEFINED) {
+          return true;
+      } else {
+          return super.hasMetaClassField(name);
+      }
+   }
+
+   public String getName() {
+      return getInstanceKlass().getName().asString().replace('/', '.');
+   }
+
+   public boolean isArray() {
+      return false;
+   }
+
+   public String[] getMetaClassFieldNames() {
+      String[] superFields = super.getMetaClassFieldNames();
+      Set k = fields.keySet();
+      String[] res = new String[k.size() + superFields.length];
+      System.arraycopy(superFields, 0, res, 0, superFields.length);
+      int i = superFields.length;
+      for (Iterator itr = k.iterator(); itr.hasNext();) {
+          res[i] = (String) itr.next();
+          i++;
+      }
+      return res;
+   }
+
+   public Object getInstanceFieldValue(String name, Instance instance) throws NoSuchFieldException {
+      Field fld = findInstanceField(name);
+      if (fld != null) {
+         return getFieldValue(fld, name, instance);
+      } else {
+         throw new NoSuchFieldException(name + " is not field of "
+                + getInstanceKlass().getName().asString().replace('/', '.'));
+      }
+   }
+
+   public Object getStaticFieldValue(String name) throws NoSuchFieldException {
+      Field fld = findStaticField(name);
+      if (fld != null) {
+         return getFieldValue(fld, name, getInstanceKlass());
+      } else {
+         throw new NoSuchFieldException(name + " is not field of "
+                + getInstanceKlass().getName().asString().replace('/', '.'));
+      }
+   }
+
+   public String[] getInstanceFieldNames() {
+      if (instanceFieldNames == null) {
+         InstanceKlass current = getInstanceKlass();
+         while (current != null) {
+            List tmp = current.getImmediateFields();
+            for (Iterator itr = tmp.iterator(); itr.hasNext();) {
+               Field fld = (Field) itr.next();
+               if (!fld.isStatic()) {
+                  String name = fld.getID().getName();
+                  if (instanceFields.get(name) == null) {
+                     instanceFields.put(name, fld);
+                  }
+               }
+            }
+            current = (InstanceKlass) current.getSuper();
+         }
+
+         Set s = instanceFields.keySet();
+         instanceFieldNames = new String[s.size()];
+         int i = 0;
+         for (Iterator itr = s.iterator(); itr.hasNext(); i++) {
+            instanceFieldNames[i] = (String) itr.next();
+         }
+      }
+      return instanceFieldNames;
+   }
+
+   public boolean hasInstanceField(String name) {
+      Field fld = findInstanceField(name);
+      return (fld != null)? true: false;
+   }
+
+   public String[] getStaticFieldNames() {
+      if (staticFieldNames == null) {
+         InstanceKlass current = getInstanceKlass();
+         List tmp = current.getImmediateFields();
+         for (Iterator itr = tmp.iterator(); itr.hasNext();) {
+            Field fld = (Field) itr.next();
+            if (fld.isStatic()) {
+               staticFields.put(fld.getID().getName(), fld);
+            }
+         }
+
+         Set s = staticFields.keySet();
+         staticFieldNames = new String[s.size()];
+         int i = 0;
+         for (Iterator itr = s.iterator(); itr.hasNext(); i++) {
+            staticFieldNames[i] = (String) itr.next();
+         }
+      }
+      return staticFieldNames;
+   }
+
+   public boolean hasStaticField(String name) {
+      Field fld = findStaticField(name);
+      return (fld != null)? true: false;
+   }
+
+   //-- Intenals only below this point
+   private static Map fields = new HashMap();
+   private static void addField(String name, int fieldId) {
+      fields.put(name, new Integer(fieldId));
+   }
+
+   private static int getFieldID(String name) {
+      Integer res = (Integer) fields.get(name);
+      return (res != null)? res.intValue() : FIELD_UNDEFINED;
+   }
+
+   static {
+      addField("sourceFile", FIELD_SOURCE_FILE);
+      addField("interfaces", FIELD_INTERFACES);
+      addField("fields", FIELD_FIELDS);
+      addField("methods", FIELD_METHODS);
+      addField("isPrivate", FIELD_IS_PRIVATE);
+      addField("isPublic", FIELD_IS_PUBLIC);
+      addField("isProtected", FIELD_IS_PROTECTED);
+      addField("isPackagePrivate", FIELD_IS_PACKAGE_PRIVATE);
+      addField("isStatic", FIELD_IS_STATIC);
+      addField("isFinal", FIELD_IS_FINAL);
+      addField("isAbstract", FIELD_IS_ABSTRACT);
+      addField("isStrict", FIELD_IS_STRICT);
+      addField("isSynthetic", FIELD_IS_SYNTHETIC);
+      addField("isInterface", FIELD_IS_INTERFACE);
+      addField("classLoader", FIELD_CLASS_LOADER);
+      addField("protectionDomain", FIELD_PROTECTION_DOMAIN);
+      addField("signers", FIELD_SIGNERS);
+      addField("statics", FIELD_STATICS);
+   }
+
+   private AccessFlags getAccessFlags() {
+      if (accFlags == null) {
+         accFlags = new AccessFlags(getInstanceKlass().computeModifierFlags());
+      }
+      return accFlags;
+   }
+
+   private Object getFieldValue(Field fld, String name, Oop oop) {
+       FieldType fd = fld.getFieldType();
+       if (fd.isObject() || fd.isArray()) {
+         return factory.newJSJavaObject(((OopField)fld).getValue(oop));
+       } else if (fd.isByte()) {
+          return new Byte(((ByteField)fld).getValue(oop));
+       } else if (fd.isChar()) {
+          return new String(new char[] { ((CharField)fld).getValue(oop) });
+       } else if (fd.isDouble()) {
+          return new Double(((DoubleField)fld).getValue(oop));
+       } else if (fd.isFloat()) {
+          return new Float(((FloatField)fld).getValue(oop));
+       } else if (fd.isInt()) {
+          return new Integer(((IntField)fld).getValue(oop));
+       } else if (fd.isLong()) {
+          return new Long(((LongField)fld).getValue(oop));
+       } else if (fd.isShort()) {
+          return new Short(((ShortField)fld).getValue(oop));
+       } else if (fd.isBoolean()) {
+          return Boolean.valueOf(((BooleanField)fld).getValue(oop));
+       } else {
+          if (Assert.ASSERTS_ENABLED) {
+             Assert.that(false, "invalid field type for " + name);
+          }
+          return null;
+       }
+   }
+
+   private Field findInstanceField(String name) {
+      Field fld = (Field) instanceFields.get(name);
+      if (fld != null) {
+         return fld;
+      } else {
+         InstanceKlass current = getInstanceKlass();
+         while (current != null) {
+            List tmp = current.getImmediateFields();
+            for (Iterator itr = tmp.iterator(); itr.hasNext();) {
+               fld = (Field) itr.next();
+               if (fld.getID().getName().equals(name) && !fld.isStatic()) {
+                   instanceFields.put(name, fld);
+                   return fld;
+               }
+            }
+            // lookup in super class.
+            current = (InstanceKlass) current.getSuper();
+         }
+      }
+      // no match
+      return null;
+   }
+
+   private Field findStaticField(String name) {
+      Field fld = (Field) staticFields.get(name);
+      if (fld != null) {
+         return fld;
+      } else {
+         // static fields are searched only in current.
+         // Direct/indirect super classes and interfaces
+         // are not included in search.
+         InstanceKlass current = getInstanceKlass();
+         List tmp = current.getImmediateFields();
+         for (Iterator itr = tmp.iterator(); itr.hasNext();) {
+            fld = (Field) itr.next();
+            if (fld.getID().getName().equals(name) && fld.isStatic()) {
+               staticFields.put(name, fld);
+               return fld;
+            }
+         }
+         // no match
+         return null;
+      }
+   }
+
+   private JSList getInterfaces() {
+      InstanceKlass ik = getInstanceKlass();
+      List intfs = ik.getDirectImplementedInterfaces();
+      List res = new ArrayList(0);
+      for (Iterator itr = intfs.iterator(); itr.hasNext();) {
+          Klass k = (Klass) itr.next();
+          res.add(k.getJavaMirror());
+      }
+      return factory.newJSList(res);
+   }
+
+   private JSMap getStatics() {
+      String[] names = getStaticFieldNames();
+      Map map = new HashMap();
+      for (int i=0; i < names.length; i++) {
+         try {
+            map.put(names[i], getStaticFieldValue(names[i]));
+         } catch (NoSuchFieldException exp) {}
+      }
+      return factory.newJSMap(map);
+  }
+
+   private Map           instanceFields;
+   private Map           staticFields;
+   private String[]      instanceFieldNames;
+   private String[]      staticFieldNames;
+   private AccessFlags   accFlags;
+}