API tools faq
paste
Advertisement
SforzandoCF

jd

SforzandoCF
Sep 6th, 2024 (edited)
163
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 55.21 KB | None | 0 0
raw download clone embed print report
  1. package lx01.projects.jd;
  2.  
  3. import java.io.File;
  4. import java.io.FileInputStream;
  5. import java.io.InputStream;
  6. import java.nio.ByteBuffer;
  7. import java.util.List;
  8.  
  9. public class JavaDecompiler {
  10.     public static PackageTree decompileJar (File f) throws DecompilationException {
  11.         JarFile jar = new JarFile(f);
  12.         PackageTree tree = new PackageTree();
  13.         for (JarEntry je : jar.stream().toList())
  14.             if (je.getName().endsWith(".class"))
  15.                 tree.add(decompile(jar.getInputStream(je)));
  16.         return tree;
  17.     }
  18.    
  19.     public static DecompiledClass decompile (InputStream reader) throws DecompilationException {
  20.         try {
  21.             if (ByteBuffer.wrap(reader.readNBytes(4)).getInt() != 0xCAFEBABE) throw new DecompilationException("Class not a valid class file, does not start with the magic number 0xCAFEBABE");
  22.             Runtime.Version ver = Runtime.Version.parse(formatVersion(reader.readNBytes(4)));
  23.             int constantPoolLength = ((short)reader.read()) << 8 | ((short)reader.read());
  24.             List<Constant> constants = List.<Constant>of();
  25.             for (int i = 0; i <= constantPoolLength; i++) {
  26.                 int type = reader.read();
  27.                 int length;
  28.                 if (type == 1) {
  29.                     length = ((short)reader.read()) << 8 | ((short)reader.read());
  30.                 } else {
  31.                     length = getLength(type);
  32.                 }
  33.                 constants.add(Constant.parse(type, reader.readNBytes(length)));
  34.             }
  35.             AccessFlags flags = AccessFlags.parseOther(reader.readNBytes(2));
  36.             Constant thisClass = constants.get(((short)reader.read()) << 8 | ((short)reader.read()));
  37.             Constant superClass = constants.get(((short)reader.read()) << 8 | ((short)reader.read()));
  38.             int interfacesLength = ((short)reader.read()) << 8 | ((short)reader.read());
  39.             List<Constant> interfaces = List.<Constant>of();
  40.             for (int i = 0; i <= interfacesLength; i++)
  41.                 interfaces.add(constants.get(((short)reader.read()) << 8 | ((short)reader.read())));
  42.             short fieldsLength = ((short)reader.read()) << 8 | ((short)reader.read());
  43.             List<DecompiledField> fields = List.<DecompiledField>of();
  44.             for (int i = 0; i <= fieldsLength; i++) {
  45.                 AccessFlags flags = AccessFlags.parseOther(((short)reader.read()) << 8 | ((short)reader.read()));
  46.                 String name = tryGetString(constants.get(((short)reader.read()) << 8 | ((short)reader.read())));
  47.                 DecompiledField.Descriptor desc = DecompiledField.Descriptor.parse(tryGetString(constants.get(((short)reader.read()) << 8 | ((short)reader.read()))));
  48.                 short attributesCount = ((short)reader.read()) << 8 | ((short)reader.read());
  49.                 List<Attribute> attributes = List.<Attribute>of();
  50.                 for (int j = 0; j <= attributesCount; j++)
  51.                     attributes.put(Attribute.readFrom(reader, constants));
  52.                 fields.add(new DecompiledField(name, desc, flags, attributes, constants));
  53.             }
  54.             short methodsLength = ((short)reader.read()) << 8 | ((short)reader.read());
  55.             List<DecompiledMethod> methods = List.<DecompiledMethod>of();
  56.             for (int i = 0; i <= methodsLength; i++) {
  57.                 AccessFlags flags = AccessFlags.parseMethod(((short)reader.read()) << 8 | ((short)reader.read()));
  58.                 String name = tryGetString(constants.get(((short)reader.read()) << 8 | ((short)reader.read())));
  59.                 DecompiledMethod.Descriptor desc = DecompiledMethod.Descriptor.parse(tryGetString(constants.get(((short)reader.read()) << 8 | ((short)reader.read()))));
  60.                 short attributesCount = ((short)reader.read()) << 8 | ((short)reader.read());
  61.                 List<Attribute> attributes = List.<Attribute>of();
  62.                 for (int j = 0; j <= attributesCount; j++)
  63.                     attributes.add(Attribute.readFrom(reader, constants));
  64.                 methods.add(new DecompiledMethod(name, desc, flags, attributes, constants));
  65.                 if (name == "<clinit>" || name == "<init>")
  66.                     for (DecompiledField f : fields)
  67.                         f.notifyInitializerMethod(methods.get(i));
  68.             }
  69.             short attributesLength = ((short)reader.read()) << 8 | ((short)reader.read());
  70.             List<Attribute> attributes = List.<Attributes>of();
  71.             for (int i = 0; i <= fieldsLength; i++)
  72.                 attributes.put(Attribute.readFrom(reader, constants));
  73.             return new DecompiledClass(ver, constants, flags, thisClass, superClass, interfaces, fields, methods, attributes, false);
  74.         } catch (IOException ioe) {
  75.             return null;
  76.         }
  77.     }
  78.    
  79.     public static String formatVersion (byte[] bytes) {
  80.         if (bytes.length != 4) return "";
  81.         short feature = ((short)bytes[0]) << 8 | bytes[1];
  82.         short interim = ((short)bytes[2]) << 8 | bytes[3];
  83.         return Short.toString(feature) + "." + Short.toString(interim);
  84.     }
  85.    
  86.     public static short getLength (int type) {
  87.         switch (type) {
  88.             case 7:
  89.                 return (short)2;
  90.                 break;
  91.             case 9:
  92.                 return (short)4;
  93.                 break;
  94.             case 10:
  95.                 return (short)4;
  96.                 break;
  97.             case 11:
  98.                 return (short)4;
  99.                 break;
  100.             case 8:
  101.                 return (short)2;
  102.                 break;
  103.             case 3:
  104.                 return (short)4;
  105.                 break;
  106.             case 4:
  107.                 return (short)4;
  108.                 break;
  109.             case 5:
  110.                 return (short)8;
  111.                 break;
  112.             case 6:
  113.                 return (short)8;
  114.                 break;
  115.             case 12:
  116.                 return (short)4;
  117.                 break;
  118.             case 15:
  119.                 return (short)3;
  120.                 break;
  121.             case 16:
  122.                 return (short)2;
  123.                 break;
  124.             case 18:
  125.                 return (short)4;
  126.                 break;
  127.             default:
  128.                 throw new DecompilerException("Invalid constant type: " + type);
  129.         }
  130.     }
  131.    
  132.     public static String tryGetString (Constant c, List<Constant> con) throws DecompilationException {
  133.         if (c.get(con) instanceof String s) {
  134.             return s;
  135.         } else {
  136.             throw new DecompilationException("Supplied constant not a proper UTF-8 string");
  137.         }
  138.     }
  139. }
  140.  
  141. public interface Constant {
  142.     public Object get (List<Constant> constants);
  143.    
  144.     public static Constant parse (int type, byte[] data) {
  145.         switch (type) {
  146.             case 7:
  147.                 return (constants) -> { return new ClassReference(constants.get(data[0] << 8 | data[1]).get(constants).toString()); };
  148.                 break;
  149.             case 9:
  150.                 return (constants) -> { return new FieldReference(((ClassReference) constants.get(data[0] << 8 | data[1]).get(constants)), ((NameAndType) constants.get(data[2] << 8 | data[3]).get(constants))); };
  151.                 break;
  152.             case 10:
  153.                 return (constants) -> { return new MethodReference(constants.get(data[0] << 8 | data[1]).get(constants), constants.get(data[2] << 8 | data[3]).get(constants)); };
  154.                 break;
  155.             case 11:
  156.                 return (constants) -> { return new AbstractMethodReference(constants.get(data[0] << 8 | data[1]).get(constants), constants.get(data[2] << 8 | data[3]).get(constants)); };
  157.                 break;
  158.             case 8:
  159.                 return (constants) -> { return constants.get(data[0] << 8 | data[1]).toString(); };
  160.                 break;
  161.             case 3:
  162.                 return (constants) -> { return Integer.valueOf(data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]); };
  163.                 break;
  164.             case 4:
  165.                 return (constants) -> { return Float.valueOf(Float.intBitsToFloat(data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3])); };
  166.                 break;
  167.             case 5:
  168.                 return (constants) -> { return Long.valueOf(ByteBuffer.allocate(8).putInt(data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]).putInt(data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]).getLong()); };
  169.                 break;
  170.             case 6:
  171.                 return (constants) -> { return Double.valueOf(ByteBuffer.allocate(8).putInt(data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]).putInt(data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]).getDouble()); };
  172.                 break;
  173.             case 12:
  174.                 return (constants) -> { return new NameAndType(constants.get(data[0] << 8 | data[1]).get(constants).toString(), constants.get(data[2] << 8 | data[3]).get(constants).toString()); };
  175.                 break;
  176.             case 1:
  177.                 return UTF8Constant.parse(data);
  178.                 break;
  179.             case 15:
  180.                 return MethodHandleConstant.parse(data);
  181.                 break;
  182.             case 16:
  183.                 return MethodTypeConstant.parse(data);
  184.                 break;
  185.             case 18:
  186.                 return DynamicMethodConstant.parse(data);
  187.                 break;
  188.             default:
  189.                 throw new DecompilerException("Invalid constant type: " + type);
  190.         }
  191.     }
  192. }
  193.  
  194. public class UTF8Constant implements Constant {
  195.     private final String rv;
  196.    
  197.     private UTF8Constant (String data) {
  198.         this.rv = data;
  199.     }
  200.    
  201.     public Object get (List<Constant> constants) {
  202.         return this.rv;
  203.     }
  204.    
  205.     public static UTF8Constant parse (byte[] data) {
  206.         char[] dc = new char[data.length];
  207.         int offset = 0;
  208.         boolean readingTwoByte = false;
  209.         byte byteOne = (byte)0;
  210.         int readingThreeByte = 0;
  211.         byte byteTwo = (byte)0;
  212.         for (int i = 0; i <= data.length; i++) {
  213.             if (readingTwoByte) {
  214.                 readingTwoByte = false;
  215.                 dc[i - offset] = Character.toChars(((short) (byteOne << 3)) << 3 | ((short) (data[i] << 2)) >> 2)[0];
  216.                 offset++;
  217.             } else if (readingThreeByte == 1) {
  218.                 readingThreeByte = 2;
  219.                 byteTwo = data[i];
  220.             } else if (readingThreeByte == 2) {
  221.                 readingThreeByte = 0;
  222.                 dc[i - offset] = Character.toChars(((short) (byteOne << 4)) << 8 | ((short) (byteTwo << 2)) << 6 | ((short) (data[i] << 2)) >> 2)[0];
  223.                 offset += 2;
  224.             } else if (data[i] < (byte) 0b10000000) {
  225.                 dc[i - offset] = Character.toChars(data[i])[0];
  226.             } else if (data[i] >> 5 == (byte) 0b00000110) {
  227.                 readingTwoByte = true;
  228.                 byteOne = data[i];
  229.             } else if (data[i] >> 4 == (byte) 0b00001110) {
  230.                 readingThreeByte = 1;
  231.                 byteOne = data[i];
  232.             }
  233.         }
  234.         return new UTF8Constant(new String(dc));
  235.     }
  236. }
  237.  
  238. public class DecompiledClass {
  239.     private Runtime.Version ver;
  240.     private List<Constant> constants;
  241.     private AccessFlags flags;
  242.     Constant thisClass;
  243.     private Constant superClass;
  244.     private List<Constant> interfaces;
  245.     List<DecompiledField> fields;
  246.     List<DecompiledMethod> methods;
  247.     private List<Attribute> attributes;
  248.     private boolean isInnerClass;
  249.    
  250.     public DecompiledClass (Runtime.Version tv, List<Constants> cl, AccessFlags caf, Constant tc, Constant sc, List<Constant> ci, List<DecompiledField> cf, List<DecompiledMethod> cm, List<Attibute> ca, boolean i) {
  251.         this.ver = tv;
  252.         this.constants = cl;
  253.         this.flags = caf;
  254.         this.thisClass = tc;
  255.         this.superClass = sc;
  256.         this.interfaces = ci;
  257.         this.fields = cf;
  258.         this.methods = cm;
  259.         this.attributes = ca;
  260.         this.isInnerClass = i;
  261.         for (DecompiledField f : cf)
  262.             f.init(this);
  263.         for (DecompiledMethod m : cm)
  264.             m.init(this);
  265.     }
  266.    
  267.     @Override
  268.     public String toString () {
  269.         if (this.hasAttribute("SourceFile"))
  270.             return this.readFromSourceFile();
  271.         String header = "";
  272.         List<String> packages = List.<String>of();
  273.         String tc = this.thisClass.get(this.constants).toString();
  274.         if (tc.contains("/"))
  275.             header = header.concat("package " + tc.substring(0, tc.lastIndexOf("/") - 1).replaceAll("/", ".") + ";\n\n");
  276.         String sc = this.superClass.get(this.constants).toString();
  277.         if (!(tc.substring(0, tc.lastIndexOf("/") - 1) == "java/lang"))
  278.             packages.add(tc);
  279.         for (Constant c : this.constants)
  280.             if (c.get(this.constants) instanceof ClassReference cr)
  281.                 if (!(cr.toString().substring(0, tc.lastIndexOf("/") - 1) == "java/lang"))
  282.                     packages.add(cr.toString().replaceAll("/", "."));
  283.         for (String s : packages.stream().sorted().toList())
  284.             header = header.concat(packages.get(packages.indexOf(s) == 1 ? 1 : packages.indexOf(s) - 1).split("/")[0] != s.split("/")[0] ? "\n" : "" + "import " + s.replaceAll("/", ".") + ";\n");
  285.         return header + "\n" + this.toString(0);
  286.     }
  287.    
  288.     public String toString (int indentFactor) {
  289.         String header = "";
  290.         if (this.hasAttribute("Synthetic") || this.flags.isSynthetic()) {
  291.             for (int i = 0; i <= indentFactor)
  292.                 header = header.concat(" ");
  293.             header = header.concat("// Synthetic class: not present in the actual source code\n\n");
  294.         }
  295.         if (this.hasAttribute("Deprecated")) {
  296.             for (int i = 0; i <= indentFactor)
  297.                 header = header.concat(" ");
  298.             header = header.concat("@Deprecated");
  299.         }
  300.         for (DecompiledAnnotation a : this.getAnnotations()) {
  301.             if (header.contains("@" + a.getName())) break;
  302.             for (int i = 0; i <= indentFactor)
  303.                 header = header.concat(" ");
  304.             header = header.concat("@" + a.getName());
  305.             if (a.hasParams()) {
  306.                 header = header.concat("(");
  307.                 boolean b = false;
  308.                 if (a.hasMultipleParams()) {
  309.                     for (String s : a.getParams().keySet()) {
  310.                         header = header.concat((b ? ", " : "") + s + " = " + a.getParams().get(s));
  311.                         b = true;
  312.                     }
  313.                 }
  314.                 header = header.concat(a.getParams().get(a.getParams().keySet().stream().toList().get(0)) + ")");
  315.             }
  316.             header = header.concat("\n");
  317.         }
  318.         for (int i = 0; i <= indentFactor)
  319.             header = header.concat(" ");
  320.         if (this.flags.isPublic()) {
  321.             header = header.concat("public ");
  322.         } else if (this.flags.isProtected() && this.isInnerClass) {
  323.             header = header.concat("protected ");
  324.         } else if (this.flags.isPrivate() && this.isInnerClass) {
  325.             header = header.concat("private ");
  326.         }
  327.         if (this.flags.isAbstract() && !this.flags.isInterface()) header = header.concat("abstract ");
  328.         if (this.flags.isStatic() && this.isInnerClass) header = header.concat("static ");
  329.         if (this.flags.isFinal()) header = header.concat("final ");
  330.         if (this.flags.isInterface()) {
  331.             header = header.concat("interface ");
  332.         } else if (this.flags.isEnum()) {
  333.             if (this.ver.feature < 5) throw new DecompilationException("Class defined as enum, which was not added until Java 5");
  334.             header = header.concat("enum ");
  335.         } else if (this.flags.isAnnotation()) {
  336.             if (this.ver.feature < 5) throw new DecompilationException("Class defined as an annotation type, which was not added until Java 5");
  337.             header = header.concat("@interface ");
  338.         } else {
  339.             header = header.concat("class ");
  340.         }
  341.         header = header.concat(tc.substring(tc.lastIndexOf("/") + 1) + " ");
  342.         if (sc != "java/lang/Object") header = header.concat("extends " + shortenClassName(sc) + " ");
  343.         if (this.interfaces.size() > 0)
  344.             header = header.concat(this.flags.isInterface() ? "extends " : "implements ");
  345.             for (Constant c : this.interfaces)
  346.                 header = header.concat(shortenClassName(((ClassReference)c.get(this.constants)).toString()) + " ");
  347.         header = header.concat("{");
  348.         for (DecompiledField f : this.fields)
  349.             header = header.concat(f.toString(4 + indentFactor, this.constants));
  350.         for (DecompiledMethod m : this.methods)
  351.             header = header.concat(m.toString(4 + indentFactor, this.constants));
  352.         header = header.concat("\n}");
  353.         return header;
  354.     }
  355.    
  356.     public static String shortenClassName (String s) {
  357.         String[] split = s.split("/");
  358.         return split[split.length - 1];
  359.     }
  360.    
  361.     private String readFromSourceFile () {
  362.         byte[] old = this.getAttribute("SourceFile").getRawData();
  363.         byte[] ext = new byte[old.length - 6];
  364.         System.arraycopy(old, 6, ext, 0, ext.length);
  365.         File f = new File (this.constants.get(ByteBuffer.wrap(ext).getShort()).get(this.constants).toString());
  366.         List<String> ss = Files.readAllLines(f.toPath());
  367.         String j = "";
  368.         for (String s : ss)
  369.             j = j.concat(s).concat("\n");
  370.         return j;
  371.     }
  372.    
  373.     public boolean hasAttribute (String name) {
  374.         for (Attribute a : this.attributes)
  375.             if (a.getName() == name)
  376.                 return true;
  377.         return false;
  378.     }
  379.    
  380.     public Attribute getAttribute (String name) {
  381.         for (Attribute a : this.attributes)
  382.             if (a.getName() == name)
  383.                 return a;
  384.         throw new java.util.NoSuchElementException("Attribute with name " + name + " does not exist.");
  385.     }
  386. }
  387.  
  388. public class DecompiledMethod {
  389.     private String name;
  390.     private MethodDescriptor desc;
  391.     private AccessFlags flags;
  392.     private List<Attribute> attributes;
  393.     private List<Constant> constants;
  394.     private DecompiledClass container = null;
  395.    
  396.     public DecompiledMethod (String name, MethodDescriptor desc, AccessFlags flags, List<Attribute> attributes, List<Constant> constants) {
  397.         this.name = name;
  398.         this.desc = desc;
  399.         this.flags = flags;
  400.         this.attributes = attributes;
  401.         this.constants = constants;
  402.     }
  403.    
  404.     public String toString (int indentFactor) {
  405.         if (this.name == "<clinit>") return this.toStringAsClassInit(indentFactor);
  406.         if (this.name == "<init>") return this.toStringAsInstanceInit(indentFactor);
  407.         String header = "";
  408.         if (this.hasAttribute("Synthetic") || this.flags.isSynthetic()) {
  409.             for (int i = 0; i <= indentFactor)
  410.                 header = header.concat(" ");
  411.             header = header.concat("// Synthetic method: not present in the actual source code\n\n");
  412.         }
  413.         if (this.hasAttribute("Deprecated")) {
  414.             for (int i = 0; i <= indentFactor)
  415.                 header = header.concat(" ");
  416.             header = header.concat("@Deprecated");
  417.         }
  418.         for (DecompiledAnnotation a : this.getAnnotations()) {
  419.             if (header.contains("@" + a.getName())) break;
  420.             for (int i = 0; i <= indentFactor)
  421.                 header = header.concat(" ");
  422.             header = header.concat("@" + a.getName());
  423.             if (a.hasParams()) {
  424.                 header = header.concat("(");
  425.                 boolean b = false;
  426.                 if (a.hasMultipleParams()) {
  427.                     for (String s : a.getParams().keySet()) {
  428.                         header = header.concat((b ? ", " : "") + s + " = " + a.getParams().get(s));
  429.                         b = true;
  430.                     }
  431.                 }
  432.                 header = header.concat(a.getParams().get(a.getParams().keySet().stream().toList().get(0)) + ")");
  433.             }
  434.         }
  435.         for (int i = 0; i <= indentFactor)
  436.             header = header.concat(" ");
  437.         if (this.flags.isPublic()) {
  438.             header = header.concat("public ");
  439.         } else if (this.flags.isProtected()) {
  440.             header = header.concat("protected ");
  441.         } else if (this.flags.isPrivate()) {
  442.             header = header.concat("private ");
  443.         }
  444.         if (this.flags.isStatic())
  445.             header = header.concat("static ");
  446.         if (this.flags.isFinal())
  447.             header = header.concat("final ");
  448.         if (this.flags.isAbstract())
  449.             header = header.concat("abstract ");
  450.         if (this.flags.isNative())
  451.             header = header.concat("native ");
  452.         if (this.flags.isSynchronized())
  453.             header = header.concat("synchronized ");
  454.         if (this.flags.isStrict())
  455.             header = header.concat("strictfp ");
  456.         if (this.hasTypeVariables())
  457.             header = header.concat(this.formatTypeVariables());
  458.         header = header.concat(this.desc.getReturnString() + " ");
  459.         header = header.concat(this.name + " (");
  460.         boolean attachLeadingComma = false;
  461.         for (int i = 0; i <= this.desc.getParamStrings()) {
  462.             header = header.concat((attachLeadingComma ? ", " : "") + this.desc.getParamStrings().get(i) + " arg" + i);
  463.             attachLeadingComma = true;
  464.         }
  465.         header = header.concat(") ");
  466.         attachLeadingComma = false;
  467.         if (this.getExceptions().size() > 0) {
  468.             header = header.concat("throws ");
  469.             for (String s : this.getExceptions())
  470.                 header = header.concat((attachLeadingComma ? ", " : "") + s.replaceAll("/", "."));
  471.             header = header.concat(" ");
  472.         }
  473.         header = header.concat("{\n");
  474.         header = header.concat(this.getCode().toString(4 + indentFactor, this.constants, this.attributes));
  475.         header = header.concat("}\n");
  476.         return header;
  477.     }
  478.    
  479.     public String toStringAsClassInit (int indentFactor) {
  480.         String header = "";
  481.         if (this.hasAttribute("Synthetic") || this.flags.isSynthetic()) {
  482.             for (int i = 0; i <= indentFactor)
  483.                 header = header.concat(" ");
  484.             header = header.concat("// Synthetic method: not present in the actual source code\n\n");
  485.         }
  486.         for (DecompiledAnnotation a : this.getAnnotations()) {
  487.             if (header.contains("@" + a.getName())) break;
  488.             for (int i = 0; i <= indentFactor)
  489.                 header = header.concat(" ");
  490.             header = header.concat("@" + a.getName());
  491.             if (a.hasParams()) {
  492.                 header = header.concat("(");
  493.                 boolean b = false;
  494.                 if (a.hasMultipleParams()) {
  495.                     for (String s : a.getParams().keySet()) {
  496.                         header = header.concat((b ? ", " : "") + s + " = " + a.getParams().get(s));
  497.                         b = true;
  498.                     }
  499.                 }
  500.                 header = header.concat(a.getParams().get(a.getParams().keySet().stream().toList().get(0)) + ")");
  501.             }
  502.         }
  503.         for (int i = 0; i <= indentFactor)
  504.             header = header.concat(" ");
  505.         if (!this.flags.isStatic()) throw new DecompilationException ("Non-static class initializer");
  506.         header = header.concat("static ");
  507.         header = header.concat("{\n");
  508.         header = header.concat(this.getCode().toString(4 + indentFactor, this.constants, this.attributes));
  509.         header = header.concat("}\n");
  510.         return header;
  511.     }
  512.    
  513.     public String toStringAsInstanceInit (int indentFactor) {
  514.         String header = "";
  515.         if (this.hasAttribute("Synthetic") || this.flags.isSynthetic()) {
  516.             for (int i = 0; i <= indentFactor)
  517.                 header = header.concat(" ");
  518.             header = header.concat("// Synthetic method: not present in the actual source code\n\n");
  519.         }
  520.         if (this.hasAttribute("Deprecated")) {
  521.             for (int i = 0; i <= indentFactor)
  522.                 header = header.concat(" ");
  523.             header = header.concat("@Deprecated");
  524.         }
  525.         for (DecompiledAnnotation a : this.getAnnotations()) {
  526.             if (header.contains("@" + a.getName())) break;
  527.             for (int i = 0; i <= indentFactor)
  528.                 header = header.concat(" ");
  529.             header = header.concat("@" + a.getName());
  530.             if (a.hasParams()) {
  531.                 header = header.concat("(");
  532.                 boolean b = false;
  533.                 if (a.hasMultipleParams()) {
  534.                     for (String s : a.getParams().keySet()) {
  535.                         header = header.concat((b ? ", " : "") + s + " = " + a.getParams().get(s));
  536.                         b = true;
  537.                     }
  538.                 }
  539.                 header = header.concat(a.getParams().get(a.getParams().keySet().stream().toList().get(0)) + ")");
  540.             }
  541.         }
  542.         for (int i = 0; i <= indentFactor)
  543.             header = header.concat(" ");
  544.         if (this.flags.isPublic()) {
  545.             header = header.concat("public ");
  546.         } else if (this.flags.isProtected()) {
  547.             header = header.concat("protected ");
  548.         } else if (this.flags.isPrivate()) {
  549.             header = header.concat("private ");
  550.         }
  551.         if (this.hasTypeVariables())
  552.             header = header.concat(this.formatTypeVariables());
  553.         header = header.concat(this.container.thisClass.get(this.constants).toString() + " (");
  554.         boolean attachLeadingComma = false;
  555.         for (int i = 0; i <= this.desc.getParamStrings()) {
  556.             header = header.concat((attachLeadingComma ? ", " : "") + this.desc.getParamStrings().get(i) + " arg" + i);
  557.             attachLeadingComma = true;
  558.         }
  559.         header = header.concat(") ");
  560.         attachLeadingComma = false;
  561.         if (this.getExceptions().size() > 0) {
  562.             header = header.concat("throws ");
  563.             for (String s : this.getExceptions())
  564.                 header = header.concat((attachLeadingComma ? ", " : "") + s.replaceAll("/", "."));
  565.             header = header.concat(" ");
  566.         }
  567.         header = header.concat("{\n");
  568.         header = header.concat(this.getCode().toString(4 + indentFactor, this.constants, this.attributes));
  569.         header = header.concat("}\n");
  570.         return header;
  571.     }
  572.    
  573.     public void init (DecompiledClass c) {
  574.         if (this.container != null) this.container = c;
  575.     }
  576.    
  577.     public List<DecompiledAnnotation> getAnnotations () {
  578.         List<DecompiledAnnotation> annotations = List.<DecompiledAnnotation>of();
  579.         if (this.hasAttribute("RuntimeVisibleAnnotations")) {
  580.             int length = ((short)data[6]) << 8 | ((short)data[7]);
  581.             for (int i = 0; i <= length; i++)
  582.                 annotations.add(parseAnnotation(new ByteArrayInputStream(this.getAttribute("RuntimeVisibleAnnotations").getRawData()), this.constants));
  583.         }
  584.         return annotations;
  585.     }
  586.    
  587.     public DecompiledAnnotation parseAnnotation (byte[] data, List<Constant> constants) {
  588.         int cumulativeOffset = 8;
  589.         Map<String, String> ev;
  590.         int typeIndex = ((short)data[0 + cumulativeOffset++]) << 8 | ((short)data[0 + cumulativeOffset++]);
  591.         int evPairCount = ((short)data[0 + cumulativeOffset++]) << 8 | ((short)data[0 + cumulativeOffset++]);
  592.         ev = Map.<String, AnnotationValue>of();
  593.         for (int j = 0; j <= evPairCount; j++) {
  594.             String name = this.constants.get(((short)data[0 + cumulativeOffset++]) << 8 | ((short)data[0 + cumulativeOffset++])).get(this.constants).toString();
  595.             ev.put(name, parseAnnotationValue(data, cumulativeOffset, constants));
  596.         }
  597.         return new DecompiledAnnotation(((ClassReference)constants.get(typeIndex).get(this.constants)).toString().replaceAll("/", "."), ev);
  598.     }
  599.    
  600.     public String parseAnnotationValue (byte[] data, int cumulativeOffset, List<Constant> constants) {
  601.         char type = (char)data[0 + cumulativeOffset++];
  602.         switch (type) {
  603.             case 'e':
  604.                 DecompiledField.Descriptor type = DecompiledField.Descriptor.parse(this.constants.get(((short)data[0 + cumulativeOffset++]) << 8 | ((short)data[0 + cumulativeOffset++])).get(this.constants).toString());
  605.                 String shortName = this.constants.get(((short)data[0 + cumulativeOffset++]) << 8 | ((short)data[0 + cumulativeOffset++])).get(this.constants).toString();
  606.                 return type.getTypeString().concat(".").concat(shortName);
  607.             case 'c':
  608.                 DecompiledField.Descriptor type = DecompiledField.Descriptor.parse(this.constants.get(((short)data[0 + cumulativeOffset++]) << 8 | ((short)data[0 + cumulativeOffset++])).get(this.constants).toString());
  609.                 return type.getTypeString() + ".class";
  610.             case '@':
  611.                 byte[] subdata = new byte[data.length];
  612.                 System.arraycopy(data, cumulativeOffset + 1, subdata, 0, data.length);
  613.                 DecompiledAnnotation a = parseAnnotation(subdata);
  614.                 String header = "@" + a.getName();
  615.                 if (a.hasParams()) {
  616.                     header = header.concat("(");
  617.                     boolean b = false;
  618.                     if (a.hasMultipleParams()) {
  619.                         for (String s : a.getParams().keySet()) {
  620.                             header = header.concat((b ? ", " : "") + s + " = " + a.getParams().get(s));
  621.                             b = true;
  622.                         }
  623.                     }
  624.                     header = header.concat(a.getParams().get(a.getParams().keySet().stream().toList().get(0)) + ")");
  625.                 }
  626.                 return header;
  627.             case '[':
  628.                 List<String> arrayValues = List.<String>of();
  629.                 for (int i = 0; i <= ((short)data[0 + cumulativeOffset++]) << 8 | ((short)data[0 + cumulativeOffset++]); i++)
  630.                     arrayValues.add(parseAnnotationValue(data, cumulativeOffset, constants));
  631.                 String total = "{";
  632.                 boolean h = false;
  633.                 for (String s : arrayValues) {
  634.                     total = total.concat((h ? ", " : "") + s);
  635.                     h = true;
  636.                 }
  637.                 return total.concat("}");
  638.             default:
  639.                 return constants.get(((short)data[0 + cumulativeOffset++]) << 8 | ((short)data[0 + cumulativeOffset++])).get(this.constants).toString();
  640.         }
  641.     }
  642.    
  643.     public boolean hasAttribute (String name) {
  644.         for (Attribute a : this.attributes)
  645.             if (a.getName() == name)
  646.                 return true;
  647.         return false;
  648.     }
  649.    
  650.     public Attribute getAttribute (String name) {
  651.         for (Attribute a : this.attributes)
  652.             if (a.getName() == name)
  653.                 return a;
  654.         throw new java.util.NoSuchElementException("Attribute with name " + name + " does not exist.");
  655.     }
  656.    
  657.     public CodeAttribute getCode () {
  658.         try {
  659.             return new CodeAttribute(this.getAttribute("Code"));
  660.         } catch (java.util.NoSuchElementException nsee) {
  661.             throw new DecompilationException("Method with no body found.", nsee);
  662.         }
  663.     }
  664.    
  665.     public List<String> getExceptions () {
  666.         try {
  667.             List<String> exc = List.<String>of();
  668.             ByteArrayInputStream data = new ByteArrayInputStream(this.getAttribute("Exceptions").getRawData());
  669.             data.skip(6);
  670.             int length = ((short) data.read()) >> 8 | ((short) data.read());
  671.             for (int i = 0; i <= length; i++)
  672.                 exc.add(this.constants.get(((short) data.read()) >> 8 | ((short) data.read())).get(this.constants).toString());
  673.         } catch (java.util.NoSuchElementException nsee) {
  674.             return List.<String>of();
  675.         }
  676.     }
  677.    
  678.     public boolean hasTypeVariables () {
  679.         return this.hasAttribute("Signature") && (this.constants.get(((short) this.getAttribute("Signature").getRawData()[6]) | ((short) this.getAttribute("Signature").getRawData()[7])).get(this.constants).toString()).contains("<");
  680.     }
  681.    
  682.     public String formatTypeVariables () {
  683.         String sig = this.constants.get(((short) this.getAttribute("Signature").getRawData()[6]) | ((short) this.getAttribute("Signature").getRawData()[7])).get(this.constants).toString();
  684.        
  685.     }
  686.    
  687.     public static class Descriptor {
  688.         private final String returnString;
  689.         private final List<String> paramStrings;
  690.        
  691.         private Descriptor (String r, List<String> p) {
  692.             this.returnString = r;
  693.             this.paramStrings = p;
  694.         }
  695.        
  696.         public static Descriptor parse (String s) {
  697.             String params = s.substring(1, s.indexOf(")") - 1);
  698.             String returnType = s.substring(s.indexOf(")") + 1);
  699.             List<String> paramList = List.<String>of();
  700.             while (params.length() >= 0) {
  701.                 switch (params.charAt(0)) {
  702.                     case 'B':
  703.                         paramList.add("byte");
  704.                         params = params.substring(1);
  705.                         break;
  706.                     case 'C':
  707.                         paramList.add("char");
  708.                         params = params.substring(1);
  709.                         break;
  710.                     case 'D':
  711.                         paramList.add("double");
  712.                         params = params.substring(1);
  713.                         break;
  714.                     case 'F':
  715.                         paramList.add("float");
  716.                         params = params.substring(1);
  717.                         break;
  718.                     case 'I':
  719.                         paramList.add("int");
  720.                         params = params.substring(1);
  721.                         break;
  722.                     case 'J':
  723.                         paramList.add("long");
  724.                         params = params.substring(1);
  725.                         break;
  726.                     case 'L':
  727.                         String classpath = params.substring(1, params.substring(1).indexOf(";") - 1);
  728.                         paramList.add(classpath.substring(classpath.lastIndexOf("/")));
  729.                         params = params.substring(params.substring(1).indexOf(";") + 1);
  730.                         break;
  731.                     case 'S':
  732.                         paramList.add("short");
  733.                         params = params.substring(1);
  734.                         break;
  735.                     case 'V':
  736.                         paramList.add("void");
  737.                         params = params.substring(1);
  738.                         break;
  739.                     case 'Z':
  740.                         paramList.add("boolean");
  741.                         params = params.substring(1);
  742.                         break;
  743.                     case '[':
  744.                         paramList.add(DecompiledField.Descriptor.parse(params.substring(1)).getTypeString().concat("[]"));
  745.                         params = params.substring(DecompiledField.Descriptor.length(params));
  746.                         break;
  747.                     default:
  748.                         throw new DecompilationException("Invalid method descriptor: " + s);
  749.                 }
  750.             }
  751.             return new Descriptor(returnType, paramList);
  752.         }
  753.        
  754.         public String getReturnString () {
  755.             return this.returnString;
  756.         }
  757.        
  758.         public List<String> getParamStrings () {
  759.             return this.paramStrings;
  760.         }
  761.     }
  762. }
  763.  
  764. public class DecompiledField {
  765.     private String name;
  766.     private DecompiledField.Descriptor desc;
  767.     private AccessFlags flags;
  768.     private List<Attribute> attributes;
  769.     private List<Constant> constants;
  770.    
  771.     private String initializationString = "";
  772.     private DecompiledClass container = null;
  773.    
  774.     public DecompiledField (String name, DecompiledField.Descriptor desc, AccessFlags flags, List<Attribute> attributes, List<Constant> constants) {
  775.         this.name = name;
  776.         this.desc = desc;
  777.         this.flags = flags;
  778.         this.attributes = attributes;
  779.         this.constants = constants;
  780.     }
  781.    
  782.     public String toString (int indentFactor) {
  783.         if (this.flags.isEnum()) return this.toStringAsEnumConstant(indentFactor);
  784.         String header = "";
  785.         if (this.hasAttribute("Synthetic") || this.flags.isSynthetic()) {
  786.             for (int i = 0; i <= indentFactor)
  787.                 header = header.concat(" ");
  788.             header = header.concat("// Synthetic field: not present in the actual source code\n\n");
  789.         }
  790.         if (this.hasAttribute("Deprecated")) {
  791.             for (int i = 0; i <= indentFactor)
  792.                 header = header.concat(" ");
  793.             header = header.concat("@Deprecated");
  794.         }
  795.         for (DecompiledAnnotation a : this.getAnnotations()) {
  796.             if (header.contains("@" + a.getName())) break;
  797.             for (int i = 0; i <= indentFactor)
  798.                 header = header.concat(" ");
  799.             header = header.concat("@" + a.getName());
  800.             if (a.hasParams()) {
  801.                 header = header.concat("(");
  802.                 boolean b = false;
  803.                 if (a.hasMultipleParams()) {
  804.                     for (String s : a.getParams().keySet()) {
  805.                         header = header.concat((b ? ", " : "") + s + " = " + a.getParams().get(s));
  806.                         b = true;
  807.                     }
  808.                 }
  809.                 header = header.concat(a.getParams().get(a.getParams().keySet().stream().toList().get(0)) + ")");
  810.             }
  811.         }
  812.         for (int i = 0; i <= indentFactor)
  813.             header = header.concat(" ");
  814.         if (this.flags.isPublic()) {
  815.             header = header.concat("public ");
  816.         } else if (this.flags.isProtected()) {
  817.             header = header.concat("protected ");
  818.         } else if (this.flags.isPrivate()) {
  819.             header = header.concat("private ");
  820.         }
  821.         if (this.flags.isStatic())
  822.             header = header.concat("static ");
  823.         if (this.flags.isTransient())
  824.             header = header.concat("transient ");
  825.         if (this.flags.isFinal())
  826.             header = header.concat("final ");
  827.         if (this.flags.isVolatile())
  828.             header = header.concat("volatile ");
  829.         header = header.concat(this.desc.getTypeString() + " " + this.name + this.initializatonString + ";");
  830.         return header;
  831.     }
  832.    
  833.     public String toStringAsEnumConstant (int indentFactor) {
  834.         if (!this.flags.isEnum()) throw new IllegalStateException("DecompiledField.toStringAsEnumConstant should not be called if the field is not an enum constant");
  835.         String header = "";
  836.         if (this.hasAttribute("Synthetic") || this.flags.isSynthetic()) {
  837.             for (int i = 0; i <= indentFactor)
  838.                 header = header.concat(" ");
  839.             header = header.concat("// Synthetic field: not present in the actual source code\n\n");
  840.         }
  841.         if (this.hasAttribute("Deprecated")) {
  842.             for (int i = 0; i <= indentFactor)
  843.                 header = header.concat(" ");
  844.             header = header.concat("@Deprecated");
  845.         }
  846.         for (DecompiledAnnotation a : this.getAnnotations()) {
  847.             if (header.contains("@" + a.getName())) break;
  848.             for (int i = 0; i <= indentFactor)
  849.                 header = header.concat(" ");
  850.             header = header.concat("@" + a.getName());
  851.             if (a.hasParams()) {
  852.                 header = header.concat("(");
  853.                 boolean b = false;
  854.                 if (a.hasMultipleParams()) {
  855.                     for (String s : a.getParams().keySet()) {
  856.                         header = header.concat((b ? ", " : "") + s + " = " + a.getParams().get(s));
  857.                         b = true;
  858.                     }
  859.                 }
  860.                 header = header.concat(a.getParams().get(a.getParams().keySet().stream().toList().get(0)) + ")");
  861.             }
  862.         }
  863.         for (int i = 0; i <= indentFactor)
  864.             header = header.concat(" ");
  865.         header = header.concat(this.name + this.hasMoreEnumConstants() ? "," : ";");
  866.         return header;
  867.     }
  868.    
  869.     public void init (DecompiledClass c) {
  870.         if (this.container != null) this.container = c;
  871.     }
  872.    
  873.     public void notifyInitializerMethod (DecompiledMethod method, List<DecompiledField> fields) {
  874.         if (this.flags.isStatic() == method.getName() == "<init>") return;
  875.         for (String s : method.toString(0).split(";"))
  876.             for (DecompiledField f : fields)
  877.                 if (!s.startsWith(f.getName() + " = "))
  878.                     return;
  879.         for (String s : method.toString(0).split(";"))
  880.             if (s.startsWith(this.getName() + " = "))
  881.                 this.initializationString = s.substring(this.name.length());
  882.     }
  883.    
  884.     public boolean hasAttribute (String name) {
  885.         for (Attribute a : this.attributes)
  886.             if (a.getName() == name)
  887.                 return true;
  888.         return false;
  889.     }
  890.    
  891.     public boolean hasMoreEnumConstants () {
  892.         for (DecompiledField f : this.container.fields.sublist(this.container.fields.indexOf(this))) {
  893.             if (f == this) continue;
  894.             if (f.flags.isEnum()) return true;
  895.         }
  896.         return false;
  897.     }
  898.    
  899.     public Attribute getAttribute (String name) {
  900.         for (Attribute a : this.attributes)
  901.             if (a.getName() == name)
  902.                 return a;
  903.         throw new java.util.NoSuchElementException("Attribute with name " + name + " does not exist.");
  904.     }
  905.    
  906.     public static class Descriptor {
  907.         private final String typeString;
  908.        
  909.         private Descriptor (String s) {
  910.             this.typeString = s;
  911.         }
  912.        
  913.         public static Descriptor parse (String s) {
  914.             switch (s.charAt(0)) {
  915.                 case 'B':
  916.                     return new Descriptor("byte");
  917.                 case 'C':
  918.                     return new Descriptor("char");
  919.                 case 'D':
  920.                     return new Descriptor("double");
  921.                 case 'F':
  922.                     return new Descriptor("float");
  923.                 case 'I':
  924.                     return new Descriptor("int");
  925.                 case 'J':
  926.                     return new Descriptor("long");
  927.                 case 'L':
  928.                     return new Descriptor(s.substring(s.substring(1).lastIndexOf("/") + 1, s.indexOf(";")));
  929.                 case 'S':
  930.                     return new Descriptor("short");
  931.                 case 'Z':
  932.                     return new Descriptor("boolean");
  933.                 case '[':
  934.                     return new Descriptor(parse(s.substring(1)).getTypeString().concat("[]"));
  935.                 default:
  936.                     throw new DecompilationException("Invalid field descriptor: " + s);
  937.             }
  938.         }
  939.        
  940.         public static int length (String s) {
  941.             switch (s.charAt(0)) {
  942.                 case 'B':
  943.                     return 1;
  944.                 case 'C':
  945.                     return 1;
  946.                 case 'D':
  947.                     return 1;
  948.                 case 'F':
  949.                     return 1;
  950.                 case 'I':
  951.                     return 1;
  952.                 case 'J':
  953.                     return 1;
  954.                 case 'L':
  955.                     return s.indexOf(";") + 1;
  956.                 case 'S':
  957.                     return 1;
  958.                 case 'Z':
  959.                     return 1;
  960.                 case '[':
  961.                     return length(s.substring(1)) + 1;
  962.                 default:
  963.                     throw new DecompilationException("Invalid field descriptor: " + s);
  964.             }
  965.         }
  966.        
  967.         public String getTypeString () {
  968.             return this.typeString;
  969.         }
  970.     }
  971. }
  972.  
  973. public record AccessFlags (boolean isPublic, boolean isPrivate, boolean isProtected, boolean isStatic, boolean isFinal, boolean isSuper, boolean isSynchronized, boolean isVolatile, boolean isBridge, boolean isTransient, boolean isVarargs, boolean isNative, boolean isInterface, boolean isAbstract, boolean isStrict, boolean isSynthetic, boolean isAnnotation, boolean isEnum) {
  974.     public static final short MASK_PUBLIC = (short) 0x0001;
  975.     public static final short MASK_PRIVATE = (short) 0x0002;
  976.     public static final short MASK_PROTECTED = (short) 0x0004;
  977.     public static final short MASK_STATIC = (short) 0x0008;
  978.     public static final short MASK_FINAL = (short) 0x0010;
  979.     public static final short MASK_SUPER = (short) 0x0020;
  980.     public static final short MASK_SYNCHRONIZED = (short) 0x0020;
  981.     public static final short MASK_VOLATILE = (short) 0x0040;
  982.     public static final short MASK_BRIDGE = (short) 0x0040;
  983.     public static final short MASK_TRANSIENT = (short) 0x0080;
  984.     public static final short MASK_VARARGS = (short) 0x0080;
  985.     public static final short MASK_NATIVE = (short) 0x0100;
  986.     public static final short MASK_INTERFACE = (short) 0x0200;
  987.     public static final short MASK_ABSTRACT = (short) 0x0400;
  988.     public static final short MASK_STRICT = (short) 0x0800;
  989.     public static final short MASK_SYNTHETIC = (short) 0x1000;
  990.     public static final short MASK_ANNOTATION = (short) 0x2000;
  991.     public static final short MASK_ENUM = (short) 0x4000;
  992.    
  993.     public static AccessFlags parseMethod (short data) {
  994.         return new AccessFlags(
  995.             data | MASK_PUBLIC != (short) 0,
  996.             data | MASK_PRIVATE != (short) 0,
  997.             data | MASK_PROTECTED != (short) 0,
  998.             data | MASK_STATIC != (short) 0,
  999.             data | MASK_FINAL != (short) 0,
  1000.             false,
  1001.             data | MASK_SYNCHRONIZED != (short) 0,
  1002.             false,
  1003.             data | MASK_BRIDGE != (short) 0,
  1004.             false,
  1005.             data | MASK_VARARGS != (short) 0,
  1006.             data | MASK_NATIVE != (short) 0,
  1007.             false,
  1008.             data | MASK_ABSTRACT != (short) 0,
  1009.             data | MASK_STRICT != (short) 0,
  1010.             data | MASK_SYNTHETIC != (short) 0,
  1011.             false,
  1012.             false);
  1013.     }
  1014.    
  1015.     public static AccessFlags parseOther (short data) {
  1016.         return new AccessFlags(
  1017.             data | MASK_PUBLIC != (short) 0,
  1018.             data | MASK_PRIVATE != (short) 0,
  1019.             data | MASK_PROTECTED != (short) 0,
  1020.             data | MASK_STATIC != (short) 0,
  1021.             data | MASK_FINAL != (short) 0,
  1022.             data | MASK_SUPER != (short) 0,
  1023.             false,
  1024.             data | MASK_VOLATILE != (short) 0,
  1025.             false,
  1026.             data | MASK_TRANSIENT != (short) 0,
  1027.             false,
  1028.             false,
  1029.             data | MASK_INTERFACE != (short) 0,
  1030.             data | MASK_ABSTRACT != (short) 0,
  1031.             false,
  1032.             data | MASK_SYNTHETIC != (short) 0,
  1033.             data | MASK_ANNOTATION != (short) 0,
  1034.             data | MASK_ENUM != (short) 0);
  1035.     }
  1036. }
  1037.  
  1038. public class DecompilationException extends Exception {
  1039.     public DecompilationException () {}
  1040.    
  1041.     public DecompilationException (String message) {
  1042.         super (message);
  1043.     }
  1044.    
  1045.     public DecompilationException (Throwable cause) {
  1046.         super (cause);
  1047.     }
  1048.    
  1049.     public DecompilationException (String message, Throwable cause) {
  1050.         super (message, cause);
  1051.     }
  1052.    
  1053.     protected DecompilationException (String message, Throwable cause,  boolean b1, boolean b2) {
  1054.         super (message, cause, b1, b2);
  1055.     }
  1056. }
  1057.  
  1058. public class Attribute {
  1059.     private byte[] rawData;
  1060.    
  1061.     protected Attribute (byte[] rawData) {}
  1062.    
  1063.     public static Attribute readFrom (InputStream reader, List<Constant> constants) {
  1064.         byte[] index = reader.readNBytes(2);
  1065.         byte[] length = reader.readNBytes(4);
  1066.         byte[] postData = reader.readNBytes((((short)length[0]) << 24 | ((short)length[0]) << 16) | (((short)length[0]) << 8 | ((short)length[0])));
  1067.         byte[] finalData = new byte[postData.length + 6];
  1068.         System.arraycopy(index, 0, finalData, 0, 2);
  1069.         System.arraycopy(length, 0, finalData, 0, 4);
  1070.         System.arraycopy(postData, 0, finalData, 0, (((short)length[0]) << 24 | ((short)length[0]) << 16) | (((short)length[0]) << 8 | ((short)length[0])));
  1071.         if (constants.get(((short)reader.read()) << 8 | ((short)reader.read())).get(constants).toString() == "Code")
  1072.             return CodeAttribute.readFrom(new ByteArrayInputStream(finalData));
  1073.         return new Attribute (finalData);
  1074.     }
  1075.    
  1076.     public byte[] getRawData () {
  1077.         return this.rawData;
  1078.     }
  1079. }
  1080.  
  1081. public class PackageTree {
  1082.     private String packageString = "";
  1083.    
  1084.     private Map<String, PackageTree> packages = Map.<String, PackageTree>of();
  1085.     private List<DecompiledClass> classes;
  1086.    
  1087.     public PackageTree () {}
  1088.    
  1089.     public PackageTree (String s) {
  1090.         this.packageString = s;
  1091.     }
  1092.    
  1093.     public DecompiledClass add (DecompiledClass clazz) {
  1094.         if (!this.hasPackage(clazz.getPackageString()))
  1095.             return this.addPackage(clazz.getPackageString()).add(clazz);
  1096.         if (this.toString() == clazz.getPackageString)
  1097.             return this.classes.add(clazz);
  1098.         return this.packages.get(clazz.getPackageString()).add(clazz);
  1099.     }
  1100.    
  1101.     public PackageTree addPackage (String packageString) {
  1102.         return packages.put(packageString, new PackageTree(packageString));
  1103.     }
  1104.    
  1105.     public boolean hasPackage (String s) {
  1106.         return this.packages.has(s);
  1107.     }
  1108.    
  1109.     @Override
  1110.     public String toString () {
  1111.         return this.packageString;
  1112.     }
  1113. }
  1114.  
  1115. public class DecompiledAnnotation {
  1116.     private String className;
  1117.     private Map<String, String> ev;
  1118.    
  1119.     public DecompiledAnnotation (String name, Map<String, String> map) {
  1120.         this.className = name;
  1121.         this.ev = map;
  1122.     }
  1123.    
  1124.     public String getName () {
  1125.         return  this.name;
  1126.     }
  1127.    
  1128.     public boolean hasParams () {
  1129.         return this.ev.size() > 0;
  1130.     }
  1131.    
  1132.     public boolean hasMultipleParams () {
  1133.         return this.ev.size() > 0;
  1134.     }
  1135.    
  1136.     public Map<String, String> getParams () {
  1137.         return this.ev;
  1138.     }
  1139. }
  1140.  
  1141. // Convenience classes to differentiate between constant types.
  1142. public class ClassReference {
  1143.     private String s;
  1144.    
  1145.     public ClassReference (String is) {
  1146.         this.s = is;
  1147.     }
  1148.    
  1149.     public String toString () {
  1150.         return this.is;
  1151.     }
  1152. }
  1153.  
  1154. // Field reference, for the getstatic and putstatic instructions
  1155. public class FieldReference {
  1156.     private ClassReference ref;
  1157.     private NameAndType data;
  1158.    
  1159.     public FieldReference (ClassReference clazz, NameAndType nat) {
  1160.         this.ref = clazz;
  1161.         this.data = nat;
  1162.     }
  1163.    
  1164.     public ClassReference getClass () {
  1165.         return this.ref;
  1166.     }
  1167.    
  1168.     public String getName () {
  1169.         return this.data.getName();
  1170.     }
  1171. }
  1172.  
  1173. // Method reference, for the invokestatic instruction
  1174. public class MethodReference {
  1175.     private ClassReference ref;
  1176.     private NameAndType data;
  1177.    
  1178.     public MethodReference (ClassReference clazz, NameAndType nat) {
  1179.         this.ref = clazz;
  1180.         this.data = nat;
  1181.     }
  1182.    
  1183.     public ClassReference getClass () {
  1184.         return this.ref;
  1185.     }
  1186.    
  1187.     public String getName () {
  1188.         return this.data.getName();
  1189.     }
  1190. }
  1191.  
  1192. // I need this for some reason?
  1193. public class AbstractMethodReference {
  1194.     private ClassReference ref;
  1195.     private NameAndType data;
  1196.    
  1197.     public AbstractMethodReference (ClassReference clazz, NameAndType nat) {
  1198.         this.ref = clazz;
  1199.         this.data = nat;
  1200.     }
  1201.    
  1202.     public ClassReference getClass () {
  1203.         return this.ref;
  1204.     }
  1205.    
  1206.     public String getName () {
  1207.         return this.data.getName();
  1208.     }
  1209. }
  1210.  
  1211. // A class for defining names and types of things, go figure.
  1212. public class NameAndType {
  1213.     private String name;
  1214.     private String type;
  1215.    
  1216.     public NameAndType (String n, String t) {
  1217.         this.name = n;
  1218.         this.type = t;
  1219.     }
  1220.    
  1221.     public String getName () {
  1222.         return this.name;
  1223.     }
  1224.    
  1225.     public String getType () {
  1226.         return this.type;
  1227.     }
  1228. }
  1229.  
  1230. // Method handle? Not quite sure.
  1231. public class MethodHandleConstant {
  1232.     private final int index;
  1233.    
  1234.     private MethodHandleConstant (int i) {
  1235.         this.index = i;
  1236.     }
  1237.    
  1238.     public static MethodHandleConstant parse (byte[] data) {
  1239.         return new MethodHandleConstant((((short) data[1]) << 8) | data[2]);
  1240.     }
  1241.    
  1242.     public Object get (List<Constant> constants) {
  1243.         return constants.get(this.index).get(constants);
  1244.     }
  1245. }
  1246.  
  1247. // I have no clue if this constant type is even ever used!
  1248. public class MethodTypeConstant {
  1249.     private final int index;
  1250.    
  1251.     private MethodTypeConstant (int i) {
  1252.         this.index = i;
  1253.     }
  1254.    
  1255.     public static MethodHandleConstant parse (byte[] data) {
  1256.         return new MethodHandleConstant((((short) data[0]) << 8) | data[1]);
  1257.     }
  1258.    
  1259.     public Object get (List<Constant> constants) {
  1260.         return constants.get(this.index).get(constants).toString();
  1261.     }
  1262. }
  1263.  
  1264. // This one still confuses me.
  1265. public class DynamicMethodConstant {
  1266.     private final int methodIndex;
  1267.     private final int dataIndex;
  1268.    
  1269.     private MethodTypeConstant (int i, int i2) {
  1270.         this.methodIndex = i;
  1271.         this.dataIndex = i2;
  1272.     }
  1273.    
  1274.     public static MethodHandleConstant parse (byte[] data) {
  1275.         return new MethodHandleConstant((((short) data[0]) << 8) | data[1], (((short) data[2]) << 8) | data[3]);
  1276.     }
  1277.    
  1278.     public Object get (List<Constant> constants) {
  1279.         return null;
  1280.     }
  1281.    
  1282.     public BootstrapMethod get (List<Constant> constants, DecompiledClass clazz) {
  1283.         if (!clazz.hasAttribute("BootstrapMethods")) throw new DecompilationException ("Class file missing BootstrapMethods attribute");
  1284.         BootstrapMethod method = BootstrapMethod.Attribute.parse(clazz.getAttribute("BootstrapMethods").getRawData(), List<Constant> constants).get(this.methodIndex);
  1285.         return method;
  1286.     }
  1287. }
  1288.  
  1289. public class BootstrapMethod {
  1290.     private final MethodHandle handle;
  1291.     private final List<?> args;
  1292.    
  1293.     private BootstrapMethod (MethodHandle h, List<?> a) {
  1294.         this.handle = h;
  1295.         this.args = a;
  1296.     }
  1297.    
  1298.     public static BootstrapMethod readFrom (InputStream reader, List<Constant> constants) {
  1299.         MethodHandle handle = (MethodHandle)constants.get((stream.read() << 8) | stream.read()).get(constants);
  1300.         List<?> args = List.<?>of();
  1301.         int amt = (stream.read() << 8) | stream.read();
  1302.         for (int i = 0; i <= amt; i++)
  1303.             args.add(constants.get((stream.read() << 8) | stream.read()).get(constants));
  1304.         return new BootstrapMethod(handle, args);
  1305.     }
  1306.    
  1307.     public static class Attribute {
  1308.         private List<BootstrapMethod> methods;
  1309.        
  1310.         private Attribute (List<BootstrapMethod> method) {
  1311.             this.methods = method;
  1312.         }
  1313.        
  1314.         public Attribute parse (byte[] data, List<Constant> constants) {
  1315.             ByteArrayInputStream stream = new ByteArrayInputStream(data);
  1316.             stream.skip(6);
  1317.             List<BootstrapMethod> methods = List.<BootstrapMethod>of();
  1318.             int amt = (stream.read() << 8) | stream.read();
  1319.             for (int i = 0; i <= amt; i++)
  1320.                 methods.add(BootstrapMethod.readFrom(stream, constants));
  1321.             return new Attribute(methods);
  1322.         }
  1323.     }
  1324. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!