home *** CD-ROM | disk | FTP | other *** search
/ Tutto per Internet / Internet.iso / soft95 / Java / espints / espinst.exe / classes / espresso / ClassFile.class (.txt) < prev    next >
Encoding:
Java Class File  |  1996-02-28  |  20.4 KB  |  1,137 lines
  1. package espresso;
  2.  
  3. import java.io.ByteArrayInputStream;
  4. import java.io.ByteArrayOutputStream;
  5. import java.io.DataInputStream;
  6. import java.io.DataOutputStream;
  7. import java.io.File;
  8. import java.io.FileOutputStream;
  9. import java.io.IOException;
  10. import java.util.Hashtable;
  11. import java.util.Vector;
  12.  
  13. class ClassFile implements Constants {
  14.    // $FF: renamed from: op int
  15.    private static int field_0;
  16.    private static byte[] out;
  17.    private static byte[] poolbuf;
  18.    private static byte[] databuf;
  19.    private static final int POOL_BUF_SIZE = 65536;
  20.    private static final int DATA_BUF_SIZE = 65536;
  21.    private static int[] poolIdx;
  22.    private static Object[] poolObj;
  23.    // $FF: renamed from: bp int
  24.    private static int field_1;
  25.    private static byte[] buf;
  26.    private static int processed;
  27.    private static Vector todo;
  28.    private static Name THROWSENDsig;
  29.    private static Name THROWSBEGINsig;
  30.    private static Name ARGENDsig;
  31.    private static Name ARGBEGINsig;
  32.    private static Name ARRAYsig;
  33.    private static Name VOIDsig;
  34.    private static Name BOOLEANsig;
  35.    private static Name DOUBLEsig;
  36.    private static Name FLOATsig;
  37.    private static Name LONGsig;
  38.    private static Name INTsig;
  39.    private static Name CHARsig;
  40.    private static Name SHORTsig;
  41.    private static Name BYTEsig;
  42.    private static Name closureS;
  43.    private static Name emptyS;
  44.    private static Name PeriodS;
  45.    private static Name FullTypeS;
  46.    private static Name SourceFileS;
  47.    private static Name ExceptionsS;
  48.    private static Name CodeS;
  49.    private static Name LocalVariableTableS;
  50.    private static Name LineNumberTableS;
  51.    private static Name ConstantValueS;
  52.    private static final int JAVA_MINOR_VERSION = 3;
  53.    private static final int JAVA_MAJOR_VERSION = 45;
  54.    private static final int JAVA_MAGIC = -889275714;
  55.    static Hashtable loaded;
  56.    static String classPath;
  57.    static String pathSep = System.getProperty("path.separator");
  58.    static String outDir = null;
  59.  
  60.    static {
  61.       classPath = String.valueOf(System.getProperty("java.class.path")).concat(String.valueOf(pathSep));
  62.       loaded = new Hashtable();
  63.       ConstantValueS = Name.fromString("ConstantValue");
  64.       LineNumberTableS = Name.fromString("LineNumberTable");
  65.       LocalVariableTableS = Name.fromString("LocalVariableTable");
  66.       CodeS = Name.fromString("Code");
  67.       ExceptionsS = Name.fromString("Exceptions");
  68.       SourceFileS = Name.fromString("SourceFile");
  69.       FullTypeS = Name.fromString("FullType");
  70.       PeriodS = Name.fromString(".");
  71.       emptyS = Name.fromString("");
  72.       closureS = Name.fromString("$closure");
  73.       BYTEsig = Name.fromString("B");
  74.       SHORTsig = Name.fromString("S");
  75.       CHARsig = Name.fromString("C");
  76.       INTsig = Name.fromString("I");
  77.       LONGsig = Name.fromString("J");
  78.       FLOATsig = Name.fromString("F");
  79.       DOUBLEsig = Name.fromString("D");
  80.       BOOLEANsig = Name.fromString("Z");
  81.       VOIDsig = Name.fromString("V");
  82.       ARRAYsig = Name.fromString("[");
  83.       ARGBEGINsig = Name.fromString("(");
  84.       ARGENDsig = Name.fromString(")");
  85.       THROWSBEGINsig = Name.fromString("<");
  86.       THROWSENDsig = Name.fromString(">");
  87.       databuf = new byte[65536];
  88.       poolbuf = new byte[65536];
  89.    }
  90.  
  91.    public static File openOutput(ClassObj var0) {
  92.       return new File(prefixDir(outDir, prefixDir(Basic.parentName(var0.sourcefile.toString()), String.valueOf(var0.name).concat(String.valueOf(".class")))));
  93.    }
  94.  
  95.    private static String prefixDir(String var0, String var1) {
  96.       return var0 != null ? String.valueOf(String.valueOf(var0).concat(String.valueOf(File.separator))).concat(String.valueOf(var1)) : var1;
  97.    }
  98.  
  99.    public static void writeClass(FileOutputStream var0, ClassObj var1) throws StoreError {
  100.       try {
  101.          out = databuf;
  102.          field_0 = 0;
  103.          writeChar(var1.modifiers);
  104.          writeClassName(var1.pool, var1);
  105.          if (var1.superclass != null) {
  106.             writeClassName(var1.pool, var1.superclass);
  107.          } else {
  108.             writeChar(0);
  109.          }
  110.  
  111.          writeChar(var1.interfaces.length);
  112.  
  113.          for(int var2 = 0; var2 < var1.interfaces.length; ++var2) {
  114.             writeClassName(var1.pool, var1.interfaces[var2]);
  115.          }
  116.  
  117.          int var3 = 0;
  118.          int var4 = 0;
  119.          ScopeEntry var5 = var1.scope.elements();
  120.  
  121.          for(ScopeEntry var6 = var5; var6 != null; var6 = var6.sibling) {
  122.             if (var6.obj instanceof VarObj) {
  123.                ++var3;
  124.             } else {
  125.                ++var4;
  126.             }
  127.          }
  128.  
  129.          writeChar(var3);
  130.  
  131.          for(ScopeEntry var7 = var5; var7 != null; var7 = var7.sibling) {
  132.             if (var7.obj instanceof VarObj) {
  133.                writeField(var1.pool, (VarObj)var7.obj);
  134.             }
  135.          }
  136.  
  137.          writeChar(var4);
  138.  
  139.          for(ScopeEntry var8 = var5; var8 != null; var8 = var8.sibling) {
  140.             if (!(var8.obj instanceof VarObj)) {
  141.                writeMethod(var1.pool, (FunObj)var8.obj);
  142.             }
  143.          }
  144.  
  145.          if (var1.sourcefile != null) {
  146.             writeChar(1);
  147.             writeAttr(var1.pool, SourceFileS, 2);
  148.             writeChar(var1.pool.put(var1.sourcefile));
  149.          } else {
  150.             writeChar(0);
  151.          }
  152.  
  153.          databuf = out;
  154.          int var9 = field_0;
  155.          if (var1.pool.pp > 65535) {
  156.             exceeded("constant pool size");
  157.          }
  158.  
  159.          out = poolbuf;
  160.          field_0 = 0;
  161.          writeInt(-889275714);
  162.          writeChar(3);
  163.          writeChar(45);
  164.          writePool(var1.pool);
  165.          var1.pool = null;
  166.          writeBytes(databuf, 0, var9);
  167.          poolbuf = out;
  168.          var0.write(out, 0, field_0);
  169.       } catch (StoreError var11) {
  170.          throw var11;
  171.       } catch (IOException var12) {
  172.          throw new StoreError(((Throwable)var12).toString());
  173.       }
  174.    }
  175.  
  176.    private static void writeMethod(Pool var0, FunObj var1) {
  177.       writeChar(var1.modifiers);
  178.       writeFieldName(var0, var1);
  179.       writeChar(var0.put(typeSig(var1.typ, false)));
  180.       TypSet var2 = ((FunTyp)var1.typ).thrown;
  181.       int var3 = 0;
  182.       if (var1.code != null) {
  183.          ++var3;
  184.       }
  185.  
  186.       if (var2 != null) {
  187.          ++var3;
  188.       }
  189.  
  190.       if (var1.alttyp != null) {
  191.          ++var3;
  192.       }
  193.  
  194.       writeChar(var3);
  195.       if (var1.code != null) {
  196.          writeCode(var0, var1.code);
  197.          var1.code = null;
  198.       }
  199.  
  200.       if (var2 != null) {
  201.          int var4 = TypSet.size(var2);
  202.          writeAttr(var0, ExceptionsS, 2 + 2 * var4);
  203.          writeChar(var4);
  204.  
  205.          for(int var5 = 0; var5 < var4; ++var5) {
  206.             writeClassName(var0, var2.typ.obj);
  207.             var2 = var2.next;
  208.          }
  209.       }
  210.  
  211.       if (var1.alttyp != null) {
  212.          writeAttr(var0, FullTypeS, 2);
  213.          writeChar(var0.put(typeSig(var1.alttyp, true)));
  214.       }
  215.  
  216.    }
  217.  
  218.    private static void writeField(Pool var0, VarObj var1) {
  219.       writeChar(var1.modifiers);
  220.       writeFieldName(var0, var1);
  221.       writeChar(var0.put(typeSig(var1.typ, false)));
  222.       int var2 = 0;
  223.       if (var1.value != null) {
  224.          ++var2;
  225.       }
  226.  
  227.       if (var1.alttyp != null) {
  228.          ++var2;
  229.       }
  230.  
  231.       writeChar(var2);
  232.       if (var1.value != null) {
  233.          writeAttr(var0, ConstantValueS, 2);
  234.          writeChar(var0.put(var1.value));
  235.       }
  236.  
  237.       if (var1.alttyp != null) {
  238.          writeAttr(var0, FullTypeS, 2);
  239.          writeChar(var0.put(typeSig(var1.alttyp, true)));
  240.       }
  241.  
  242.    }
  243.  
  244.    private static void writeFieldName(Pool var0, Obj var1) {
  245.       if ((var1.modifiers & 2) != 0 && Switches.obfuscate) {
  246.          writeChar(var0.put(Name.fromString(String.valueOf("_$").concat(String.valueOf(var1.name.index)))));
  247.       } else {
  248.          writeChar(var0.put(var1.name));
  249.       }
  250.  
  251.    }
  252.  
  253.    private static void writeClassName(Pool var0, ClassObj var1) {
  254.       writeChar(var0.put(new NameRef(7, var1.fullname)));
  255.    }
  256.  
  257.    private static void writeCode(Pool var0, Code var1) {
  258.       int var2 = 8 + 1 * var1.cp + 2 + 8 * var1.ncatches + 2;
  259.       int var3 = 0;
  260.       if (var1.nlines > 0) {
  261.          var2 = var2 + 8 + 4 * var1.nlines;
  262.          ++var3;
  263.       }
  264.  
  265.       if (var1.nvars > 0) {
  266.          var2 = var2 + 8 + 10 * var1.nvars;
  267.          ++var3;
  268.       }
  269.  
  270.       writeAttr(var0, CodeS, var2);
  271.       writeChar(var1.max_stack);
  272.       writeChar(var1.max_locals);
  273.       writeInt(var1.cp);
  274.       writeBytes(var1.code, 0, var1.cp);
  275.       writeChar(var1.ncatches);
  276.  
  277.       for(int var4 = 0; var4 < var1.ncatches; ++var4) {
  278.          writeChar(var1.exc_start_pc[var4]);
  279.          writeChar(var1.exc_end_pc[var4]);
  280.          writeChar(var1.exc_handler_pc[var4]);
  281.          writeChar(var1.exc_catch_type[var4]);
  282.       }
  283.  
  284.       writeChar(var3);
  285.       if (var1.nlines > 0) {
  286.          writeAttr(var0, LineNumberTableS, 2 + 4 * var1.nlines);
  287.          writeChar(var1.nlines);
  288.  
  289.          for(int var5 = 0; var5 < var1.nlines; ++var5) {
  290.             writeChar(var1.line_start_pc[var5]);
  291.             writeChar(var1.line_number[var5]);
  292.          }
  293.       }
  294.  
  295.       if (var1.nvars > 0) {
  296.          writeAttr(var0, LocalVariableTableS, 2 + 10 * var1.nvars);
  297.          writeChar(var1.nvars);
  298.  
  299.          for(int var6 = 0; var6 < var1.nvars; ++var6) {
  300.             writeChar(var1.lvar_start_pc[var6]);
  301.             writeChar(var1.lvar_end_pc[var6] - var1.lvar_start_pc[var6]);
  302.             writeChar(var0.put(var1.lvar[var6].name));
  303.             writeChar(var0.put(typeSig(var1.lvar[var6].typ, false)));
  304.             writeChar(var1.lvar[var6].adr);
  305.          }
  306.       }
  307.  
  308.    }
  309.  
  310.    private static void writeAttr(Pool var0, Name var1, int var2) {
  311.       writeChar(var0.put(var1));
  312.       writeInt(var2);
  313.    }
  314.  
  315.    private static void writePool(Pool var0) {
  316.       int var1 = field_0;
  317.       writeChar(0);
  318.  
  319.       for(int var2 = 1; var2 < var0.pp; ++var2) {
  320.          Object var3 = var0.pool[var2];
  321.          if (var3 instanceof Name) {
  322.             writeByte(1);
  323.             byte[] var4 = ((Name)var3).toAscii();
  324.             writeChar(var4.length);
  325.             writeBytes(var4, 0, var4.length);
  326.          } else if (var3 instanceof Integer) {
  327.             writeByte(3);
  328.             writeInt((Integer)var3);
  329.          } else if (var3 instanceof Long) {
  330.             writeByte(5);
  331.             writeLong((Long)var3);
  332.             ++var2;
  333.          } else if (var3 instanceof Float) {
  334.             writeByte(4);
  335.             writeFloat((Float)var3);
  336.          } else if (var3 instanceof Double) {
  337.             writeByte(6);
  338.             writeDouble((Double)var3);
  339.             ++var2;
  340.          } else if (var3 instanceof NameRef) {
  341.             NameRef var5 = (NameRef)var3;
  342.             writeByte((byte)var5.tag);
  343.             Name var6;
  344.             if (var5.tag == 7) {
  345.                byte[] var7 = var5.name.toAscii();
  346.                var6 = Name.fromAscii(externalize(var7, 0, var7.length), 0, var7.length);
  347.             } else {
  348.                var6 = var5.name;
  349.             }
  350.  
  351.             writeChar(var0.put(var6));
  352.          } else if (var3 instanceof Reference) {
  353.             Reference var8 = (Reference)var3;
  354.             writeByte((byte)var8.tag);
  355.             writeChar(var0.put(var8.className));
  356.             writeChar(var0.put(var8.nameType));
  357.          } else {
  358.             if (!(var3 instanceof NameAndType)) {
  359.                throw new CompilerError(String.valueOf("writePool ").concat(String.valueOf(var3)));
  360.             }
  361.  
  362.             NameAndType var9 = (NameAndType)var3;
  363.             writeByte(12);
  364.             writeChar(var0.put(var9.name));
  365.             writeChar(var0.put(var9.sig));
  366.          }
  367.       }
  368.  
  369.       putChar(var1, var0.pp);
  370.    }
  371.  
  372.    public static Name typeSig(Typ var0, boolean var1) {
  373.       switch (var0.tag) {
  374.          case 2:
  375.             return BYTEsig;
  376.          case 3:
  377.          default:
  378.             throw new CompilerError("typeSig");
  379.          case 4:
  380.             return CHARsig;
  381.          case 5:
  382.             return SHORTsig;
  383.          case 6:
  384.             return INTsig;
  385.          case 7:
  386.             return LONGsig;
  387.          case 8:
  388.             return FLOATsig;
  389.          case 9:
  390.             return DOUBLEsig;
  391.          case 10:
  392.             return BOOLEANsig;
  393.          case 11:
  394.             byte[] var2 = new byte[var0.obj.fullname.len + 2];
  395.             var2[0] = 76;
  396.             var0.obj.fullname.copyAscii(var2, 1);
  397.             var2[var2.length - 1] = 59;
  398.             return Name.fromAscii(externalize(var2, 0, var2.length), 0, var2.length);
  399.          case 12:
  400.             return VOIDsig;
  401.          case 13:
  402.             return ARRAYsig.append(typeSig(((ArrayTyp)var0).elemtyp, var1));
  403.          case 14:
  404.             FunTyp var3 = (FunTyp)var0;
  405.             int var4 = var3.argtyps.length + 3;
  406.             if (var1 && var3.thrown != null) {
  407.                var4 = var4 + TypSet.size(var3.thrown) + 2;
  408.             }
  409.  
  410.             Name[] var5 = new Name[var4];
  411.             int var6 = 0;
  412.             var5[var6++] = ARGBEGINsig;
  413.  
  414.             for(int var7 = 0; var7 < var3.argtyps.length; ++var7) {
  415.                var5[var6++] = typeSig(var3.argtyps[var7], var1);
  416.             }
  417.  
  418.             var5[var6++] = ARGENDsig;
  419.             var5[var6++] = typeSig(var3.restyp, var1);
  420.             if (var1 && var3.thrown != null) {
  421.                var5[var6++] = THROWSBEGINsig;
  422.  
  423.                for(TypSet var8 = var3.thrown; var8 != null; var8 = var8.next) {
  424.                   var5[var6++] = typeSig(var8.typ, var1);
  425.                }
  426.  
  427.                var5[var6++] = THROWSENDsig;
  428.             }
  429.  
  430.             return Name.concat(var5);
  431.       }
  432.    }
  433.  
  434.    private static void putChar(int var0, int var1) {
  435.       out[var0] = (byte)(var1 >> 8 & 255);
  436.       out[var0 + 1] = (byte)(var1 & 255);
  437.    }
  438.  
  439.    private static void writeDouble(double var0) {
  440.       ByteArrayOutputStream var2 = new ByteArrayOutputStream(8);
  441.       DataOutputStream var3 = new DataOutputStream(var2);
  442.  
  443.       try {
  444.          var3.writeDouble(var0);
  445.          writeBytes(var2.toByteArray(), 0, 8);
  446.       } catch (IOException var5) {
  447.          throw new CompilerError("write");
  448.       }
  449.    }
  450.  
  451.    private static void writeFloat(float var0) {
  452.       ByteArrayOutputStream var1 = new ByteArrayOutputStream(4);
  453.       DataOutputStream var2 = new DataOutputStream(var1);
  454.  
  455.       try {
  456.          var2.writeFloat(var0);
  457.          writeBytes(var1.toByteArray(), 0, 4);
  458.       } catch (IOException var4) {
  459.          throw new CompilerError("write");
  460.       }
  461.    }
  462.  
  463.    private static void writeLong(long var0) {
  464.       ByteArrayOutputStream var2 = new ByteArrayOutputStream(8);
  465.       DataOutputStream var3 = new DataOutputStream(var2);
  466.  
  467.       try {
  468.          var3.writeLong(var0);
  469.          writeBytes(var2.toByteArray(), 0, 8);
  470.       } catch (IOException var5) {
  471.          throw new CompilerError("write");
  472.       }
  473.    }
  474.  
  475.    private static void writeInt(int var0) {
  476.       if (field_0 + 4 > out.length) {
  477.          doubleOut();
  478.       }
  479.  
  480.       out[field_0++] = (byte)(var0 >> 24 & 255);
  481.       out[field_0++] = (byte)(var0 >> 16 & 255);
  482.       out[field_0++] = (byte)(var0 >> 8 & 255);
  483.       out[field_0++] = (byte)(var0 & 255);
  484.    }
  485.  
  486.    private static void writeChar(int var0) {
  487.       if (field_0 + 2 > out.length) {
  488.          doubleOut();
  489.       }
  490.  
  491.       out[field_0++] = (byte)(var0 >> 8 & 255);
  492.       out[field_0++] = (byte)(var0 & 255);
  493.    }
  494.  
  495.    private static void writeBytes(byte[] var0, int var1, int var2) {
  496.       while(field_0 + var2 > out.length) {
  497.          doubleOut();
  498.       }
  499.  
  500.       System.arraycopy(var0, var1, out, field_0, var2);
  501.       field_0 += var2;
  502.    }
  503.  
  504.    private static void writeByte(int var0) {
  505.       if (field_0 == out.length) {
  506.          doubleOut();
  507.       }
  508.  
  509.       out[field_0++] = (byte)var0;
  510.    }
  511.  
  512.    private static void doubleOut() {
  513.       byte[] var0 = new byte[out.length * 2];
  514.       System.arraycopy(out, 0, var0, 0, out.length);
  515.       out = var0;
  516.    }
  517.  
  518.    public static Scope directory(Name var0) throws IOException {
  519.       ClassObj var1 = loadDir(var0);
  520.       if (var1.scope == null) {
  521.          var1.scope = new Scope((Scope)null, var1);
  522.          String var2 = externalizeFileName(var1.fullname);
  523.          GeneralFile var3 = find(var2);
  524.          Basic.assert(var3.isDirectory());
  525.          String[] var4 = var3.list();
  526.          if (var4 != null) {
  527.             for(int var5 = 0; var5 < var4.length; ++var5) {
  528.                if (var4[var5].endsWith(".class")) {
  529.                   Name var6 = Name.fromString(var4[var5].substring(0, var4[var5].length() - 6));
  530.                   Name var7 = var1.fullname.append(PeriodS).append(var6);
  531.                   var1.scope.enter(new ClassObj(var7, var6));
  532.                }
  533.             }
  534.          }
  535.       }
  536.  
  537.       return var1.scope;
  538.    }
  539.  
  540.    public static ClassObj loadDir(Name var0) throws IOException {
  541.       ClassObj var1 = (ClassObj)loaded.get(var0);
  542.       if (var1 == null) {
  543.          String var2 = externalizeFileName(var0);
  544.          GeneralFile var3 = find(var2);
  545.          if (var3.isDirectory()) {
  546.             var1 = new ClassObj(var0, shortName(var0));
  547.             loaded.put(var0, var1);
  548.          } else {
  549.             loadError(String.valueOf(String.valueOf("directory ").concat(String.valueOf(var2))).concat(String.valueOf(" not found")));
  550.          }
  551.       }
  552.  
  553.       return var1;
  554.    }
  555.  
  556.    public static ClassObj load(Name var0, Name var1) throws LoadError {
  557.       if (var1.pos((byte)46) == var1.len) {
  558.          var1 = var0.append(var1);
  559.       }
  560.  
  561.       todo = new Vector();
  562.       processed = 0;
  563.  
  564.       try {
  565.          ClassObj var2;
  566.          for(var2 = loadClass(var1); processed < todo.size(); ++processed) {
  567.             completeClass((ClassObj)todo.elementAt(processed));
  568.          }
  569.  
  570.          return var2;
  571.       } catch (LoadError var4) {
  572.          throw var4;
  573.       } catch (IOException var5) {
  574.          throw new LoadError(((Throwable)var5).toString());
  575.       }
  576.    }
  577.  
  578.    private static void completeClass(ClassObj var0) throws IOException {
  579.       long var1 = System.currentTimeMillis();
  580.       String var3 = String.valueOf(externalizeFileName(var0.fullname)).concat(String.valueOf(".class"));
  581.       GeneralFile var4 = find(var3);
  582.       if (!var4.exists()) {
  583.          loadError(String.valueOf(String.valueOf("file ").concat(String.valueOf(var3))).concat(String.valueOf(" not found")));
  584.       }
  585.  
  586.       if (Switches.verbose) {
  587.          System.out.print(String.valueOf(String.valueOf("[loading ").concat(String.valueOf(var4.getPath()))).concat(String.valueOf(" ")));
  588.          System.out.flush();
  589.       }
  590.  
  591.       buf = var4.read();
  592.       field_1 = 0;
  593.       loaded.put(var0.fullname, var0);
  594.       readClass(var0);
  595.       if (Switches.verbose) {
  596.          System.out.println(String.valueOf(System.currentTimeMillis() - var1).concat(String.valueOf("ms]")));
  597.       }
  598.  
  599.    }
  600.  
  601.    private static ClassObj loadClass(Name var0) {
  602.       if (var0 == null) {
  603.          return null;
  604.       } else {
  605.          ClassObj var1 = (ClassObj)loaded.get(var0);
  606.          if (var1 == null) {
  607.             int var2;
  608.             for(var2 = processed; var2 < todo.size() && !((ClassObj)todo.elementAt(var2)).fullname.equals(var0); ++var2) {
  609.             }
  610.  
  611.             if (var2 < todo.size()) {
  612.                var1 = (ClassObj)todo.elementAt(var2);
  613.             } else {
  614.                var1 = new ClassObj();
  615.                var1.name = shortName(var0);
  616.                var1.fullname = var0;
  617.                var1.packagename = packageName(var0);
  618.                var1.typ = new Typ(11, var1);
  619.                var1.scope = new Scope((Scope)null, var1);
  620.                var1.interfaces = new ClassObj[0];
  621.                todo.addElement(var1);
  622.             }
  623.          }
  624.  
  625.          return var1;
  626.       }
  627.    }
  628.  
  629.    public static GeneralFile find(String var0) throws LoadError {
  630.       GeneralFile var1 = null;
  631.  
  632.       int var3;
  633.       for(int var2 = 0; (var1 == null || !var1.exists()) && var2 < classPath.length(); var2 = var3 + 1) {
  634.          var3 = classPath.indexOf(pathSep, var2);
  635.          String var4 = classPath.substring(var2, var3);
  636.          var1 = GeneralFile.open(var4, var0);
  637.          if (Switches.printSearch) {
  638.             System.out.println(String.valueOf("searching ").concat(String.valueOf(var1.getPath())));
  639.          }
  640.       }
  641.  
  642.       return var1;
  643.    }
  644.  
  645.    public static GeneralFile findClassFile(String var0) throws LoadError {
  646.       GeneralFile var1 = GeneralFile.open((String)null, var0);
  647.       return var1.exists() ? var1 : find(var0);
  648.    }
  649.  
  650.    private static void readClass(ClassObj var0) throws LoadError {
  651.       int var1 = nextInt();
  652.       if (var1 != -889275714) {
  653.          loadError("bad class file");
  654.       }
  655.  
  656.       char var2 = nextChar();
  657.       char var3 = nextChar();
  658.       if (var3 != '-' || var2 < 3) {
  659.          loadError(String.valueOf(String.valueOf(String.valueOf(String.valueOf(String.valueOf(String.valueOf(String.valueOf("class file has wrong version ").concat(String.valueOf(var3))).concat(String.valueOf("."))).concat(String.valueOf(var2))).concat(String.valueOf(", should be "))).concat(String.valueOf(45))).concat(String.valueOf("."))).concat(String.valueOf(3)));
  660.       }
  661.  
  662.       indexPool();
  663.       var0.modifiers = nextChar();
  664.       Name var4 = readClassName();
  665.       if (!var0.fullname.equals(var4)) {
  666.          loadError(String.valueOf(String.valueOf(String.valueOf("class file: ").concat(String.valueOf(var0.fullname))).concat(String.valueOf(" contains wrong class: "))).concat(String.valueOf(var4)));
  667.       }
  668.  
  669.       var0.superclass = loadClass(readClassName());
  670.       var0.interfaces = new ClassObj[nextChar()];
  671.  
  672.       for(int var5 = 0; var5 < var0.interfaces.length; ++var5) {
  673.          var0.interfaces[var5] = loadClass(readClassName());
  674.       }
  675.  
  676.       char var6 = nextChar();
  677.  
  678.       for(int var7 = 0; var7 < var6; ++var7) {
  679.          var0.scope.enter(readField());
  680.       }
  681.  
  682.       char var8 = nextChar();
  683.  
  684.       for(int var9 = 0; var9 < var8; ++var9) {
  685.          FunObj var10 = readMethod();
  686.          if (var10.name.startsWith(closureS)) {
  687.             ++var0.nclosures;
  688.          }
  689.  
  690.          var0.scope.enter(var10);
  691.       }
  692.  
  693.       char var11 = nextChar();
  694.  
  695.       for(int var12 = 0; var12 < var11; ++var12) {
  696.          Name var13 = (Name)readPool(nextChar());
  697.          int var14 = nextInt();
  698.          if (var13.index == SourceFileS.index) {
  699.             var0.sourcefile = (Name)readPool(nextChar());
  700.          } else {
  701.             unrecogized(var13);
  702.             field_1 += var14;
  703.          }
  704.       }
  705.  
  706.    }
  707.  
  708.    private static FunObj readMethod() throws LoadError {
  709.       char var0 = nextChar();
  710.       Name var1 = (Name)readPool(nextChar());
  711.       FunTyp var2 = (FunTyp)readType(nextChar());
  712.       FunObj var3 = new FunObj(var0, var1, var2);
  713.       char var4 = nextChar();
  714.  
  715.       for(int var5 = 0; var5 < var4; ++var5) {
  716.          Name var6 = (Name)readPool(nextChar());
  717.          int var7 = nextInt();
  718.          if (var6.index == CodeS.index) {
  719.             field_1 += var7;
  720.          } else if (var6.index == ExceptionsS.index) {
  721.             char var8 = nextChar();
  722.  
  723.             for(int var9 = 0; var9 < var8; ++var9) {
  724.                Name var10 = readClassName();
  725.                var2.thrown = TypSet.incl(var2.thrown, loadClass(var10).typ);
  726.             }
  727.          } else if (var6.index == FullTypeS.index) {
  728.             var3.alttyp = var3.typ;
  729.             var3.typ = readType(nextChar());
  730.          } else {
  731.             unrecogized(var6);
  732.             field_1 += var7;
  733.          }
  734.       }
  735.  
  736.       return var3;
  737.    }
  738.  
  739.    private static VarObj readField() throws LoadError {
  740.       char var0 = nextChar();
  741.       Name var1 = (Name)readPool(nextChar());
  742.       Typ var2 = readType(nextChar());
  743.       VarObj var3 = new VarObj(var0, var1, var2);
  744.       char var4 = nextChar();
  745.  
  746.       for(int var5 = 0; var5 < var4; ++var5) {
  747.          Name var6 = (Name)readPool(nextChar());
  748.          int var7 = nextInt();
  749.          if (var6.index == ConstantValueS.index) {
  750.             var3.value = readPool(nextChar());
  751.             if (var3.value instanceof NameRef) {
  752.                var3.value = ((NameRef)var3.value).name;
  753.             }
  754.          } else if (var6.index == FullTypeS.index) {
  755.             var3.alttyp = var3.typ;
  756.             var3.typ = readType(nextChar());
  757.          } else {
  758.             unrecogized(var6);
  759.             field_1 += var7;
  760.          }
  761.       }
  762.  
  763.       return var3;
  764.    }
  765.  
  766.    private static Name readClassName() {
  767.       char var0 = nextChar();
  768.       return var0 == 0 ? null : ((NameRef)readPool(var0)).name;
  769.    }
  770.  
  771.    private static Code readCode(Obj var0) throws LoadError {
  772.       Code var1 = new Code(var0, var0.name.equals(Basic.clinitS), false);
  773.       var1.max_stack = nextChar();
  774.       var1.max_locals = nextChar();
  775.       var1.cp = nextInt();
  776.       var1.code = new byte[var1.cp];
  777.       System.arraycopy(buf, field_1, var1.code, 0, var1.cp);
  778.       var1.ncatches = nextChar();
  779.       var1.exc_start_pc = new char[var1.ncatches];
  780.       var1.exc_end_pc = new char[var1.ncatches];
  781.       var1.exc_handler_pc = new char[var1.ncatches];
  782.       var1.exc_catch_type = new char[var1.ncatches];
  783.  
  784.       for(int var2 = 0; var2 < var1.ncatches; ++var2) {
  785.          var1.exc_start_pc[var2] = nextChar();
  786.          var1.exc_end_pc[var2] = nextChar();
  787.          var1.exc_handler_pc[var2] = nextChar();
  788.          var1.exc_catch_type[var2] = nextChar();
  789.       }
  790.  
  791.       char var3 = nextChar();
  792.  
  793.       for(int var4 = 0; var4 < var3; ++var4) {
  794.          Name var5 = (Name)readPool(nextChar());
  795.          int var6 = nextInt();
  796.          if (var5.index == LineNumberTableS.index) {
  797.             var1.nlines = nextChar();
  798.             var1.line_start_pc = new char[var1.nlines];
  799.             var1.line_number = new char[var1.nlines];
  800.  
  801.             for(int var7 = 0; var7 < var1.nlines; ++var7) {
  802.                var1.line_start_pc[var7] = nextChar();
  803.                var1.line_number[var7] = nextChar();
  804.             }
  805.          } else if (var5.index == LocalVariableTableS.index) {
  806.             var1.nvars = nextChar();
  807.             var1.lvar_start_pc = new char[var1.nvars];
  808.             var1.lvar_end_pc = new char[var1.nvars];
  809.             var1.lvar = new VarObj[var1.nvars];
  810.  
  811.             for(int var8 = 0; var8 < var1.nvars; ++var8) {
  812.                var1.lvar_start_pc[var8] = nextChar();
  813.                var1.lvar_end_pc[var8] = (char)(var1.lvar_start_pc[var8] + nextChar());
  814.                var1.lvar[var8] = new VarObj(0, (Name)readPool(nextChar()), readType(nextChar()));
  815.                var1.lvar[var8].adr = nextChar();
  816.             }
  817.          } else {
  818.             unrecogized(var5);
  819.             field_1 += var6;
  820.          }
  821.       }
  822.  
  823.       return var1;
  824.    }
  825.  
  826.    private static Typ readType(int var0) throws LoadError {
  827.       return sig2type(internalize(buf, poolIdx[var0] + 3, getChar(poolIdx[var0] + 1)), 0);
  828.    }
  829.  
  830.    private static Typ sig2type(byte[] var0, int var1) throws LoadError {
  831.       switch (var0[var1]) {
  832.          case 66:
  833.             return Typ.byteTyp;
  834.          case 67:
  835.             return Typ.charTyp;
  836.          case 68:
  837.             return Typ.doubleTyp;
  838.          case 70:
  839.             return Typ.floatTyp;
  840.          case 73:
  841.             return Typ.intTyp;
  842.          case 74:
  843.             return Typ.longTyp;
  844.          case 76:
  845.             return loadClass(Name.fromAscii(var0, var1 + 1, sigLen(var0, var1) - 2)).typ;
  846.          case 83:
  847.             return Typ.shortTyp;
  848.          case 86:
  849.             return Typ.voidTyp;
  850.          case 90:
  851.             return Typ.booleanTyp;
  852.          case 91:
  853.             ++var1;
  854.  
  855.             while(48 <= var0[var1] && var0[var1] <= 57) {
  856.                ++var1;
  857.             }
  858.  
  859.             return new ArrayTyp(sig2type(var0, var1));
  860.          case 40:
  861.             ++var1;
  862.             Typ[] var2 = new Typ[6];
  863.  
  864.             int var3;
  865.             for(var3 = 0; var0[var1] != 41; var1 += sigLen(var0, var1)) {
  866.                if (var3 == var2.length) {
  867.                   Typ[] var4 = new Typ[var2.length * 2];
  868.                   System.arraycopy(var2, 0, var4, 0, var2.length);
  869.                   var2 = var4;
  870.                }
  871.  
  872.                var2[var3++] = sig2type(var0, var1);
  873.             }
  874.  
  875.             ++var1;
  876.             Typ[] var5 = new Typ[var3];
  877.             System.arraycopy(var2, 0, var5, 0, var3);
  878.             Typ var6 = sig2type(var0, var1);
  879.             var1 += sigLen(var0, var1);
  880.             TypSet var7 = null;
  881.             if (var1 < var0.length && var0[var1] == 60) {
  882.                ++var1;
  883.  
  884.                while(var0[var1] != 62) {
  885.                   var7 = TypSet.incl(var7, sig2type(var0, var1));
  886.                   var1 += sigLen(var0, var1);
  887.                }
  888.             }
  889.  
  890.             return new FunTyp(var5, var6, var7);
  891.          default:
  892.             loadError(String.valueOf("bad signature: ").concat(String.valueOf(Convert.ascii2string(var0, var1, sigLen(var0, var1)))));
  893.             return null;
  894.       }
  895.    }
  896.  
  897.    private static int sigLen(byte[] var0, int var1) {
  898.       switch (var0[var1]) {
  899.          case 66:
  900.          case 67:
  901.          case 68:
  902.          case 70:
  903.          case 73:
  904.          case 74:
  905.          case 83:
  906.          case 86:
  907.          case 90:
  908.             return 1;
  909.          case 76:
  910.             int var2;
  911.             for(var2 = 1; var0[var1 + var2] != 59; ++var2) {
  912.             }
  913.  
  914.             return var2 + 1;
  915.          case 91:
  916.             int var3;
  917.             for(var3 = 1; 48 <= var0[var1 + var3] && var0[var1 + var3] <= 57; ++var3) {
  918.             }
  919.  
  920.             return var3 + sigLen(var0, var1 + var3);
  921.          case 40:
  922.             int var4;
  923.             for(var4 = 1; var0[var1 + var4] != 41; ++var4) {
  924.             }
  925.  
  926.             return var4 + 1 + sigLen(var0, var1 + var4 + 1);
  927.          default:
  928.             return 10;
  929.       }
  930.    }
  931.  
  932.    private static Name readExternal(int var0) {
  933.       if (poolObj[var0] == null) {
  934.          int var1 = poolIdx[var0];
  935.          if (buf[var1] == 1) {
  936.             char var2 = getChar(var1 + 1);
  937.             byte[] var3 = internalize(buf, var1 + 3, var2);
  938.             poolObj[var0] = Name.fromAscii(var3, 0, var2);
  939.          }
  940.       }
  941.  
  942.       return (Name)poolObj[var0];
  943.    }
  944.  
  945.    private static Object readPool(int var0) {
  946.       if (poolObj[var0] == null) {
  947.          int var1 = poolIdx[var0];
  948.          byte var2 = buf[var1];
  949.          switch (var2) {
  950.             case 1:
  951.                poolObj[var0] = Name.fromAscii(buf, var1 + 3, getChar(var1 + 1));
  952.                break;
  953.             case 2:
  954.                throw new CompilerError("can't read unicode strings in class files");
  955.             case 3:
  956.                poolObj[var0] = new Integer(getInt(var1 + 1));
  957.                break;
  958.             case 4:
  959.                poolObj[var0] = new Float(getFloat(var1 + 1));
  960.                break;
  961.             case 5:
  962.                poolObj[var0] = new Long(getLong(var1 + 1));
  963.                break;
  964.             case 6:
  965.                poolObj[var0] = new Double(getDouble(var1 + 1));
  966.                break;
  967.             case 7:
  968.                poolObj[var0] = new NameRef(var2, readExternal(getChar(var1 + 1)));
  969.                break;
  970.             case 8:
  971.                poolObj[var0] = new NameRef(var2, (Name)readPool(getChar(var1 + 1)));
  972.                break;
  973.             case 9:
  974.             case 10:
  975.             case 11:
  976.                poolObj[var0] = new Reference(var2, (NameRef)readPool(getChar(var1 + 1)), (NameAndType)readPool(getChar(var1 + 3)));
  977.                break;
  978.             case 12:
  979.                poolObj[var0] = new NameAndType((Name)readPool(getChar(var1 + 1)), readExternal(getChar(var1 + 3)));
  980.                break;
  981.             default:
  982.                throw new CompilerError(String.valueOf("bad constant pool tag: ").concat(String.valueOf(var2)));
  983.          }
  984.       }
  985.  
  986.       return poolObj[var0];
  987.    }
  988.  
  989.    private static void indexPool() throws LoadError {
  990.       poolIdx = new int[nextChar()];
  991.       poolObj = new Object[poolIdx.length];
  992.       int var0 = 1;
  993.  
  994.       while(var0 < poolIdx.length) {
  995.          poolIdx[var0++] = field_1;
  996.          byte var1 = buf[field_1++];
  997.          switch (var1) {
  998.             case 1:
  999.             case 2:
  1000.                char var2 = nextChar();
  1001.                field_1 += var2;
  1002.                break;
  1003.             case 3:
  1004.             case 4:
  1005.             case 9:
  1006.             case 10:
  1007.             case 11:
  1008.             case 12:
  1009.                field_1 += 4;
  1010.                break;
  1011.             case 5:
  1012.             case 6:
  1013.                field_1 += 8;
  1014.                ++var0;
  1015.                break;
  1016.             case 7:
  1017.             case 8:
  1018.                field_1 += 2;
  1019.                break;
  1020.             default:
  1021.                throw new LoadError(String.valueOf("bad constant pool tag: ").concat(String.valueOf(var1)));
  1022.          }
  1023.       }
  1024.  
  1025.    }
  1026.  
  1027.    private static double getDouble(int var0) {
  1028.       DataInputStream var1 = new DataInputStream(new ByteArrayInputStream(buf, var0, 8));
  1029.  
  1030.       try {
  1031.          return var1.readDouble();
  1032.       } catch (IOException var3) {
  1033.          throw new CompilerError("get");
  1034.       }
  1035.    }
  1036.  
  1037.    private static float getFloat(int var0) {
  1038.       DataInputStream var1 = new DataInputStream(new ByteArrayInputStream(buf, var0, 4));
  1039.  
  1040.       try {
  1041.          return var1.readFloat();
  1042.       } catch (IOException var3) {
  1043.          throw new CompilerError("get");
  1044.       }
  1045.    }
  1046.  
  1047.    private static long getLong(int var0) {
  1048.       DataInputStream var1 = new DataInputStream(new ByteArrayInputStream(buf, var0, 8));
  1049.  
  1050.       try {
  1051.          return var1.readLong();
  1052.       } catch (IOException var3) {
  1053.          throw new CompilerError("get");
  1054.       }
  1055.    }
  1056.  
  1057.    private static int getInt(int var0) {
  1058.       return ((buf[var0] & 255) << 24) + ((buf[var0 + 1] & 255) << 16) + ((buf[var0 + 2] & 255) << 8) + (buf[var0 + 3] & 255);
  1059.    }
  1060.  
  1061.    private static char getChar(int var0) {
  1062.       return (char)(((buf[var0] & 255) << 8) + (buf[var0 + 1] & 255));
  1063.    }
  1064.  
  1065.    private static int nextInt() {
  1066.       return ((buf[field_1++] & 255) << 24) + ((buf[field_1++] & 255) << 16) + ((buf[field_1++] & 255) << 8) + (buf[field_1++] & 255);
  1067.    }
  1068.  
  1069.    private static char nextChar() {
  1070.       return (char)(((buf[field_1++] & 255) << 8) + (buf[field_1++] & 255));
  1071.    }
  1072.  
  1073.    static Name packageName(Name var0) {
  1074.       int var1 = var0.lastPos((byte)46);
  1075.       return var1 < 0 ? emptyS : var0.subName(0, var1).append(PeriodS);
  1076.    }
  1077.  
  1078.    static Name shortName(Name var0) {
  1079.       return var0.subName(var0.lastPos((byte)46) + 1, var0.len);
  1080.    }
  1081.  
  1082.    static String externalizeFileName(Name var0) {
  1083.       byte[] var1 = var0.toAscii();
  1084.       String var2 = Convert.ascii2string(var1, 0, var1.length);
  1085.       return var2.replace('.', File.separatorChar);
  1086.    }
  1087.  
  1088.    static Name internalizeFileName(String var0) {
  1089.       byte[] var1 = Convert.string2ascii(var0.replace(File.separatorChar, '.'));
  1090.       return Name.fromAscii(var1, 0, var1.length);
  1091.    }
  1092.  
  1093.    private static byte[] externalize(byte[] var0, int var1, int var2) {
  1094.       byte[] var3 = new byte[var2];
  1095.  
  1096.       for(int var4 = 0; var4 < var2; ++var4) {
  1097.          byte var5 = var0[var1 + var4];
  1098.          if (var5 == 46) {
  1099.             var3[var4] = 47;
  1100.          } else {
  1101.             var3[var4] = var5;
  1102.          }
  1103.       }
  1104.  
  1105.       return var3;
  1106.    }
  1107.  
  1108.    private static byte[] internalize(byte[] var0, int var1, int var2) {
  1109.       byte[] var3 = new byte[var2];
  1110.  
  1111.       for(int var4 = 0; var4 < var2; ++var4) {
  1112.          byte var5 = var0[var1 + var4];
  1113.          if (var5 == 47) {
  1114.             var3[var4] = 46;
  1115.          } else {
  1116.             var3[var4] = var5;
  1117.          }
  1118.       }
  1119.  
  1120.       return var3;
  1121.    }
  1122.  
  1123.    private static void unrecogized(Name var0) {
  1124.    }
  1125.  
  1126.    private static void exceeded(String var0) throws StoreError {
  1127.       throw new StoreError(String.valueOf(var0).concat(String.valueOf(" exceeded")));
  1128.    }
  1129.  
  1130.    private static void loadError(String var0) throws LoadError {
  1131.       throw new LoadError(var0);
  1132.    }
  1133.  
  1134.    public ClassFile() {
  1135.    }
  1136. }
  1137.