/*

 * Copyright (c) 2005, 2019, 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.

 *

 * 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.

 *

 */

package sun.jvm.hotspot;

import java.io.BufferedOutputStream;

import java.io.BufferedReader;

import java.io.ByteArrayOutputStream;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.PrintStream;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Comparator;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.Stack;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import sun.jvm.hotspot.ci.ciEnv;

import sun.jvm.hotspot.code.CodeBlob;

import sun.jvm.hotspot.code.CodeCacheVisitor;

import sun.jvm.hotspot.code.NMethod;

import sun.jvm.hotspot.debugger.Address;

import sun.jvm.hotspot.debugger.OopHandle;

import sun.jvm.hotspot.classfile.ClassLoaderDataGraph;

import sun.jvm.hotspot.memory.FileMapInfo;

import sun.jvm.hotspot.memory.SystemDictionary;

import sun.jvm.hotspot.memory.Universe;

import sun.jvm.hotspot.gc.shared.CollectedHeap;

import sun.jvm.hotspot.gc.g1.G1CollectedHeap;

import sun.jvm.hotspot.oops.DefaultHeapVisitor;

import sun.jvm.hotspot.oops.HeapVisitor;

import sun.jvm.hotspot.oops.InstanceKlass;

import sun.jvm.hotspot.oops.Klass;

import sun.jvm.hotspot.oops.Metadata;

import sun.jvm.hotspot.oops.Method;

import sun.jvm.hotspot.oops.MethodData;

import sun.jvm.hotspot.oops.Oop;

import sun.jvm.hotspot.oops.RawHeapVisitor;

import sun.jvm.hotspot.oops.Symbol;

import sun.jvm.hotspot.oops.UnknownOopException;

import sun.jvm.hotspot.opto.Compile;

import sun.jvm.hotspot.opto.InlineTree;

import sun.jvm.hotspot.runtime.CompiledVFrame;

import sun.jvm.hotspot.runtime.CompilerThread;

import sun.jvm.hotspot.runtime.JavaThread;

import sun.jvm.hotspot.runtime.JavaVFrame;

import sun.jvm.hotspot.runtime.Threads;

import sun.jvm.hotspot.runtime.VM;

import sun.jvm.hotspot.tools.ObjectHistogram;

import sun.jvm.hotspot.tools.PMap;

import sun.jvm.hotspot.tools.PStack;

import sun.jvm.hotspot.tools.StackTrace;

import sun.jvm.hotspot.tools.jcore.ClassDump;

import sun.jvm.hotspot.tools.jcore.ClassFilter;

import sun.jvm.hotspot.types.CIntegerType;

import sun.jvm.hotspot.types.Field;

import sun.jvm.hotspot.types.Type;

import sun.jvm.hotspot.types.basic.BasicType;

import sun.jvm.hotspot.ui.classbrowser.HTMLGenerator;

import sun.jvm.hotspot.ui.tree.CTypeTreeNodeAdapter;

import sun.jvm.hotspot.ui.tree.OopTreeNodeAdapter;

import sun.jvm.hotspot.ui.tree.SimpleTreeNode;

import sun.jvm.hotspot.utilities.AddressOps;

import sun.jvm.hotspot.utilities.Assert;

import sun.jvm.hotspot.utilities.CompactHashTable;

import sun.jvm.hotspot.utilities.HeapProgressThunk;

import sun.jvm.hotspot.utilities.LivenessPathElement;

import sun.jvm.hotspot.utilities.MethodArray;

import sun.jvm.hotspot.utilities.ObjectReader;

import sun.jvm.hotspot.utilities.PointerFinder;

import sun.jvm.hotspot.utilities.PointerLocation;

import sun.jvm.hotspot.utilities.ReversePtrs;

import sun.jvm.hotspot.utilities.ReversePtrsAnalysis;

import sun.jvm.hotspot.utilities.RobustOopDeterminator;

import sun.jvm.hotspot.utilities.SystemDictionaryHelper;

import sun.jvm.hotspot.utilities.soql.JSJavaFactory;

import sun.jvm.hotspot.utilities.soql.JSJavaFactoryImpl;

import sun.jvm.hotspot.utilities.soql.JSJavaScriptEngine;

public class CommandProcessor {

    volatile boolean quit;

    public abstract static class DebuggerInterface {

        public abstract HotSpotAgent getAgent();

        public abstract boolean isAttached();

        public abstract void attach(String pid);

        public abstract void attach(String java, String core);

        public abstract void detach();

        public abstract void reattach();

    }

    public static class BootFilter implements ClassFilter {

        public boolean canInclude(InstanceKlass kls) {

            return kls.getClassLoader() == null;

        }

    }

    public static class NonBootFilter implements ClassFilter {

        private HashMap emitted = new HashMap();

        public boolean canInclude(InstanceKlass kls) {

            if (kls.getClassLoader() == null) return false;

            if (emitted.get(kls.getName()) != null) {

                // Since multiple class loaders are being shoved

                // together duplicate classes are a possibilty.  For

                // now just ignore them.

                return false;

            }

            emitted.put(kls.getName(), kls);

            return true;

        }

    }

