home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 27 / CDROM27.iso / share / wnt / jig / data1.cab / Program_Executable_Files / lib / jig.jar / BrowserFileLoader.class (.txt) < prev    next >
Encoding:
Java Class File  |  1998-08-19  |  12.2 KB  |  862 lines
  1. import java.io.BufferedReader;
  2. import java.io.DataOutputStream;
  3. import java.io.EOFException;
  4. import java.io.File;
  5. import java.io.FileInputStream;
  6. import java.io.FileNotFoundException;
  7. import java.io.FileOutputStream;
  8. import java.io.FilenameFilter;
  9. import java.io.FilterOutputStream;
  10. import java.io.IOException;
  11. import java.io.InputStreamReader;
  12. import java.io.StreamTokenizer;
  13. import java.io.StringReader;
  14. import java.util.Observable;
  15.  
  16. class BrowserFileLoader extends Observable {
  17.    private FilenameFilter filter;
  18.    private File cwd;
  19.    private String rootDir;
  20.    private String[] results;
  21.    private int resultsCount;
  22.    private static int resultsIncrement = 512;
  23.    private static String extension = ".java";
  24.    private MethodRecord[] classMethodList;
  25.    private String[] classFiles;
  26.    private boolean[] changes;
  27.    static int PackageLoad;
  28.    static int ClassLoad = 1;
  29.    static int MethodLoad = 2;
  30.    static int PartialsFound = 3;
  31.    static int MaxChanges = 4;
  32.    private String classFileName;
  33.    boolean partialClassesExist = false;
  34.  
  35.    BrowserFileLoader(String var1) {
  36.       this.rootDir = var1;
  37.    }
  38.  
  39.    private String GetRootDir() {
  40.       return this.rootDir;
  41.    }
  42.  
  43.    public static String subdir(String var0, String var1) {
  44.       int var2 = var1.length();
  45.       String var3 = correctPackageName(var0);
  46.       return var3.length() >= var2 ? var3.substring(var2) + "." : "";
  47.    }
  48.  
  49.    public static String noext(String var0, String var1) {
  50.       int var2 = var0.length() - var1.length();
  51.       return var0.substring(0, var2);
  52.    }
  53.  
  54.    public String[] ListDirectory() {
  55.       this.resultsCount = 0;
  56.       this.results = new String[resultsIncrement];
  57.  
  58.       try {
  59.          this.list_directory(this.rootDir, (FilenameFilter)null, 0, true);
  60.       } catch (IOException var4) {
  61.       }
  62.  
  63.       int var1;
  64.       for(var1 = 0; this.results[var1] != null; ++var1) {
  65.       }
  66.  
  67.       String[] var2 = new String[var1];
  68.  
  69.       for(int var3 = 0; var3 < var1; ++var3) {
  70.          var2[var3] = this.results[var3];
  71.       }
  72.  
  73.       this.results = null;
  74.       return var2;
  75.    }
  76.  
  77.    public String[] ListFiles(String var1) {
  78.       EndsWithFilter var2 = new EndsWithFilter(".java");
  79.       this.resultsCount = 0;
  80.       this.results = new String[resultsIncrement];
  81.  
  82.       try {
  83.          this.list_directory(var1, var2, 0, false);
  84.       } catch (IOException var6) {
  85.       }
  86.  
  87.       int var3;
  88.       for(var3 = 0; this.results[var3] != null; ++var3) {
  89.       }
  90.  
  91.       String[] var4 = new String[var3];
  92.  
  93.       for(int var5 = 0; var5 < var3; ++var5) {
  94.          var4[var5] = this.results[var5];
  95.       }
  96.  
  97.       return var4;
  98.    }
  99.  
  100.    private String[] list_directory(String var1, FilenameFilter var2, int var3, boolean var4) throws IOException {
  101.       File var5 = new File(var1);
  102.       if (!var5.isDirectory()) {
  103.          throw new IllegalArgumentException(BrowserOptions.messages.getString("ListDirect") + var5);
  104.       } else {
  105.          String[] var6 = var5.list(var2);
  106.  
  107.          for(int var7 = 0; var7 < var6.length; ++var7) {
  108.             if (var4 && this.test_info(var5, var6[var7])) {
  109.                this.results[this.resultsCount++] = subdir(var1, this.rootDir) + correctPackageName(var6[var7]);
  110.                this.resizeResults();
  111.             }
  112.  
  113.             if (!var4 && !this.test_info(var5, var6[var7])) {
  114.                this.results[this.resultsCount++] = subdir(var1, this.rootDir) + noext(var6[var7], extension);
  115.                this.resizeResults();
  116.             }
  117.  
  118.             if (var4 && this.test_info(var5, var6[var7])) {
  119.                this.list_directory(var1 + System.getProperty("file.separator") + var6[var7], var2, 1 + var3, var4);
  120.             }
  121.          }
  122.  
  123.          return this.results;
  124.       }
  125.    }
  126.  
  127.    public boolean test_info(File var1, String var2) throws IOException {
  128.       File var3 = new File(var1, var2);
  129.       if (!var3.exists()) {
  130.          System.out.println(BrowserOptions.messages.getString("NoSuchFile") + " " + var1 + ", " + var2);
  131.          return false;
  132.       } else {
  133.          return var3.isDirectory();
  134.       }
  135.    }
  136.  
  137.    private String getClassName(String var1) {
  138.       return this.minorClassName(var1.substring(var1.lastIndexOf(46) + 1));
  139.    }
  140.  
  141.    private String getFileName(String var1) {
  142.       return this.rootDir + correctFileName(var1) + ".java";
  143.    }
  144.  
  145.    public String[] loadClassPart(String var1, MethodRecord[] var2) {
  146.       int[] var3 = MethodRecord.getClassDefn(this.minorClassName(var1.substring(var1.lastIndexOf(46) + 1)), this.classMethodList);
  147.       return this.loadSourceLines(this.classFileName(), var3[0], var3[1] - 1);
  148.    }
  149.  
  150.    public String[] loadClassEnd(String var1, MethodRecord[] var2) {
  151.       int[] var3 = MethodRecord.getClassDefn(this.minorClassName(var1.substring(var1.lastIndexOf(46) + 1)), this.classMethodList);
  152.       return this.loadSourceLines(this.classFileName(), var3[2], var3[3] - 1);
  153.    }
  154.  
  155.    private static int findClassEnd(String var0) {
  156.       byte[] var1 = var0.getBytes();
  157.       int var3 = 0;
  158.  
  159.       for(int var2 = var1.length - 1; var2 >= 0; --var2) {
  160.          byte var4 = var1[var2];
  161.          if (var4 == 10 && var3 == 1) {
  162.             return var2;
  163.          }
  164.  
  165.          if (var4 == 125) {
  166.             ++var3;
  167.          }
  168.       }
  169.  
  170.       return var1.length;
  171.    }
  172.  
  173.    public void saveClassDef(String var1, boolean var2, String var3) {
  174.       int var4 = findClassEnd(var3);
  175.       if (var3.charAt(var3.length() - 1) != '\n') {
  176.          var3 = var3.concat("\n");
  177.       }
  178.  
  179.       if (var2) {
  180.          this.saveClass(var1, (int[])null, var3.substring(0, var4), var3.substring(var4 + 1, var3.length() - 1));
  181.       } else {
  182.          this.saveClass(var1, MethodRecord.getClassBorders(this.minorClassName(var1.substring(var1.lastIndexOf(46) + 1)), this.classMethodList), var3.substring(0, var4), var3.substring(var4 + 1, var3.length() - 1));
  183.       }
  184.    }
  185.  
  186.    public String[] loadMethod(String var1, MethodRecord[] var2, int var3) {
  187.       String[] var4 = null;
  188.       if (this.classFileName() != null) {
  189.          try {
  190.             var4 = this.loadSourceLines(this.classFileName(), var2[var3].commentStartRow(), var2[var3].endRow);
  191.          } catch (ArrayIndexOutOfBoundsException var5) {
  192.          }
  193.       }
  194.  
  195.       return var4;
  196.    }
  197.  
  198.    public MethodRecord[] loadClassFile(String var1) {
  199.       MethodRecord[] var2 = new MethodRecord[512];
  200.       this.minorClassName(var1.substring(var1.lastIndexOf(46) + 1));
  201.       String var3 = this.getFileName(var1);
  202.       int var4 = 0;
  203.       int var5 = 0;
  204.       this.classFileName = var1;
  205.  
  206.       try {
  207.          FileInputStream var6 = new FileInputStream(var3);
  208.          StreamTokenizer var7 = new StreamTokenizer(var6);
  209.          String var8 = "";
  210.          int var9 = 0;
  211.          boolean var10 = false;
  212.          boolean var11 = false;
  213.          String var12 = null;
  214.          int var13 = -1;
  215.          String[] var14 = new String[16];
  216.          int var15 = 0;
  217.          int[] var16 = new int[16];
  218.          int var17 = 0;
  219.          var7.wordChars(95, 95);
  220.          if (!BrowserOptions.specialSystem[1].equalsIgnoreCase("ordinary slash")) {
  221.             var7.ordinaryChar(47);
  222.          }
  223.  
  224.          var7.slashStarComments(true);
  225.          var7.slashSlashComments(true);
  226.  
  227.          try {
  228.             while(var7.nextToken() != -1) {
  229.                var5 = var7.lineno();
  230.                switch ((char)var7.ttype) {
  231.                   case '(':
  232.                      if (var15 == var9) {
  233.                         var11 = true;
  234.                         var12 = var8;
  235.                         var13 = var17 >= 0 ? var17 + 1 : var7.lineno();
  236.                         var17 = -1;
  237.                      }
  238.                      break;
  239.                   case ';':
  240.                      if (var15 == var9 && var11) {
  241.                         var11 = false;
  242.                      }
  243.                      break;
  244.                   case '{':
  245.                      if (var15 == var9 && var11) {
  246.                         var11 = false;
  247.                         var10 = true;
  248.                         var2[var4++] = new MethodRecord(var12, var13, 0);
  249.                         var2[var4 - 1].className = var14[var15 - 1];
  250.                         var2[var4 - 1].inner = var15 - 1;
  251.                      }
  252.  
  253.                      ++var9;
  254.                      break;
  255.                   case '}':
  256.                      --var9;
  257.                      if (var15 == var9 && var10) {
  258.                         var10 = false;
  259.                         var2[var4 - 1].setEndRow(var7.lineno());
  260.                         var17 = var7.lineno();
  261.                      }
  262.  
  263.                      if (var9 + 1 == var15) {
  264.                         --var15;
  265.                         var2[var16[var15]].setEndRow(var7.lineno());
  266.                         var17 = var7.lineno();
  267.                      }
  268.                      break;
  269.                   case '∩┐╜':
  270.                      var8 = var7.sval;
  271.                      if (var9 == 0 && (var8.equalsIgnoreCase("class") || var8.equalsIgnoreCase("interface"))) {
  272.                         var7.nextToken();
  273.                         var14[var15] = var7.sval;
  274.                         var16[var15] = var4;
  275.                         var2[var4] = new MethodRecord((String)null, var17 >= 0 ? var17 + 1 : var7.lineno(), 0);
  276.                         var2[var4].className = var14[var15];
  277.                         var2[var4].inner = var15;
  278.                         ++var4;
  279.                         ++var15;
  280.                         var17 = -1;
  281.                      }
  282.  
  283.                      if (var9 >= 1 && !var10 && var8.equalsIgnoreCase("class")) {
  284.                         var7.nextToken();
  285.                         var14[var15] = var7.sval;
  286.                         var16[var15] = var4;
  287.                         var2[var4] = new MethodRecord((String)null, var17 >= 0 ? var17 + 1 : var7.lineno(), 0);
  288.                         var2[var4].className = var14[var15];
  289.                         var2[var4].inner = var15;
  290.                         ++var4;
  291.                         ++var15;
  292.                         var17 = -1;
  293.                      }
  294.                }
  295.             }
  296.          } catch (EOFException var18) {
  297.          }
  298.  
  299.          var6.close();
  300.       } catch (FileNotFoundException var19) {
  301.          System.err.println("loadClassFile: " + var19);
  302.          return null;
  303.       } catch (IOException var20) {
  304.          System.err.println("loadClassFile: " + var20);
  305.       }
  306.  
  307.       MethodRecord[] var22 = new MethodRecord[var4];
  308.  
  309.       for(int var23 = 0; var23 < var4; ++var23) {
  310.          var22[var23] = var2[var23];
  311.       }
  312.  
  313.       int var24 = 0;
  314.       int var25 = 0;
  315.       Object var26 = null;
  316.  
  317.       for(int var29 = 0; var29 < var22.length; ++var29) {
  318.          if (var24 > 0 && var22[var29].inner() == var25 && var22[var29].methodName() != null) {
  319.             String[] var27 = this.loadSourceLines(var1, var24, var22[var29].endRow());
  320.             var22[var29].locateFirstMethodComment(var27, var24);
  321.             var24 = 0;
  322.          }
  323.  
  324.          if (var22[var29].methodName() == null) {
  325.             if (var24 > 0 && var22[var29].inner() > var25) {
  326.                String[] var28 = this.loadSourceLines(var1, var24, var22[var29].endRow());
  327.                var22[var29].locateFirstMethodComment(var28, var24);
  328.             }
  329.  
  330.             var24 = var22[var29].startRow();
  331.             var25 = var22[var29].inner();
  332.          }
  333.       }
  334.  
  335.       for(int var30 = 0; var30 < var22.length; ++var30) {
  336.          if (var22[var30].methodName() == null) {
  337.             if (var30 + 1 == var22.length) {
  338.                var22[var30].defnEndRow = var22[var30].endRow - 1;
  339.                break;
  340.             }
  341.  
  342.             var22[var30].defnEndRow = var22[var30 + 1].commentStartRow() - 1;
  343.             if (var22[var30].endRow == var22[var30].defnEndRow) {
  344.                --var22[var30].defnEndRow;
  345.             }
  346.          }
  347.       }
  348.  
  349.       this.classMethodList = var22;
  350.       int var31 = MethodRecord.classList(var22).length;
  351.       boolean var32 = this.partialClassesExist;
  352.       if (var31 > 1) {
  353.          this.partialClassesExist = true;
  354.       } else {
  355.          this.partialClassesExist = false;
  356.       }
  357.  
  358.       if (var32 || var31 > 1) {
  359.          this.changes = new boolean[MaxChanges];
  360.          this.changes[ClassLoad] = true;
  361.          this.changes[PartialsFound] = true;
  362.          boolean[] var33 = this.changes;
  363.          ((Observable)this).setChanged();
  364.          ((Observable)this).notifyObservers(var33);
  365.       }
  366.  
  367.       return var22;
  368.    }
  369.  
  370.    public String[] loadSourceLines(String var1, int var2, int var3) {
  371.       String[] var4 = new String[3000];
  372.       this.minorClassName(var1.substring(var1.lastIndexOf(46) + 1));
  373.       String var5 = this.getFileName(var1);
  374.       int var6 = 0;
  375.  
  376.       try {
  377.          BufferedReader var7 = new BufferedReader(new InputStreamReader(new FileInputStream(new File(var5))));
  378.          int var8 = 0;
  379.  
  380.          try {
  381.             while(true) {
  382.                String var9 = var7.readLine();
  383.                ++var8;
  384.                if (var9 == null) {
  385.                   break;
  386.                }
  387.  
  388.                if (var8 >= var2 && var8 <= var3) {
  389.                   var4[var6++] = var9;
  390.                }
  391.             }
  392.          } catch (EOFException var10) {
  393.          } catch (ArrayIndexOutOfBoundsException var11) {
  394.          }
  395.  
  396.          var7.close();
  397.       } catch (FileNotFoundException var12) {
  398.          System.err.println("loadSourceLines: " + var12);
  399.       } catch (IOException var13) {
  400.          System.err.println("loadSourceLines: " + var13);
  401.       }
  402.  
  403.       String[] var14 = new String[var6];
  404.  
  405.       for(int var15 = 0; var15 < var6; ++var15) {
  406.          var14[var15] = var4[var15];
  407.       }
  408.  
  409.       return var14;
  410.    }
  411.  
  412.    public void saveMethod(String var1, MethodRecord[] var2, int var3, String var4) {
  413.       Object var5 = null;
  414.       Object var6 = null;
  415.       this.minorClassName(var1.substring(var1.lastIndexOf(46) + 1));
  416.       String var7 = this.getFileName(var1);
  417.       int var8 = 0;
  418.       int var9 = 0;
  419.       var4 = this.fixMethodEnd(var4);
  420.       if (var3 == -1) {
  421.          int var10 = MethodRecord.FindLast(var2);
  422.          if (var10 == -1) {
  423.             var8 = -1;
  424.             var9 = 2000;
  425.          } else {
  426.             var8 = var2[var10].endRow() + 1;
  427.             var9 = var2[var10].endRow();
  428.          }
  429.       } else {
  430.          var8 = var2[var3].endRow() + 1;
  431.          if (var3 == MethodRecord.FindFirst(var2)) {
  432.             var9 = var2[var3].commentStartRow() - 1;
  433.          } else {
  434.             var9 = var2[MethodRecord.FindPrevious(var2, var3)].endRow();
  435.          }
  436.       }
  437.  
  438.       String[] var18 = this.loadSourceLines(var1, 1, var9);
  439.       String[] var19;
  440.       if (var8 == -1) {
  441.          int var11 = var18.length;
  442.  
  443.          for(int var22 = var18.length - 1; var22 >= 0; --var22) {
  444.             if (var18[var22].indexOf(125) != -1) {
  445.                var11 = var22;
  446.                break;
  447.             }
  448.          }
  449.  
  450.          String[] var12 = var18;
  451.          var18 = new String[var11];
  452.  
  453.          int var23;
  454.          for(var23 = 0; var23 < var11; ++var23) {
  455.             var18[var23] = var12[var23];
  456.          }
  457.  
  458.          var19 = new String[var12.length - var18.length];
  459.  
  460.          for(int var13 = 0; var23 < var12.length; ++var13) {
  461.             var19[var13] = var12[var23];
  462.             ++var23;
  463.          }
  464.       } else {
  465.          var19 = this.loadSourceLines(var1, var8, 2000);
  466.       }
  467.  
  468.       try {
  469.          DataOutputStream var24 = new DataOutputStream(new FileOutputStream(var7));
  470.  
  471.          for(int var25 = 0; var25 < var18.length; ++var25) {
  472.             var24.writeBytes(var18[var25]);
  473.             var24.writeBytes(System.getProperty("line.separator"));
  474.          }
  475.  
  476.          StringReader var26 = new StringReader(var4);
  477.          int var27 = 0;
  478.  
  479.          while((var27 = var26.read()) != -1) {
  480.             switch (var27) {
  481.                case 10:
  482.                   var24.writeBytes(System.getProperty("line.separator"));
  483.                   break;
  484.                default:
  485.                   var24.write(var27);
  486.             }
  487.          }
  488.  
  489.          for(int var14 = 0; var14 < var19.length; ++var14) {
  490.             var24.writeBytes(var19[var14]);
  491.             var24.writeBytes(System.getProperty("line.separator"));
  492.          }
  493.  
  494.          ((FilterOutputStream)var24).close();
  495.       } catch (FileNotFoundException var15) {
  496.          System.err.println("saveMethod: " + var15);
  497.       } catch (IOException var16) {
  498.          System.err.println("saveMethod: " + var16);
  499.       }
  500.    }
  501.  
  502.    public void saveClass(String var1, int[] var2, String var3, String var4) {
  503.       String[] var5 = null;
  504.       String[] var6 = null;
  505.       String[] var7 = null;
  506.       String var8 = this.getFileName(this.majorClassName(var1));
  507.       String var9 = this.majorClassName(var1);
  508.       if (var2 != null) {
  509.          var5 = this.loadSourceLines(var9, var2[0], var2[1] - 1);
  510.          var6 = this.loadSourceLines(var9, var2[2], var2[3] - 1);
  511.          var7 = this.loadSourceLines(var9, var2[4], var2[5] - 1);
  512.       }
  513.  
  514.       try {
  515.          DataOutputStream var10 = new DataOutputStream(new FileOutputStream(var8));
  516.          if (var5 != null) {
  517.             for(int var11 = 0; var11 < var5.length; ++var11) {
  518.                var10.writeBytes(var5[var11]);
  519.                var10.writeBytes(System.getProperty("line.separator"));
  520.             }
  521.          }
  522.  
  523.          StringReader var16 = new StringReader(var3);
  524.          int var12 = 0;
  525.  
  526.          while((var12 = var16.read()) != -1) {
  527.             switch (var12) {
  528.                case 10:
  529.                   var10.writeBytes(System.getProperty("line.separator"));
  530.                   break;
  531.                default:
  532.                   var10.write(var12);
  533.             }
  534.          }
  535.  
  536.          var10.writeBytes(System.getProperty("line.separator"));
  537.          if (var6 != null) {
  538.             for(int var13 = 0; var13 < var6.length; ++var13) {
  539.                var10.writeBytes(var6[var13]);
  540.                var10.writeBytes(System.getProperty("line.separator"));
  541.             }
  542.          }
  543.  
  544.          var16 = new StringReader(var4);
  545.          var12 = 0;
  546.  
  547.          while((var12 = var16.read()) != -1) {
  548.             switch (var12) {
  549.                case 10:
  550.                   var10.writeBytes(System.getProperty("line.separator"));
  551.                   break;
  552.                default:
  553.                   var10.write(var12);
  554.             }
  555.          }
  556.  
  557.          var10.writeBytes(System.getProperty("line.separator"));
  558.          if (var7 != null) {
  559.             for(int var21 = 0; var21 < var7.length; ++var21) {
  560.                var10.writeBytes(var7[var21]);
  561.                var10.writeBytes(System.getProperty("line.separator"));
  562.             }
  563.          }
  564.  
  565.          ((FilterOutputStream)var10).close();
  566.       } catch (FileNotFoundException var14) {
  567.          System.err.println("saveClass: " + var14);
  568.       } catch (IOException var15) {
  569.          System.err.println("saveClass: " + var15);
  570.       }
  571.    }
  572.  
  573.    public static void main(String[] var0) {
  574.       String var1 = var0[1] + "." + var0[2];
  575.       BrowserOptions.init();
  576.       BrowserFileLoader var2 = new BrowserFileLoader(var0[0]);
  577.       var2.loadPackage(var0[0], var0[1]);
  578.       MethodRecord[] var3 = var2.loadClassFile(var1);
  579.  
  580.       for(int var4 = 0; var4 < var3.length; ++var4) {
  581.          System.out.println(var3[var4]);
  582.       }
  583.  
  584.       System.out.println("====");
  585.       String[] var5 = MethodRecord.classList(var3);
  586.  
  587.       for(int var9 = 0; var9 < var5.length; ++var9) {
  588.          int[] var6 = MethodRecord.getClassBorders(var5[var9], var3);
  589.          System.out.println(var5[var9] + ", " + MethodRecord.isInner(var5[var9], var3) + ", " + MethodRecord.beginClass(var5[var9], var3) + ", " + MethodRecord.endClass(var5[var9], var3) + ", " + var6[0] + ", " + var6[1] + ", " + var6[2] + ", " + var6[3]);
  590.       }
  591.  
  592.       System.out.println("====");
  593.  
  594.       for(int var10 = 0; var10 < var5.length; ++var10) {
  595.          MethodRecord[] var11 = MethodRecord.classMethodList(var5[var10], var3);
  596.          System.out.println(var5[var10]);
  597.  
  598.          for(int var7 = 0; var7 < var11.length; ++var7) {
  599.             System.out.println("\t" + var11[var7]);
  600.          }
  601.       }
  602.  
  603.       System.out.println("====");
  604.       MethodRecord[] var12 = MethodRecord.classRecordList(var3);
  605.  
  606.       for(int var13 = 0; var13 < var12.length; ++var13) {
  607.          System.out.println(var12[var13]);
  608.          int[] var8 = MethodRecord.getClassDefn(var12[var13].className(), var12);
  609.          System.out.println("Class defn: " + var8[0] + " " + var8[1] + " " + var8[2] + " " + var8[3]);
  610.          var8 = MethodRecord.getClassBorders(var12[var13].className(), var12);
  611.          System.out.println("Class borders: " + var8[0] + " " + var8[1] + " " + var8[2] + " " + var8[3] + " " + var8[4] + " " + var8[5]);
  612.       }
  613.  
  614.       System.exit(1);
  615.    }
  616.  
  617.    public long lastModified(String var1) {
  618.       String var2 = this.getFileName(var1);
  619.       File var3 = new File(var2);
  620.       return var3.lastModified();
  621.    }
  622.  
  623.    private String getBytecodeFileName(String var1) {
  624.       return this.rootDir + correctFileName(var1) + ".class";
  625.    }
  626.  
  627.    public boolean isClassCompiled(String var1) {
  628.       String var2 = this.getBytecodeFileName(var1);
  629.       File var3 = new File(var2);
  630.       return var3.lastModified() > this.lastModified(var1);
  631.    }
  632.  
  633.    public boolean removeClassFile(String var1) {
  634.       String var2 = this.getFileName(var1);
  635.       File var3 = new File(var2);
  636.       return var3.delete();
  637.    }
  638.  
  639.    public boolean existClassFile(String var1) {
  640.       String var2 = this.getFileName(var1);
  641.       File var3 = new File(var2);
  642.       return var3.exists();
  643.    }
  644.  
  645.    public boolean renameClassFile(String var1, String var2) {
  646.       String var3 = this.getFileName(var1);
  647.       String var4 = this.getFileName(var2);
  648.       File var5 = new File(var3);
  649.       File var6 = new File(var4);
  650.       return var5.renameTo(var6);
  651.    }
  652.  
  653.    void resizeResults() {
  654.       if (this.resultsCount % resultsIncrement == 0) {
  655.          String[] var1 = new String[this.resultsCount];
  656.  
  657.          for(int var2 = 0; var2 < this.resultsCount; ++var2) {
  658.             var1[var2] = this.results[var2];
  659.          }
  660.  
  661.          this.results = new String[this.resultsCount + resultsIncrement];
  662.  
  663.          for(int var3 = 0; var3 < this.resultsCount; ++var3) {
  664.             this.results[var3] = var1[var3];
  665.          }
  666.       }
  667.  
  668.    }
  669.  
  670.    public static String correctPackageName(String var0) {
  671.       String var1 = var0.replace('.', !BrowserOptions.specialSystem[3].equals("") ? BrowserOptions.specialSystem[3].charAt(0) : ':');
  672.       return var1.replace(BrowserOptions.delimiterChar(), '.');
  673.    }
  674.  
  675.    public static String correctFileName(String var0) {
  676.       if (var0 != null && !var0.equals("")) {
  677.          String var1 = var0.replace('.', BrowserOptions.delimiterChar());
  678.          return var1.replace(!BrowserOptions.specialSystem[3].equals("") ? BrowserOptions.specialSystem[3].charAt(0) : ':', '.');
  679.       } else {
  680.          return "";
  681.       }
  682.    }
  683.  
  684.    private static char periodDisplayChar() {
  685.       return !BrowserOptions.specialSystem[3].equals("") ? BrowserOptions.specialSystem[3].charAt(0) : ':';
  686.    }
  687.  
  688.    void loadPackage(String var1, String var2) {
  689.       this.classFiles = this.ListFiles(var1 + correctFileName(var2));
  690.       this.partialClassesExist = false;
  691.       this.changes = new boolean[MaxChanges];
  692.       this.changes[ClassLoad] = true;
  693.       boolean[] var3 = this.changes;
  694.       ((Observable)this).setChanged();
  695.       ((Observable)this).notifyObservers(var3);
  696.    }
  697.  
  698.    private void changed(boolean[] var1) {
  699.       ((Observable)this).setChanged();
  700.       ((Observable)this).notifyObservers(var1);
  701.    }
  702.  
  703.    void loadClass(String var1, boolean var2) {
  704.       if (var2 || !this.classOnList(this.minorClassName(var1.substring(var1.lastIndexOf(46) + 1)))) {
  705.          this.classMethodList = this.loadClassFile(this.majorClassName(var1));
  706.       }
  707.  
  708.       this.changes = new boolean[MaxChanges];
  709.       if (this.classMethodList == null) {
  710.          this.classFileName = null;
  711.          this.changes[ClassLoad] = true;
  712.       } else {
  713.          this.changes[MethodLoad] = true;
  714.       }
  715.  
  716.       boolean[] var3 = this.changes;
  717.       ((Observable)this).setChanged();
  718.       ((Observable)this).notifyObservers(var3);
  719.    }
  720.  
  721.    private boolean classOnList(String var1) {
  722.       if (this.classMethodList != null && this.classMethodList.length != 0) {
  723.          String[] var2 = MethodRecord.classList(this.classMethodList);
  724.  
  725.          for(int var3 = 0; var3 < var2.length; ++var3) {
  726.             if (var2[var3].equals(var1)) {
  727.                return true;
  728.             }
  729.          }
  730.  
  731.          return false;
  732.       } else {
  733.          return false;
  734.       }
  735.    }
  736.  
  737.    public String classFileName() {
  738.       return this.classFileName;
  739.    }
  740.  
  741.    public MethodRecord[] partialClassList() {
  742.       int var1 = 0;
  743.       if (this.classMethodList != null && this.partialClassesExist()) {
  744.          for(int var2 = 0; var2 < this.classMethodList.length; ++var2) {
  745.             if (this.classMethodList[var2].methodName() == null) {
  746.                ++var1;
  747.             }
  748.          }
  749.       }
  750.  
  751.       MethodRecord[] var5 = new MethodRecord[var1];
  752.       var1 = 0;
  753.       if (this.classMethodList != null && this.partialClassesExist()) {
  754.          for(int var3 = 0; var3 < this.classMethodList.length; ++var3) {
  755.             if (this.classMethodList[var3].methodName() == null) {
  756.                var5[var1++] = this.classMethodList[var3];
  757.             }
  758.          }
  759.       }
  760.  
  761.       return var5;
  762.    }
  763.  
  764.    public MethodRecord[] getMethods(String var1) {
  765.       return MethodRecord.classMethodList(this.minorClassName(var1.substring(var1.lastIndexOf(46) + 1)), this.classMethodList);
  766.    }
  767.  
  768.    public String[] getClasses() {
  769.       return this.classFiles;
  770.    }
  771.  
  772.    private String minorClassName(String var1) {
  773.       int var2 = var1.lastIndexOf(45);
  774.       if (var2 == -1) {
  775.          return var1;
  776.       } else {
  777.          var1 = var1.substring(var2 + 1);
  778.          var2 = var1.lastIndexOf(43);
  779.          if (var2 >= 0) {
  780.             return var1.substring(var2 + 1);
  781.          } else {
  782.             var2 = var1.lastIndexOf(32);
  783.             return var2 >= 0 ? var1.substring(var2 + 1) : var1;
  784.          }
  785.       }
  786.    }
  787.  
  788.    private String majorClassName(String var1) {
  789.       int var2 = var1.indexOf(32);
  790.       if (var2 >= 0) {
  791.          return var1.substring(0, var2);
  792.       } else {
  793.          var2 = var1.indexOf(43);
  794.          return var2 >= 0 ? var1.substring(0, var2) : var1;
  795.       }
  796.    }
  797.  
  798.    public boolean partialClassesExist() {
  799.       return this.partialClassesExist;
  800.    }
  801.  
  802.    private String fixMethodEnd(String var1) {
  803.       int var2 = var1.lastIndexOf(125);
  804.       int var3 = var1.lastIndexOf(10);
  805.       return var2 > var3 ? var1 + "\n" : var1;
  806.    }
  807.  
  808.    public String[] getClasses(String var1, String var2) {
  809.       return this.classFiles = this.ListFiles(var1 + correctFileName(var2));
  810.    }
  811.  
  812.    boolean removeInnerClass(String var1) {
  813.       Object var2 = null;
  814.       Object var3 = null;
  815.       String var4 = this.getFileName(this.majorClassName(var1));
  816.       String var5 = this.minorClassName(var1);
  817.       var5 = this.minorClassName(var5.substring(var5.lastIndexOf(46) + 1));
  818.       int[] var6 = null;
  819.       String[] var7 = MethodRecord.classList(this.classMethodList);
  820.  
  821.       for(int var8 = 0; var8 < var7.length; ++var8) {
  822.          if (var5.equals(var7[var8])) {
  823.             var6 = MethodRecord.getClassBorders(var7[var8], this.classMethodList);
  824.             break;
  825.          }
  826.       }
  827.  
  828.       if (var6 == null) {
  829.          return false;
  830.       } else {
  831.          String[] var14 = this.loadSourceLines(this.majorClassName(var1), var6[0], var6[1] - 1);
  832.          String[] var15 = this.loadSourceLines(this.majorClassName(var1), var6[4], var6[5] - 1);
  833.  
  834.          try {
  835.             DataOutputStream var9 = new DataOutputStream(new FileOutputStream(var4));
  836.  
  837.             for(int var10 = 0; var10 < var14.length; ++var10) {
  838.                var9.writeBytes(var14[var10]);
  839.                var9.writeBytes(System.getProperty("line.separator"));
  840.             }
  841.  
  842.             for(int var11 = 0; var11 < var15.length; ++var11) {
  843.                var9.writeBytes(var15[var11]);
  844.                var9.writeBytes(System.getProperty("line.separator"));
  845.             }
  846.  
  847.             ((FilterOutputStream)var9).close();
  848.          } catch (FileNotFoundException var12) {
  849.             System.err.println("saveMethod: " + var12);
  850.          } catch (IOException var13) {
  851.             System.err.println("saveMethod: " + var13);
  852.          }
  853.  
  854.          return true;
  855.       }
  856.    }
  857.  
  858.    public void classFileName(String var1) {
  859.       this.classFileName = var1;
  860.    }
  861. }
  862.