--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/agent/src/share/classes/sun/jvm/hotspot/utilities/soql/JSJavaHeap.java	Sat Dec 01 00:00:00 2007 +0000
@@ -0,0 +1,263 @@
+/*
+ * Copyright 2004-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 javax.script.ScriptException;
+import sun.jvm.hotspot.debugger.*;
+import sun.jvm.hotspot.memory.*;
+import sun.jvm.hotspot.oops.*;
+import sun.jvm.hotspot.runtime.*;
+import sun.jvm.hotspot.utilities.*;
+import java.lang.reflect.Method;
+
+public class JSJavaHeap extends DefaultScriptObject {
+    private static final int FIELD_CAPACITY = 0;
+    private static final int FIELD_USED = 1;
+    private static final int FIELD_FOR_EACH_OBJECT = 2;
+    private static final int FIELD_FOR_EACH_CLASS = 3;
+
+    private static final int FIELD_UNDEFINED = -1;
+
+    public JSJavaHeap(JSJavaFactory fac) {
+        this.factory = fac;
+    }
+
+    public Object get(String name) {
+        int fieldID = getFieldID(name);
+        switch (fieldID) {
+        case FIELD_CAPACITY:
+            return new Long(getCapacity());
+        case FIELD_USED:
+            return new Long(getUsed());
+        case FIELD_FOR_EACH_OBJECT:
+            return new MethodCallable(this, forEachObjectMethod);
+        case FIELD_FOR_EACH_CLASS:
+            return new MethodCallable(this, forEachClassMethod);
+        case FIELD_UNDEFINED:
+        default:
+            return super.get(name);
+        }
+    }
+
+    public Object[] getIds() {
+        Object[] superIds = super.getIds();
+        Object[] tmp = fields.keySet().toArray();
+        Object[] res = new Object[superIds.length + tmp.length];
+        System.arraycopy(tmp, 0, res, 0, tmp.length);
+        System.arraycopy(superIds, 0, res, tmp.length, superIds.length);
+        return res;
+    }
+
+    public boolean has(String name) {
+        if (getFieldID(name) != FIELD_UNDEFINED) {
+            return true;
+        } else {
+            return super.has(name);
+        }
+    }
+
+    public void put(String name, Object value) {
+        if (getFieldID(name) == FIELD_UNDEFINED) {
+            super.put(name, value);
+        }
+    }
+
+    public void forEachObject(Object[] args) {
+        boolean subtypes = true;
+        Klass kls = null;
+        Callable func = null;
+        switch (args.length) {
+        case 3: {
+            Object b = args[2];
+            if (b != null && b instanceof Boolean) {
+                subtypes = ((Boolean)b).booleanValue();
+            }
+        }
+        case 2: {
+            Object k = args[1];
+            if (k == null) return;
+            if (k instanceof JSJavaKlass) {
+                kls = ((JSJavaKlass)k).getKlass();
+            } else if (k instanceof String) {
+                kls = SystemDictionaryHelper.findInstanceKlass((String)k);
+                if (kls == null) return;
+            }
+        }
+        case 1: {
+            Object f = args[0];
+            if (f != null && f instanceof Callable) {
+                func = (Callable) f;
+            } else {
+                // unknown target - just return
+                return ;
+            }
+        }
+        break;
+
+        default:
+            return;
+        }
+
+        final Callable finalFunc = func;
+      HeapVisitor visitor = new DefaultHeapVisitor() {
+                public boolean doObj(Oop oop) {
+                    JSJavaObject jo = factory.newJSJavaObject(oop);
+                    if (jo != null) {
+                  try {
+                    finalFunc.call(new Object[] { jo });
+                  } catch (ScriptException exp) {
+                    throw new RuntimeException(exp);
+                  }
+                    }
+                return false;
+                }
+            };
+        ObjectHeap heap = VM.getVM().getObjectHeap();
+        if (kls == null) {
+            kls = SystemDictionaryHelper.findInstanceKlass("java.lang.Object");
+        }
+        heap.iterateObjectsOfKlass(visitor, kls, subtypes);
+    }
+
+    public void forEachClass(Object[] args) {
+        boolean withLoader = false;
+        Callable func = null;
+        switch (args.length) {
+        case 2: {
+            Object b = args[1];
+            if (b instanceof Boolean) {
+                withLoader = ((Boolean)b).booleanValue();
+            }
+        }
+        case 1: {
+            Object f = args[0];
+            if (f instanceof Callable) {
+                func = (Callable) f;
+            } else {
+                return;
+            }
+        }
+        break;
+        default:
+            return;
+        }
+
+      final Callable finalFunc = func;
+        SystemDictionary sysDict = VM.getVM().getSystemDictionary();
+        if (withLoader) {
+            sysDict.classesDo(new SystemDictionary.ClassAndLoaderVisitor() {
+                    public void visit(Klass kls, Oop loader) {
+                        JSJavaKlass  jk = factory.newJSJavaKlass(kls);
+                        if (jk == null) {
+                            return;
+                        }
+                        JSJavaObject k = jk.getJSJavaClass();
+                        JSJavaObject l = factory.newJSJavaObject(loader);
+                        if (k != null) {
+                         if (k != null) {
+                       try {
+                               finalFunc.call(new Object[] { k, l });
+                       } catch (ScriptException exp) {
+                         throw new RuntimeException(exp);
+                       }
+                           }
+                        }
+                    }
+                });
+
+        } else {
+            sysDict.classesDo(new SystemDictionary.ClassVisitor() {
+                    public void visit(Klass kls) {
+                        JSJavaKlass jk = factory.newJSJavaKlass(kls);
+                        if (jk == null) {
+                            return;
+                        }
+                        JSJavaClass k = jk.getJSJavaClass();
+                        if (k != null) {
+                            if (k != null) {
+                        try {
+                                  finalFunc.call(new Object[] { k });
+                        } catch (ScriptException exp) {
+                          throw new RuntimeException(exp);
+                        }
+                            }
+                        }
+                    }
+                });
+        }
+    }
+
+    public String toString() {
+        StringBuffer buf = new StringBuffer();
+        buf.append("Java Heap (capacity=");
+        buf.append(getCapacity());
+        buf.append(", used=");
+        buf.append(getUsed());
+        buf.append(")");
+        return buf.toString();
+    }
+
+    //-- Internals 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("capacity", FIELD_CAPACITY);
+        addField("used", FIELD_USED);
+        addField("forEachObject", FIELD_FOR_EACH_OBJECT);
+        addField("forEachClass", FIELD_FOR_EACH_CLASS);
+      try {
+          Class myClass = JSJavaHeap.class;
+          forEachObjectMethod = myClass.getMethod("forEachObject",
+                                new Class[] { Object[].class });
+          forEachClassMethod = myClass.getMethod("forEachClass",
+                                new Class[] {Object[].class });
+      } catch (RuntimeException re) {
+          throw re;
+      } catch (Exception exp) {
+          throw new RuntimeException(exp);
+      }
+    }
+
+    private long getCapacity() {
+        return VM.getVM().getUniverse().heap().capacity();
+    }
+
+    private long getUsed() {
+        return VM.getVM().getUniverse().heap().used();
+    }
+
+    private final JSJavaFactory factory;
+    private static Method forEachObjectMethod;
+    private static Method forEachClassMethod;
+}