/*

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

 *

 *

 */

package sun.jvm.hotspot.ui.classbrowser;

import java.io.*;

import java.util.*;

import sun.jvm.hotspot.asm.*;

import sun.jvm.hotspot.asm.sparc.*;

import sun.jvm.hotspot.asm.x86.*;

import sun.jvm.hotspot.asm.ia64.*;

import sun.jvm.hotspot.code.*;

import sun.jvm.hotspot.compiler.*;

import sun.jvm.hotspot.debugger.*;

import sun.jvm.hotspot.interpreter.*;

import sun.jvm.hotspot.memory.*;

import sun.jvm.hotspot.oops.*;

import sun.jvm.hotspot.runtime.*;

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

import sun.jvm.hotspot.types.*;

import sun.jvm.hotspot.utilities.*;

public class HTMLGenerator implements /* imports */ ClassConstants {

    static class Formatter {

        boolean html;

        StringBuffer buf = new StringBuffer();

        Formatter(boolean h) {

            html = h;

        }

        void append(String s) {

            buf.append(s);

        }

        void append(int s) {

            buf.append(s);

        }

        void append(char s) {

            buf.append(s);

        }

        void append(StringBuffer s) {

            buf.append(s);

        }

        void append(Formatter s) {

            buf.append(s);

        }

        StringBuffer getBuffer() {

            return buf;

        }

        public String toString() {

            return buf.toString();

        }

        void wrap(String tag, String text) {

            wrap(tag, tag, text);

        }

        void wrap(String before, String after, String text) {

            beginTag(before);

            append(text);

            endTag(after);

        }

        // header tags

        void h1(String s) { nl(); wrap("h1", s); nl(); }

        void h2(String s) { nl(); wrap("h2", s); nl(); }

        void h3(String s) { nl(); wrap("h3", s); nl(); }

        void h4(String s) { nl(); wrap("h4", s); nl(); }

        // list tags

        void beginList()  { beginTag("ul"); nl(); }

        void endList()    { endTag("ul"); nl();   }

        void beginListItem() { beginTag("li"); }

        void endListItem()   { endTag("li"); nl();   }

        void li(String s) { wrap("li", s); nl();  }

        // table tags

        void beginTable(int border) {

            beginTag("table border='" + border + "'");

        }

        void cell(String s) { wrap("td", s); }

        void headerCell(String s) { wrap("th", s); }

        void endTable() { endTag("table"); }

        void link(String href, String text) {

            wrap("a href='" + href + "'", "a", text);

        }

        void beginTag(String s) {

            if (html) { append("<"); append(s); append(">"); }

        }

        void endTag(String s) {

            if (html) {

               append("</"); append(s); append(">");

            } else {

               if (s.equals("table") || s.equals("tr")) {

                  nl();

               }

               if (s.equals("td") || s.equals("th")) {

                  append(" ");

               }

            }

        }

        void bold(String s) {

            wrap("b", s);

        }

        void nl() {

            if (!html) buf.append("\n");

        }

        void br() {

            if (html) append("<br>");

            else      append("\n");

        }

        void genEmptyHTML() {

            if (html) append("<html></html>");

        }

        void genHTMLPrologue() {

            if (html) append("<html><body>");

        }

        void genHTMLPrologue(String title) {

            if (html) {

                append("<html><head><title>");

                append(title);

                append("</title></head>");

                append("<body>");

            }

            h2(title);

        }

        void genHTMLEpilogue() {

            if (html) append("</body></html>");

        }

    }

   private static final String DUMP_KLASS_OUTPUT_DIR = ".";

   private static final int NATIVE_CODE_SIZE = 200;

   private final String spaces;

   private final String tab;

   private boolean genHTML = true;

   public HTMLGenerator() {

       this(true);

   }

   public HTMLGenerator(boolean html) {

       genHTML = html;

       if (html) {

           spaces = "  ";

           tab = "    ";

       } else {

           spaces = "  ";

           tab = "    ";

       }

    }

   private static CPUHelper cpuHelper;

   static {

      VM.registerVMInitializedObserver(new Observer() {

         public void update(Observable o, Object data) {

            initialize();

         }

      });

   }

   private static synchronized void initialize() {

      String cpu = VM.getVM().getCPU();

      if (cpu.equals("sparc")) {

         cpuHelper = new SPARCHelper();

      } else if (cpu.equals("x86")) {

         cpuHelper = new X86Helper();

      } else if (cpu.equals("ia64")) {

         cpuHelper = new IA64Helper();

      } else {

          throw new RuntimeException("cpu '" + cpu + "' is not yet supported!");

      }

   }

   protected static synchronized CPUHelper getCPUHelper() {

      return cpuHelper;

   }

