feat(jdk8): move files to new folder to avoid resources compiled.

jdkSrc/jdk8/com/sun/tools/hat/internal/oql/OQLEngine.java

@@ -0,0 +1,311 @@
+/*
+ * Copyright (c) 1997, 2008, Oracle and/or its affiliates. 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.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+
+/*
+ * The Original Code is HAT. The Initial Developer of the
+ * Original Code is Bill Foote, with contributions from others
+ * at JavaSoft/Sun.
+ */
+
+package com.sun.tools.hat.internal.oql;
+
+import com.sun.tools.hat.internal.model.*;
+import java.io.*;
+import java.lang.reflect.*;
+import java.util.*;
+
+/**
+ * This is Object Query Language Interpreter
+ *
+ */
+public class OQLEngine {
+    static {
+        try {
+            // Do we have javax.script support?
+            // create ScriptEngineManager
+            Class<?> managerClass = Class.forName("javax.script.ScriptEngineManager");
+            Object manager = managerClass.newInstance();
+
+            // create JavaScript engine
+            Method getEngineMethod = managerClass.getMethod("getEngineByName",
+                                new Class[] { String.class });
+            Object jse = getEngineMethod.invoke(manager, new Object[] {"js"});
+            oqlSupported = (jse != null);
+        } catch (Exception exp) {
+            oqlSupported = false;
+        }
+    }
+
+    // check OQL is supported or not before creating OQLEngine
+    public static boolean isOQLSupported() {
+        return oqlSupported;
+    }
+
+    public OQLEngine(Snapshot snapshot) {
+        if (!isOQLSupported()) {
+            throw new UnsupportedOperationException("OQL not supported");
+        }
+        init(snapshot);
+    }
+
+    /**
+       Query is of the form
+
+          select &lt;java script code to select&gt;
+          [ from [instanceof] &lt;class name&gt; [&lt;identifier&gt;]
+            [ where &lt;java script boolean expression&gt; ]
+          ]
+    */
+    public synchronized void executeQuery(String query, ObjectVisitor visitor)
+                                          throws OQLException {
+        debugPrint("query : " + query);
+        StringTokenizer st = new StringTokenizer(query);
+        if (st.hasMoreTokens()) {
+            String first = st.nextToken();
+            if (! first.equals("select") ) {
+                // Query does not start with 'select' keyword.
+                // Just treat it as plain JavaScript and eval it.
+                try {
+                    Object res = evalScript(query);
+                    visitor.visit(res);
+                } catch (Exception e) {
+                    throw new OQLException(e);
+                }
+                return;
+            }
+        } else {
+            throw new OQLException("query syntax error: no 'select' clause");
+        }
+
+        String selectExpr = "";
+        boolean seenFrom = false;
+        while (st.hasMoreTokens()) {
+            String tok = st.nextToken();
+            if (tok.equals("from")) {
+                seenFrom = true;
+                break;
+            }
+            selectExpr += " " + tok;
+        }
+
+        if (selectExpr.equals("")) {
+            throw new OQLException("query syntax error: 'select' expression can not be empty");
+        }
+
+        String className = null;
+        boolean isInstanceOf = false;
+        String whereExpr =  null;
+        String identifier = null;
+
+        if (seenFrom) {
+            if (st.hasMoreTokens()) {
+                String tmp = st.nextToken();
+                if (tmp.equals("instanceof")) {
+                    isInstanceOf = true;
+                    if (! st.hasMoreTokens()) {
+                        throw new OQLException("no class name after 'instanceof'");
+                    }
+                    className = st.nextToken();
+                } else {
+                    className = tmp;
+                }
+            } else {
+                throw new OQLException("query syntax error: class name must follow 'from'");
+            }
+
+            if (st.hasMoreTokens()) {
+                identifier = st.nextToken();
+                if (identifier.equals("where")) {
+                    throw new OQLException("query syntax error: identifier should follow class name");
+                }
+                if (st.hasMoreTokens()) {
+                    String tmp = st.nextToken();
+                    if (! tmp.equals("where")) {
+                        throw new OQLException("query syntax error: 'where' clause expected after 'from' clause");
+                    }
+
+                    whereExpr = "";
+                    while (st.hasMoreTokens()) {
+                        whereExpr += " " + st.nextToken();
+                    }
+                    if (whereExpr.equals("")) {
+                        throw new OQLException("query syntax error: 'where' clause cannot have empty expression");
+                    }
+                }
+            } else {
+                throw new OQLException("query syntax error: identifier should follow class name");
+            }
+        }
+
+        executeQuery(new OQLQuery(selectExpr, isInstanceOf, className,
+                                  identifier, whereExpr), visitor);
+    }
+
+    private void executeQuery(OQLQuery q, ObjectVisitor visitor)
+                              throws OQLException {
+        JavaClass clazz = null;
+        if (q.className != null) {
+            clazz = snapshot.findClass(q.className);
+            if (clazz == null) {
+                throw new OQLException(q.className + " is not found!");
+            }
+        }
+
+        StringBuffer buf = new StringBuffer();
+        buf.append("function __select__(");
+        if (q.identifier != null) {
+            buf.append(q.identifier);
+        }
+        buf.append(") { return ");
+        buf.append(q.selectExpr.replace('\n', ' '));
+        buf.append("; }");
+
+        String selectCode = buf.toString();
+        debugPrint(selectCode);
+        String whereCode = null;
+        if (q.whereExpr != null) {
+            buf = new StringBuffer();
+            buf.append("function __where__(");
+            buf.append(q.identifier);
+            buf.append(") { return ");
+            buf.append(q.whereExpr.replace('\n', ' '));
+            buf.append("; }");
+            whereCode = buf.toString();
+        }
+        debugPrint(whereCode);
+
+        // compile select expression and where condition
+        try {
+            evalMethod.invoke(engine, new Object[] { selectCode });
+            if (whereCode != null) {
+                evalMethod.invoke(engine, new Object[] { whereCode });
+            }
+
+            if (q.className != null) {
+                Enumeration objects = clazz.getInstances(q.isInstanceOf);
+                while (objects.hasMoreElements()) {
+                    JavaHeapObject obj = (JavaHeapObject) objects.nextElement();
+                    Object[] args = new Object[] { wrapJavaObject(obj) };
+                    boolean b = (whereCode == null);
+                    if (!b) {
+                        Object res = call("__where__", args);
+                        if (res instanceof Boolean) {
+                            b = ((Boolean)res).booleanValue();
+                        } else if (res instanceof Number) {
+                            b = ((Number)res).intValue() != 0;
+                        } else {
+                            b = (res != null);
+                        }
+                    }
+
+                    if (b) {
+                        Object select = call("__select__", args);
+                        if (visitor.visit(select)) return;
+                    }
+                }
+            } else {
+                // simple "select <expr>" query
+                Object select = call("__select__", new Object[] {});
+                visitor.visit(select);
+            }
+        } catch (Exception e) {
+            throw new OQLException(e);
+        }
+    }
+
+    public Object evalScript(String script) throws Exception {
+        return evalMethod.invoke(engine, new Object[] { script });
+    }
+
+    public Object wrapJavaObject(JavaHeapObject obj) throws Exception {
+        return call("wrapJavaObject", new Object[] { obj });
+    }
+
+    public Object toHtml(Object obj) throws Exception {
+        return call("toHtml", new Object[] { obj });
+    }
+
+    public Object call(String func, Object[] args) throws Exception {
+        return invokeMethod.invoke(engine, new Object[] { func, args });
+    }
+
+    private static void debugPrint(String msg) {
+        if (debug) System.out.println(msg);
+    }
+
+    private void init(Snapshot snapshot) throws RuntimeException {
+        this.snapshot = snapshot;
+        try {
+            // create ScriptEngineManager
+            Class<?> managerClass = Class.forName("javax.script.ScriptEngineManager");
+            Object manager = managerClass.newInstance();
+
+            // create JavaScript engine
+            Method getEngineMethod = managerClass.getMethod("getEngineByName",
+                                new Class[] { String.class });
+            engine = getEngineMethod.invoke(manager, new Object[] {"js"});
+
+            // initialize engine with init file (hat.js)
+            InputStream strm = getInitStream();
+            Class<?> engineClass = Class.forName("javax.script.ScriptEngine");
+            evalMethod = engineClass.getMethod("eval",
+                                new Class[] { Reader.class });
+            evalMethod.invoke(engine, new Object[] {new InputStreamReader(strm)});
+
+            // initialize ScriptEngine.eval(String) and
+            // Invocable.invokeFunction(String, Object[]) methods.
+            Class<?> invocableClass = Class.forName("javax.script.Invocable");
+
+            evalMethod = engineClass.getMethod("eval",
+                                  new Class[] { String.class });
+            invokeMethod = invocableClass.getMethod("invokeFunction",
+                                  new Class[] { String.class, Object[].class });
+
+            // initialize ScriptEngine.put(String, Object) method
+            Method putMethod = engineClass.getMethod("put",
+                                  new Class[] { String.class, Object.class });
+
+            // call ScriptEngine.put to initialize built-in heap object
+            putMethod.invoke(engine, new Object[] {
+                        "heap", call("wrapHeapSnapshot", new Object[] { snapshot })
+                    });
+        } catch (Exception e) {
+            if (debug) e.printStackTrace();
+            throw new RuntimeException(e);
+        }
+    }
+
+    private InputStream getInitStream() {
+        return getClass().getResourceAsStream("/com/sun/tools/hat/resources/hat.js");
+    }
+
+    private Object engine;
+    private Method evalMethod;
+    private Method invokeMethod;
+    private Snapshot snapshot;
+    private static boolean debug = false;
+    private static boolean oqlSupported;
+}