home *** CD-ROM | disk | FTP | other *** search
/ PC Online 1997 October / PCO1097.ISO / FilesBBS / WIN95 / IAVAZIP.EXE / DATA.Z / ClassFile.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-08-18  |  9.3 KB  |  657 lines
  1. package com.sfs.hardcore;
  2.  
  3. import java.io.ByteArrayInputStream;
  4. import java.io.DataInputStream;
  5. import java.io.DataOutputStream;
  6. import java.io.IOException;
  7. import java.io.InputStream;
  8. import java.io.OutputStream;
  9. import java.io.PrintStream;
  10.  
  11. public class ClassFile {
  12.    int magic;
  13.    short majorVersion;
  14.    short minorVersion;
  15.    ConstantPoolInfo[] constantPool;
  16.    short accessFlags;
  17.    ConstantPoolInfo thisClass;
  18.    ConstantPoolInfo superClass;
  19.    ConstantPoolInfo[] interfaces;
  20.    FieldInfo[] fields;
  21.    MethodInfo[] methods;
  22.    AttributeInfo[] attributes;
  23.    boolean isValidClass;
  24.    public static final int ACC_PUBLIC = 1;
  25.    public static final int ACC_PRIVATE = 2;
  26.    public static final int ACC_PROTECTED = 4;
  27.    public static final int ACC_STATIC = 8;
  28.    public static final int ACC_FINAL = 16;
  29.    public static final int ACC_SYNCHRONIZED = 32;
  30.    public static final int ACC_THREADSAFE = 64;
  31.    public static final int ACC_TRANSIENT = 128;
  32.    public static final int ACC_NATIVE = 256;
  33.    public static final int ACC_INTERFACE = 512;
  34.    public static final int ACC_ABSTRACT = 1024;
  35.    public boolean debug;
  36.    public boolean dumpConstants;
  37.  
  38.    public void deleteMethod(String var1, String var2) {
  39.       for(int var3 = 0; var3 < this.constantPool.length; ++var3) {
  40.          if (this.constantPool[var3].type == 7) {
  41.          }
  42.       }
  43.  
  44.    }
  45.  
  46.    public AttributeInfo getAttribute(String var1) {
  47.       if (this.attributes == null) {
  48.          return null;
  49.       } else {
  50.          for(int var2 = 0; var2 < this.attributes.length; ++var2) {
  51.             if (var1.compareTo(this.attributes[var2].name.toString()) == 0) {
  52.                return this.attributes[var2];
  53.             }
  54.          }
  55.  
  56.          return null;
  57.       }
  58.    }
  59.  
  60.    public String toString() {
  61.       return "Class File (Version " + this.majorVersion + "." + this.minorVersion + ") for class " + this.thisClass.arg1;
  62.    }
  63.  
  64.    public boolean read(InputStream var1) throws IOException {
  65.       DataInputStream var2 = new DataInputStream(var1);
  66.       this.magic = var2.readInt();
  67.       if (this.magic != -889275714) {
  68.          return false;
  69.       } else {
  70.          this.majorVersion = var2.readShort();
  71.          this.minorVersion = var2.readShort();
  72.          short var3 = var2.readShort();
  73.          this.constantPool = new ConstantPoolInfo[var3];
  74.          if (this.debug) {
  75.             System.out.println("read(): Read header...");
  76.          }
  77.  
  78.          this.constantPool[0] = new ConstantPoolInfo();
  79.  
  80.          for(int var4 = 1; var4 < this.constantPool.length; ++var4) {
  81.             this.constantPool[var4] = new ConstantPoolInfo();
  82.             if (!this.constantPool[var4].read(var2)) {
  83.                return false;
  84.             }
  85.  
  86.             if (this.constantPool[var4].type == 5 || this.constantPool[var4].type == 6) {
  87.                ++var4;
  88.             }
  89.          }
  90.  
  91.          for(int var10 = 1; var10 < this.constantPool.length; ++var10) {
  92.             if (this.constantPool[var10] != null) {
  93.                if (this.constantPool[var10].index1 > 0) {
  94.                   this.constantPool[var10].arg1 = this.constantPool[this.constantPool[var10].index1];
  95.                }
  96.  
  97.                if (this.constantPool[var10].index2 > 0) {
  98.                   this.constantPool[var10].arg2 = this.constantPool[this.constantPool[var10].index2];
  99.                }
  100.             }
  101.          }
  102.  
  103.          if (this.dumpConstants) {
  104.             for(int var11 = 1; var11 < this.constantPool.length; ++var11) {
  105.                System.out.println("C" + var11 + " - " + this.constantPool[var11]);
  106.             }
  107.          }
  108.  
  109.          this.accessFlags = var2.readShort();
  110.          this.thisClass = this.constantPool[var2.readShort()];
  111.          this.superClass = this.constantPool[var2.readShort()];
  112.          if (this.debug) {
  113.             System.out.println("read(): Read class info...");
  114.          }
  115.  
  116.          var3 = var2.readShort();
  117.          if (var3 != 0) {
  118.             if (this.debug) {
  119.                System.out.println("Class implements " + var3 + " interfaces.");
  120.             }
  121.  
  122.             this.interfaces = new ConstantPoolInfo[var3];
  123.  
  124.             for(int var12 = 0; var12 < var3; ++var12) {
  125.                short var5 = var2.readShort();
  126.                if (var5 < 1 || var5 > this.constantPool.length - 1) {
  127.                   return false;
  128.                }
  129.  
  130.                this.interfaces[var12] = this.constantPool[var5];
  131.                if (this.debug) {
  132.                   System.out.println("I" + var12 + ": " + this.interfaces[var12]);
  133.                }
  134.             }
  135.          }
  136.  
  137.          if (this.debug) {
  138.             System.out.println("read(): Read interface info...");
  139.          }
  140.  
  141.          var3 = var2.readShort();
  142.          if (this.debug) {
  143.             System.out.println("This class has " + var3 + " fields.");
  144.          }
  145.  
  146.          if (var3 != 0) {
  147.             this.fields = new FieldInfo[var3];
  148.  
  149.             for(int var13 = 0; var13 < var3; ++var13) {
  150.                this.fields[var13] = new FieldInfo();
  151.                if (!this.fields[var13].read(var2, this.constantPool)) {
  152.                   return false;
  153.                }
  154.  
  155.                if (this.debug) {
  156.                   System.out.println("F" + var13 + ": " + this.fields[var13].toString(this.constantPool));
  157.                }
  158.             }
  159.          }
  160.  
  161.          if (this.debug) {
  162.             System.out.println("read(): Read field info...");
  163.          }
  164.  
  165.          var3 = var2.readShort();
  166.          if (var3 != 0) {
  167.             this.methods = new MethodInfo[var3];
  168.  
  169.             for(int var14 = 0; var14 < var3; ++var14) {
  170.                this.methods[var14] = new MethodInfo();
  171.                if (!this.methods[var14].read(var2, this.constantPool)) {
  172.                   return false;
  173.                }
  174.  
  175.                if (this.debug) {
  176.                   System.out.println("M" + var14 + ": " + this.methods[var14].toString());
  177.                }
  178.             }
  179.          }
  180.  
  181.          if (this.debug) {
  182.             System.out.println("read(): Read method info...");
  183.          }
  184.  
  185.          var3 = var2.readShort();
  186.          if (var3 != 0) {
  187.             this.attributes = new AttributeInfo[var3];
  188.  
  189.             for(int var15 = 0; var15 < var3; ++var15) {
  190.                this.attributes[var15] = new AttributeInfo();
  191.                if (!this.attributes[var15].read(var2, this.constantPool)) {
  192.                   return false;
  193.                }
  194.             }
  195.          }
  196.  
  197.          if (this.debug) {
  198.             System.out.println("read(): Read attribute info...");
  199.             System.out.println("done.");
  200.          }
  201.  
  202.          this.isValidClass = true;
  203.          return true;
  204.       }
  205.    }
  206.  
  207.    public ConstantPoolInfo getConstantPoolItem(short var1) throws Exception {
  208.       if (var1 > 0 && var1 <= this.constantPool.length - 1) {
  209.          ConstantPoolInfo var2 = this.constantPool[var1];
  210.          if (var2.arg1 != null) {
  211.             var2.index1 = ConstantPoolInfo.indexOf(var2.arg1, this.constantPool);
  212.          }
  213.  
  214.          if (var2.arg2 != null) {
  215.             var2.index2 = ConstantPoolInfo.indexOf(var2.arg2, this.constantPool);
  216.          }
  217.  
  218.          return var2;
  219.       } else {
  220.          return null;
  221.       }
  222.    }
  223.  
  224.    public static String typeString(String var0, String var1) {
  225.       int var2 = 0;
  226.       int var3 = 0;
  227.  
  228.       StringBuffer var4;
  229.       for(var4 = new StringBuffer(); var0.charAt(var3) == '['; ++var3) {
  230.          ++var2;
  231.       }
  232.  
  233.       switch (var0.charAt(var3)) {
  234.          case 'B':
  235.             var4.append("byte ");
  236.             break;
  237.          case 'C':
  238.             var4.append("char ");
  239.             break;
  240.          case 'D':
  241.             var4.append("double ");
  242.             break;
  243.          case 'F':
  244.             var4.append("float ");
  245.             break;
  246.          case 'I':
  247.             var4.append("int ");
  248.             break;
  249.          case 'J':
  250.             var4.append("long ");
  251.             break;
  252.          case 'L':
  253.             for(int var5 = var3 + 1; var5 < var0.indexOf(59); ++var5) {
  254.                if (var0.charAt(var5) != '/') {
  255.                   var4.append(var0.charAt(var5));
  256.                } else {
  257.                   var4.append('.');
  258.                }
  259.             }
  260.  
  261.             var4.append(" ");
  262.             break;
  263.          case 'S':
  264.             var4.append("short ");
  265.             break;
  266.          case 'V':
  267.             var4.append("void ");
  268.             break;
  269.          case 'Z':
  270.             var4.append("boolean ");
  271.       }
  272.  
  273.       var4.append(var1);
  274.  
  275.       while(var2 > 0) {
  276.          var4.append("[]");
  277.          --var2;
  278.       }
  279.  
  280.       return var4.toString();
  281.    }
  282.  
  283.    public void addConstantPoolItems(ConstantPoolInfo[] var1) {
  284.       boolean[] var4 = new boolean[var1.length];
  285.  
  286.       for(int var5 = 0; var5 < var1.length; ++var5) {
  287.          if (var1[var5].type == 1 || var1[var5].type == 2 || var1[var5].type == 3 || var1[var5].type == 5 || var1[var5].type == 4 || var1[var5].type == 6) {
  288.             var4[var5] = false;
  289.             ConstantPoolInfo var2 = var1[var5].inPool(this.constantPool);
  290.             if (var2 != null) {
  291.                var4[var5] = true;
  292.  
  293.                for(int var6 = 0; var6 < var1.length; ++var6) {
  294.                   if (var1[var6].arg1 == var1[var5]) {
  295.                      var1[var6].arg1 = var2;
  296.                   }
  297.  
  298.                   if (var1[var6].arg2 == var1[var5]) {
  299.                      var1[var6].arg2 = var2;
  300.                   }
  301.                }
  302.             }
  303.          }
  304.       }
  305.  
  306.       for(int var9 = 0; var9 < var1.length; ++var9) {
  307.          if (var1[var9].type == 7 || var1[var9].type == 9 || var1[var9].type == 10 || var1[var9].type == 8 || var1[var9].type == 11 || var1[var9].type == 12) {
  308.             var4[var9] = false;
  309.             ConstantPoolInfo var8 = var1[var9].inPool(this.constantPool);
  310.             if (var8 != null) {
  311.                var4[var9] = true;
  312.  
  313.                for(int var11 = 0; var11 < var1.length; ++var11) {
  314.                   if (var1[var11].arg1 == var1[var9]) {
  315.                      var1[var11].arg1 = var8;
  316.                   }
  317.  
  318.                   if (var1[var11].arg2 == var1[var9]) {
  319.                      var1[var11].arg2 = var8;
  320.                   }
  321.                }
  322.             }
  323.          }
  324.       }
  325.  
  326.       int var10 = 0;
  327.  
  328.       for(int var12 = 0; var12 < var1.length; ++var12) {
  329.          if (!var4[var12]) {
  330.             ++var10;
  331.          }
  332.       }
  333.  
  334.       ConstantPoolInfo[] var3 = new ConstantPoolInfo[this.constantPool.length + var10];
  335.  
  336.       for(int var13 = 1; var13 < this.constantPool.length; ++var13) {
  337.          var3[var13] = this.constantPool[var13];
  338.       }
  339.  
  340.       int var14 = 0;
  341.  
  342.       for(int var7 = this.constantPool.length; var7 < var3.length; ++var7) {
  343.          while(var4[var14]) {
  344.             ++var14;
  345.          }
  346.  
  347.          var3[var7] = var1[var14];
  348.          ++var14;
  349.       }
  350.  
  351.       this.constantPool = var3;
  352.    }
  353.  
  354.    public void mapPackage(String var1, String var2) {
  355.       for(int var3 = 0; var3 < this.constantPool.length; ++var3) {
  356.          if (this.constantPool[var3].type == 7) {
  357.             String var4 = this.constantPool[var3].arg1.strValue;
  358.             if (var4.startsWith(var1)) {
  359.                this.constantPool[var3].arg1.strValue = var2 + var4.substring(var4.lastIndexOf(47));
  360.             }
  361.          }
  362.       }
  363.  
  364.    }
  365.  
  366.    public void write(OutputStream var1) throws IOException, Exception {
  367.       DataOutputStream var2 = new DataOutputStream(var1);
  368.       if (!this.isValidClass) {
  369.          throw new Exception("ClassFile::write() - Invalid Class");
  370.       } else {
  371.          var2.writeInt(this.magic);
  372.          var2.writeShort(this.majorVersion);
  373.          var2.writeShort(this.minorVersion);
  374.          var2.writeShort(this.constantPool.length);
  375.  
  376.          for(int var3 = 1; var3 < this.constantPool.length; ++var3) {
  377.             if (this.constantPool[var3] != null) {
  378.                this.constantPool[var3].write(var2, this.constantPool);
  379.             }
  380.          }
  381.  
  382.          var2.writeShort(this.accessFlags);
  383.          var2.writeShort(ConstantPoolInfo.indexOf(this.thisClass, this.constantPool));
  384.          var2.writeShort(ConstantPoolInfo.indexOf(this.superClass, this.constantPool));
  385.          if (this.interfaces == null) {
  386.             var2.writeShort(0);
  387.          } else {
  388.             var2.writeShort(this.interfaces.length);
  389.  
  390.             for(int var4 = 0; var4 < this.interfaces.length; ++var4) {
  391.                var2.writeShort(ConstantPoolInfo.indexOf(this.interfaces[var4], this.constantPool));
  392.             }
  393.          }
  394.  
  395.          if (this.fields == null) {
  396.             var2.writeShort(0);
  397.          } else {
  398.             var2.writeShort(this.fields.length);
  399.  
  400.             for(int var5 = 0; var5 < this.fields.length; ++var5) {
  401.                this.fields[var5].write(var2, this.constantPool);
  402.             }
  403.          }
  404.  
  405.          if (this.methods == null) {
  406.             var2.writeShort(0);
  407.          } else {
  408.             var2.writeShort(this.methods.length);
  409.  
  410.             for(int var6 = 0; var6 < this.methods.length; ++var6) {
  411.                this.methods[var6].write(var2, this.constantPool);
  412.             }
  413.          }
  414.  
  415.          if (this.attributes == null) {
  416.             var2.writeShort(0);
  417.          } else {
  418.             var2.writeShort(this.attributes.length);
  419.  
  420.             for(int var7 = 0; var7 < this.attributes.length; ++var7) {
  421.                this.attributes[var7].write(var2, this.constantPool);
  422.             }
  423.  
  424.          }
  425.       }
  426.    }
  427.  
  428.    public void addAttribute(AttributeInfo var1) {
  429.       if (this.attributes == null) {
  430.          this.attributes = new AttributeInfo[1];
  431.          this.attributes[0] = var1;
  432.       } else {
  433.          AttributeInfo[] var2 = new AttributeInfo[1 + this.attributes.length];
  434.  
  435.          for(int var3 = 0; var3 < this.attributes.length; ++var3) {
  436.             var2[var3] = this.attributes[var3];
  437.          }
  438.  
  439.          var2[this.attributes.length] = var1;
  440.          this.attributes = var2;
  441.       }
  442.    }
  443.  
  444.    public ConstantPoolInfo getConstantRef(short var1) {
  445.       return this.constantPool[var1];
  446.    }
  447.  
  448.    public static String accessString(short var0) {
  449.       StringBuffer var1 = new StringBuffer();
  450.       if ((var0 & 1) != 0) {
  451.          var1.append("public ");
  452.       }
  453.  
  454.       if ((var0 & 2) != 0) {
  455.          var1.append("private ");
  456.       }
  457.  
  458.       if ((var0 & 4) != 0) {
  459.          var1.append("protected ");
  460.       }
  461.  
  462.       if ((var0 & 8) != 0) {
  463.          var1.append("static ");
  464.       }
  465.  
  466.       if ((var0 & 16) != 0) {
  467.          var1.append("final ");
  468.       }
  469.  
  470.       if ((var0 & 32) != 0) {
  471.          var1.append("synchronized ");
  472.       }
  473.  
  474.       if ((var0 & 64) != 0) {
  475.          var1.append("threadsafe ");
  476.       }
  477.  
  478.       if ((var0 & 128) != 0) {
  479.          var1.append("transient ");
  480.       }
  481.  
  482.       if ((var0 & 256) != 0) {
  483.          var1.append("native ");
  484.       }
  485.  
  486.       if ((var0 & 512) != 0) {
  487.          var1.append("interface ");
  488.       }
  489.  
  490.       if ((var0 & 1024) != 0) {
  491.          var1.append("abstract ");
  492.       }
  493.  
  494.       return var1.toString();
  495.    }
  496.  
  497.    public static String nextSig(String var0) {
  498.       int var1;
  499.       for(var1 = 0; var0.charAt(var1) == '['; ++var1) {
  500.       }
  501.  
  502.       if (var0.charAt(var1) == 'L') {
  503.          while(var0.charAt(var1) != ';') {
  504.             ++var1;
  505.          }
  506.       }
  507.  
  508.       ++var1;
  509.       String var2 = var0.substring(var1);
  510.       return var2;
  511.    }
  512.  
  513.    public void mapClass(String var1, String var2) {
  514.       if (this.debug) {
  515.          System.out.println("Mapping class name " + var1 + " ==> " + var2 + " for class " + this.thisClass.arg1);
  516.       }
  517.  
  518.       for(int var3 = 0; var3 < this.constantPool.length; ++var3) {
  519.          if (this.constantPool[var3].type == 7) {
  520.             String var4 = this.constantPool[var3].arg1.strValue;
  521.             if (var4.compareTo(var1) == 0) {
  522.                if (this.debug) {
  523.                   System.out.println("REPLACING " + var4 + " with " + var2);
  524.                }
  525.  
  526.                this.constantPool[var3].arg1.strValue = var2;
  527.             }
  528.          }
  529.       }
  530.  
  531.    }
  532.  
  533.    String printClassName(String var1) {
  534.       if (var1.charAt(0) == '[') {
  535.          return typeString(var1, "");
  536.       } else {
  537.          StringBuffer var2 = new StringBuffer();
  538.  
  539.          for(int var3 = 0; var3 < var1.length(); ++var3) {
  540.             if (var1.charAt(var3) == '/') {
  541.                var2.append('.');
  542.             } else {
  543.                var2.append(var1.charAt(var3));
  544.             }
  545.          }
  546.  
  547.          return var2.toString();
  548.       }
  549.    }
  550.  
  551.    public void display(PrintStream var1) throws Exception {
  552.       String var5 = null;
  553.       if (!this.isValidClass) {
  554.          var1.println("Not a valid class");
  555.       }
  556.  
  557.       String var3 = this.printClassName(this.thisClass.arg1.strValue);
  558.       String var4 = this.printClassName(this.superClass.arg1.strValue);
  559.       if (var3.indexOf(46) > 0) {
  560.          var5 = var3.substring(0, var3.lastIndexOf(46));
  561.          var3 = var3.substring(var3.lastIndexOf(46) + 1);
  562.          var1.println("package " + var5 + "\n");
  563.       }
  564.  
  565.       for(int var2 = 1; var2 < this.constantPool.length; ++var2) {
  566.          if (this.constantPool[var2] != null && this.constantPool[var2] != this.thisClass && this.constantPool[var2] != this.superClass && this.constantPool[var2].type == 7) {
  567.             String var6 = this.constantPool[var2].arg1.strValue;
  568.             if (var6.charAt(0) != '[') {
  569.                var6 = this.printClassName(this.constantPool[var2].arg1.strValue);
  570.                if (var5 == null || !var6.startsWith(var5)) {
  571.                   var1.println("import " + this.printClassName(var6) + ";");
  572.                }
  573.             }
  574.          }
  575.       }
  576.  
  577.       var1.println();
  578.       var1.println("/*");
  579.       if (this.attributes != null) {
  580.          var1.println(" * This class has " + this.attributes.length + " optional class attributes.");
  581.          var1.println(" * These attributes are: ");
  582.  
  583.          for(int var10 = 0; var10 < this.attributes.length; ++var10) {
  584.             String var8 = this.attributes[var10].name.strValue;
  585.             DataInputStream var15 = new DataInputStream(new ByteArrayInputStream(this.attributes[var10].data));
  586.             var1.println(" * Attribute " + (var10 + 1) + " is of type " + this.attributes[var10].name);
  587.             if (var8.compareTo("SourceFile") == 0) {
  588.                ConstantPoolInfo var7 = null;
  589.  
  590.                try {
  591.                   var7 = this.constantPool[var15.readShort()];
  592.                } catch (IOException var9) {
  593.                }
  594.  
  595.                var1.println(" *\tSourceFile : " + var7);
  596.             } else {
  597.                var1.println(" *\tTYPE (" + var8 + ")");
  598.             }
  599.          }
  600.       } else {
  601.          var1.println(" * This class has NO optional class attributes.");
  602.       }
  603.  
  604.       var1.println(" */\n");
  605.       var1.print(accessString(this.accessFlags) + "class " + var3 + " extends " + var4);
  606.       if (this.interfaces != null) {
  607.          var1.print(" implements ");
  608.  
  609.          for(int var11 = 0; var11 < this.interfaces.length - 1; ++var11) {
  610.             var1.print(this.interfaces[var11].arg1.strValue + ", ");
  611.          }
  612.  
  613.          var1.print(this.interfaces[this.interfaces.length - 1].arg1.strValue);
  614.       }
  615.  
  616.       var1.println(" {\n");
  617.       if (this.fields != null) {
  618.          var1.println("/* Instance Variables */");
  619.  
  620.          for(int var12 = 0; var12 < this.fields.length; ++var12) {
  621.             var1.println("    " + this.fields[var12].toString(this.constantPool) + ";");
  622.          }
  623.       }
  624.  
  625.       if (this.methods != null) {
  626.          var1.println("\n/* Methods */");
  627.  
  628.          for(int var13 = 0; var13 < this.methods.length; ++var13) {
  629.             var1.println("    " + this.methods[var13].toString(var3));
  630.          }
  631.       }
  632.  
  633.       var1.println("\n}");
  634.    }
  635.  
  636.    public short addConstantPoolItem(ConstantPoolInfo var1) throws Exception {
  637.       ConstantPoolInfo var3 = var1.inPool(this.constantPool);
  638.       if (var3 != null) {
  639.          return ConstantPoolInfo.indexOf(var3, this.constantPool);
  640.       } else {
  641.          ConstantPoolInfo[] var2 = new ConstantPoolInfo[this.constantPool.length + 1];
  642.  
  643.          for(int var4 = 1; var4 < this.constantPool.length; ++var4) {
  644.             var2[var4] = this.constantPool[var4];
  645.          }
  646.  
  647.          var2[this.constantPool.length] = var1;
  648.          this.constantPool = var2;
  649.          return ConstantPoolInfo.indexOf(var1, this.constantPool);
  650.       }
  651.    }
  652.  
  653.    public String getClassName() {
  654.       return this.printClassName(this.thisClass.arg1.strValue);
  655.    }
  656. }
  657.