   protected String escapeHTMLSpecialChars(String value) {

      if (!genHTML) return value;

      Formatter buf = new Formatter(genHTML);

      int len = value.length();

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

         char c = value.charAt(i);

         switch (c) {

            case '<':

               buf.append("<");

               break;

            case '>':

               buf.append(">");

               break;

            case '&':

               buf.append("&");

               break;

            default:

               buf.append(c);

               break;

         }

      }

      return buf.toString();

   }

   public String genHTMLForMessage(String message) {

      Formatter buf = new Formatter(genHTML);

      buf.genHTMLPrologue(message);

      buf.genHTMLEpilogue();

      return buf.toString();

   }

   public String genHTMLErrorMessage(Exception exp) {

      exp.printStackTrace();

      return genHTMLForMessage(exp.getClass().getName() + " : " + exp.getMessage());

   }

   public String genHTMLForWait(String message) {

      Formatter buf = new Formatter(genHTML);

      buf.genHTMLPrologue("Please wait ..");

      buf.h2(message);

      return buf.toString();

   }

   protected String genKlassTitle(InstanceKlass klass) {

      Formatter buf = new Formatter(genHTML);

      AccessFlags acc = klass.getAccessFlagsObj();

      if (acc.isPublic()) {

         buf.append("public ");

      } else if (acc.isProtected()) {

         buf.append("protected ");

      } else if (acc.isPrivate()) {

         buf.append("private ");

      }

      if (acc.isStatic()) {

         buf.append("static ");

      }

      if (acc.isAbstract() ) {

         buf.append("abstract ");

      } else if (acc.isFinal()) {

         buf.append("final ");

      }

      if (acc.isStrict()) {

         buf.append("strict ");

      }

      // javac generated flags

      if (acc.isEnum()) {

         buf.append("[enum] ");

      }

      if (acc.isSynthetic()) {

         buf.append("[synthetic] ");

      }

      if (klass.isInterface()) {

         buf.append("interface");

      } else {

         buf.append("class");

      }

      buf.append(' ');

      buf.append(klass.getName().asString().replace('/', '.'));

      // is it generic?

      Symbol genSig = klass.getGenericSignature();

      if (genSig != null) {

         buf.append(" [signature ");

         buf.append(escapeHTMLSpecialChars(genSig.asString()));

         buf.append("] ");

      } else {

         buf.append(' ');

      }

      buf.append('@');

      buf.append(klass.getHandle().toString());

      return buf.toString();

   }

   protected String genBaseHref() {

      return "";

   }

   protected String genKlassHref(InstanceKlass klass) {

      return genBaseHref() + "klass=" + klass.getHandle();

   }

   protected String genKlassLink(InstanceKlass klass) {

      Formatter buf = new Formatter(genHTML);

      buf.link(genKlassHref(klass), genKlassTitle(klass));

      return buf.toString();

   }

   protected String genMethodModifierString(AccessFlags acc) {

      Formatter buf = new Formatter(genHTML);

      if (acc.isPrivate()) {

         buf.append("private ");

      } else if (acc.isProtected()) {

         buf.append("protected ");

      } else if (acc.isPublic()) {

         buf.append("public ");

      }

      if (acc.isStatic()) {

         buf.append("static ");

      } else if (acc.isAbstract() ) {

         buf.append("abstract ");

      } else if (acc.isFinal()) {

         buf.append("final ");

      }

       if (acc.isNative()) {

         buf.append("native ");

      }

      if (acc.isStrict()) {

         buf.append("strict ");

      }

      if (acc.isSynchronized()) {

         buf.append("synchronized ");

      }

      // javac generated flags

      if (acc.isBridge()) {

         buf.append("[bridge] ");

      }

      if (acc.isSynthetic()) {

         buf.append("[synthetic] ");

      }

      if (acc.isVarArgs()) {

         buf.append("[varargs] ");

      }

      return buf.toString();

   }

   protected String genMethodNameAndSignature(Method method) {

      Formatter buf = new Formatter(genHTML);

      buf.append(genMethodModifierString(method.getAccessFlagsObj()));

      Symbol sig = method.getSignature();

      new SignatureConverter(sig, buf.getBuffer()).iterateReturntype();

      buf.append(" ");

      String methodName = method.getName().asString();

      buf.append(escapeHTMLSpecialChars(methodName));

      buf.append('(');

      new SignatureConverter(sig, buf.getBuffer()).iterateParameters();

      buf.append(')');

      // is it generic?

      Symbol genSig = method.getGenericSignature();

      if (genSig != null) {

         buf.append(" [signature ");

         buf.append(escapeHTMLSpecialChars(genSig.asString()));

         buf.append("] ");

      }

      return buf.toString().replace('/', '.');

   }

   protected String genMethodTitle(Method method) {

      Formatter buf = new Formatter(genHTML);

      buf.append(genMethodNameAndSignature(method));

      buf.append(' ');

      buf.append('@');

      buf.append(method.getHandle().toString());

      return buf.toString();

   }

   protected String genMethodHref(Method m) {

      return genBaseHref() + "method=" + m.getHandle();

   }

   protected String genMethodLink(Method m) {

      Formatter buf = new Formatter(genHTML);

      buf.link(genMethodHref(m), genMethodTitle(m));

      return buf.toString();

   }

   protected String genMethodAndKlassLink(Method m) {

      Formatter buf = new Formatter(genHTML);

      buf.append(genMethodLink(m));

      buf.append(" of ");

      buf.append(genKlassLink((InstanceKlass) m.getMethodHolder()));

      return buf.toString();

   }

   protected String genNMethodHref(NMethod nm) {

      return genBaseHref() + "nmethod=" + nm.getAddress();

   }

   public String genNMethodTitle(NMethod nmethod) {

      Formatter buf = new Formatter(genHTML);

      Method m = nmethod.getMethod();

      buf.append("Disassembly for compiled method [");

      buf.append(genMethodTitle(m));

      buf.append(" ] ");

      buf.append('@');

      buf.append(nmethod.getAddress().toString());

      return buf.toString();

   }

   protected String genNMethodLink(NMethod nm) {

      Formatter buf = new Formatter(genHTML);

      buf.link(genNMethodHref(nm), genNMethodTitle(nm));

      return buf.toString();

   }

   public String genCodeBlobTitle(CodeBlob blob) {

      Formatter buf = new Formatter(genHTML);

      buf.append("Disassembly for code blob " + blob.getName() + " [");

      buf.append(blob.getClass().getName());

      buf.append(" ] @");

      buf.append(blob.getAddress().toString());

      return buf.toString();

   }

   protected BytecodeDisassembler createBytecodeDisassembler(Method m) {

      return new BytecodeDisassembler(m);

   }

   private String genLowHighShort(int val) {

      Formatter buf = new Formatter(genHTML);

      buf.append('#');

      buf.append(Integer.toString(val & 0xFFFF));

      buf.append(" #");

      buf.append(Integer.toString((val >> 16) & 0xFFFF));

      return buf.toString();

   }

   protected String genHTMLTableForConstantPool(ConstantPool cpool) {

      Formatter buf = new Formatter(genHTML);

      buf.beginTable(1);

      buf.beginTag("tr");

      buf.headerCell("Index");

      buf.headerCell("Constant Type");

      buf.headerCell("Constant Value");

      buf.endTag("tr");

      final int length = (int) cpool.getLength();

      // zero'th pool entry is always invalid. ignore it.

      for (int index = 1; index < length; index++) {

         buf.beginTag("tr");

         buf.cell(Integer.toString(index));

         int ctag = (int) cpool.getTags().getByteAt((int) index);

         switch (ctag) {

            case JVM_CONSTANT_Integer:

               buf.cell("JVM_CONSTANT_Integer");

               buf.cell(Integer.toString(cpool.getIntAt(index)));

               break;

            case JVM_CONSTANT_Float:

               buf.cell("JVM_CONSTANT_Float");

               buf.cell(Float.toString(cpool.getFloatAt(index)));

               break;

            case JVM_CONSTANT_Long:

               buf.cell("JVM_CONSTANT_Long");

               buf.cell(Long.toString(cpool.getLongAt(index)));

               // long entries occupy two slots

               index++;

               break;

            case JVM_CONSTANT_Double:

               buf.cell("JVM_CONSTANT_Double");

               buf.cell(Double.toString(cpool.getDoubleAt(index)));

               // double entries occupy two slots

               index++;

               break;

            case JVM_CONSTANT_UnresolvedClass:

               buf.cell("JVM_CONSTANT_UnresolvedClass");

               buf.cell(cpool.getSymbolAt(index).asString());

               break;

            case JVM_CONSTANT_UnresolvedClassInError:

               buf.cell("JVM_CONSTANT_UnresolvedClassInError");

               buf.cell(cpool.getSymbolAt(index).asString());

               break;

            case JVM_CONSTANT_Class:

               buf.cell("JVM_CONSTANT_Class");

               Klass klass = (Klass) cpool.getObjAt(index);

               if (klass instanceof InstanceKlass) {

                  buf.cell(genKlassLink((InstanceKlass) klass));

               } else {

                  buf.cell(klass.getName().asString().replace('/', '.'));

               }

               break;

            case JVM_CONSTANT_UnresolvedString:

               buf.cell("JVM_CONSTANT_UnresolvedString");

               buf.cell("\"" +