    static class Tokens {

        final String input;

        int i;

        String[] tokens;

        int length;

        String[] splitWhitespace(String cmd) {

            String[] t = cmd.split("\\s");

            if (t.length == 1 && t[0].length() == 0) {

                return new String[0];

            }

            return t;

        }

        void add(String s, ArrayList t) {

            if (s.length() > 0) {

                t.add(s);

            }

        }

        Tokens(String cmd) {

            input = cmd;

            // check for quoting

            int quote = cmd.indexOf('"');

            ArrayList t = new ArrayList();

            if (quote != -1) {

                while (cmd.length() > 0) {

                    if (quote != -1) {

                        int endquote = cmd.indexOf('"', quote + 1);

                        if (endquote == -1) {

                            throw new RuntimeException("mismatched quotes: " + input);

                        }

                        String before = cmd.substring(0, quote).trim();

                        String quoted = cmd.substring(quote + 1, endquote);

                        cmd = cmd.substring(endquote + 1).trim();

                        if (before.length() > 0) {

                            String[] w = splitWhitespace(before);

                            for (int i = 0; i < w.length; i++) {

                                add(w[i], t);

                            }

                        }

                        add(quoted, t);

                        quote = cmd.indexOf('"');

                    } else {

                        String[] w = splitWhitespace(cmd);

                        for (int i = 0; i < w.length; i++) {

                            add(w[i], t);

                        }

                        cmd = "";

                    }

                }

            } else {

                String[] w = splitWhitespace(cmd);

                for (int i = 0; i < w.length; i++) {

                    add(w[i], t);

                }

            }

            tokens = (String[])t.toArray(new String[0]);

            i = 0;

            length = tokens.length;

            //for (int i = 0; i < tokens.length; i++) {

            //    System.out.println("\"" + tokens[i] + "\"");

            //}

        }

        String nextToken() {

            return tokens[i++];

        }

        boolean hasMoreTokens() {

            return i < length;

        }

        int countTokens() {

            return length - i;

        }

        void trim(int n) {

            if (length >= n) {

                length -= n;

            } else {

                throw new IndexOutOfBoundsException(String.valueOf(n));

            }

        }

        String join(String sep) {

            StringBuffer result = new StringBuffer();

            for (int w = i; w < length; w++) {

                result.append(tokens[w]);

                if (w + 1 < length) {

                    result.append(sep);

                }

            }

            return result.toString();

        }

        String at(int i) {

            if (i < 0 || i >= length) {

                throw new IndexOutOfBoundsException(String.valueOf(i));

            }

            return tokens[i];

        }

    }

    abstract class Command {

        Command(String n, String u, boolean ok) {

            name = n;

            usage = u;

            okIfDisconnected = ok;

        }

        Command(String n, boolean ok) {

            name = n;

            usage = n;

            okIfDisconnected = ok;

        }

        final String name;

        final String usage;

        final boolean okIfDisconnected;

        abstract void doit(Tokens t);

        void usage() {

            out.println("Usage: " + usage);

        }

        void printOopValue(Oop oop) {

            if (oop != null) {

                Klass k = oop.getKlass();

                Symbol s = k.getName();

                if (s != null) {

                    out.print("Oop for " + s.asString() + " @ ");

                } else {

                    out.print("Oop @ ");

                }

                Oop.printOopAddressOn(oop, out);

            } else {

                out.print("null");

            }

        }

        void printNode(SimpleTreeNode node) {

            int count = node.getChildCount();

            for (int i = 0; i < count; i++) {

                try {

                    SimpleTreeNode field = node.getChild(i);

                    if (field instanceof OopTreeNodeAdapter) {

                        out.print(field);

                        out.print(" ");

                        printOopValue(((OopTreeNodeAdapter)field).getOop());

                        out.println();

                    } else {

                        out.println(field);

                    }

                } catch (Exception e) {

                    out.println();

                    out.println("Error: " + e);

                    if (verboseExceptions) {

                        e.printStackTrace(out);

                    }

                }

            }

        }

    }

    void quote(String s) {

        if (s.indexOf(" ") == -1) {

            out.print(s);

        } else {

            out.print("\"");

            out.print(s);

            out.print("\"");

        }

    }

    void dumpType(Type type) {

        out.print("type ");

        quote(type.getName());

        out.print(" ");

        if (type.getSuperclass() != null) {

            quote(type.getSuperclass().getName());

            out.print(" ");

        } else {

            out.print("null ");

        }

        out.print(type.isOopType());

        out.print(" ");

        if (type.isCIntegerType()) {

            out.print("true ");

            out.print(((CIntegerType)type).isUnsigned());

            out.print(" ");

        } else {

            out.print("false false ");

        }

        out.print(type.getSize());

        out.println();

    }

    void dumpFields(Type type) {

        dumpFields(type, true);

    }

    void dumpFields(Type type, boolean allowStatic) {

        Iterator i = type.getFields();

        while (i.hasNext()) {

            Field f = (Field) i.next();

            if (!allowStatic && f.isStatic()) continue;

            out.print("field ");

            quote(type.getName());

            out.print(" ");

            out.print(f.getName());

            out.print(" ");

            quote(f.getType().getName());

            out.print(" ");

            out.print(f.isStatic());

            out.print(" ");

            if (f.isStatic()) {

                out.print("0 ");

                out.print(f.getStaticFieldAddress());

            } else {

                out.print(f.getOffset());

                out.print(" 0x0");

            }

            out.println();

        }

    }

    Address lookup(String symbol) {

        if (symbol.indexOf("::") != -1) {

            String[] parts = symbol.split("::");

            StringBuffer mangled = new StringBuffer("__1c");

            for (int i = 0; i < parts.length; i++) {

                int len = parts[i].length();

                if (len >= 26) {

                    mangled.append((char)('a' + (len / 26)));

                    len = len % 26;

                }

                mangled.append((char)('A' + len));

                mangled.append(parts[i]);

            }

            mangled.append("_");

            symbol = mangled.toString();

        }

        return VM.getVM().getDebugger().lookup(null, symbol);

    }

    Address parseAddress(String addr) {

        return VM.getVM().getDebugger().parseAddress(addr);

    }

    private final Command[] commandList = {

        new Command("reattach", true) {

            public void doit(Tokens t) {

                int tokens = t.countTokens();

                if (tokens != 0) {

                    usage();

                    return;

                }

                preAttach();

                debugger.reattach();

                postAttach();

            }

        },

        new Command("attach", "attach pid | exec core", true) {

            public void doit(Tokens t) {

                int tokens = t.countTokens();

                if (tokens == 1) {

                    preAttach();

                    debugger.attach(t.nextToken());

                    postAttach();

                } else if (tokens == 2) {

                    preAttach();

                    debugger.attach(t.nextToken(), t.nextToken());

                    postAttach();

                } else {

                    usage();

                }

            }

        },

        new Command("detach", false) {

            public void doit(Tokens t) {

                if (t.countTokens() != 0) {

                    usage();

                } else {

                    debugger.detach();

                }

            }

        },

        new Command("examine", "examine [ address/count ] | [ address,address]", false) {

            Pattern args1 = Pattern.compile("^(0x[0-9a-f]+)(/([0-9]*)([a-z]*))?$");

            Pattern args2 = Pattern.compile("^(0x[0-9a-f]+),(0x[0-9a-f]+)(/[a-z]*)?$");

            String fill(Address a, int width) {

                String s = "0x0";

                if (a != null) {

                    s = a.toString();

                }

                if (s.length() != width) {

                    return s.substring(0, 2) + "000000000000000000000".substring(0, width - s.length()) + s.substring(2);

                }

                return s;

            }

            public void doit(Tokens t) {

                if (t.countTokens() != 1) {

                    usage();

                } else {

                    String arg = t.nextToken();

                    Matcher m1 = args1.matcher(arg);

                    Matcher m2 = args2.matcher(arg);

                    Address start = null;

                    Address end   = null;

                    String format = "";

                    int formatSize = (int)VM.getVM().getAddressSize();

                    if (m1.matches()) {

                        start = VM.getVM().getDebugger().parseAddress(m1.group(1));

                        int count = 1;

                        if (m1.group(2) != null) {

                            count = Integer.parseInt(m1.group(3));

                        }

                        end = start.addOffsetTo(count * formatSize);

                    } else if (m2.matches()) {

                        start = VM.getVM().getDebugger().parseAddress(m2.group(1));

                        end   = VM.getVM().getDebugger().parseAddress(m2.group(2));

                    } else {

                        usage();

                        return;

                    }

                    int line = 80;

                    int formatWidth = formatSize * 8 / 4 + 2;

                    out.print(fill(start, formatWidth));

                    out.print(": ");

                    int width = line - formatWidth - 2;

                    boolean needsPrintln = true;

                    while (start != null && start.lessThan(end)) {

                        Address val = start.getAddressAt(0);

                        out.print(fill(val, formatWidth));

                        needsPrintln = true;

                        width -= formatWidth;

                        start = start.addOffsetTo(formatSize);

                        if (width <= formatWidth) {

                            out.println();

                            needsPrintln = false;

                            if (start.lessThan(end)) {

                                out.print(fill(start, formatWidth));

                                out.print(": ");

                                width = line - formatWidth - 2;

                            }

                        } else {

                            out.print(" ");

                            width -= 1;

                        }

                    }

                    if (needsPrintln) {

                        out.println();

                    }

                }

            }

        },

        new Command("dumpreplaydata", "dumpreplaydata { <address > | -a | <thread_id> }", false) {

            // This is used to dump replay data from ciInstanceKlass, ciMethodData etc

            // default file name is replay.txt, also if java crashes in compiler

            // thread, this file will be dumped in error processing.

            public void doit(Tokens t) {

                if (t.countTokens() != 1) {

                    usage();

                    return;

                }

                String name = t.nextToken();

                Address a = null;

                try {

                    a = VM.getVM().getDebugger().parseAddress(name);

                } catch (NumberFormatException e) { }

                if (a != null) {