home *** CD-ROM | disk | FTP | other *** search
/ Symantec Visual Cafe for Java 2.5 / symantec-visual-cafe-2.5-database-dev-edition.iso / VPage / Java.bin / CLASSES.ZIP / sun / tools / javap / JavaP.class (.txt) next >
Encoding:
Java Class File  |  1997-07-08  |  6.7 KB  |  230 lines
  1. package sun.tools.javap;
  2.  
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.io.OutputStreamWriter;
  6. import java.io.PrintWriter;
  7. import java.util.Vector;
  8. import sun.tools.java.BinaryClass;
  9. import sun.tools.java.ClassNotFound;
  10. import sun.tools.java.ClassPath;
  11. import sun.tools.java.Identifier;
  12. import sun.tools.util.ModifierFilter;
  13.  
  14. public class JavaP {
  15.    private JavaPEnvironment env;
  16.    private Vector classList = new Vector();
  17.    private PrintWriter output;
  18.    private static final String progname = "javap";
  19.    private static final String version = "97/04/22";
  20.  
  21.    public JavaP(PrintWriter var1) {
  22.       this.output = var1;
  23.       this.env = new JavaPEnvironment(var1);
  24.    }
  25.  
  26.    private void error(String var1) {
  27.       int var2 = var1.length();
  28.  
  29.       for(int var3 = 0; var3 < var2; ++var3) {
  30.          System.err.write(var1.charAt(var3));
  31.       }
  32.  
  33.       System.err.write(10);
  34.       System.err.flush();
  35.    }
  36.  
  37.    private void usage() {
  38.       this.error("Usage: javap <options> <classes>...");
  39.       this.error("");
  40.       this.error("where options include:");
  41.       this.error("   -b         Backward compatibility with javap in JDK 1.1");
  42.       this.error("   -c         Disassemble the code");
  43.       this.error("   -classpath <directories separated by colons>");
  44.       this.error("              List directories in which to look for classes");
  45.       this.error("   -l         Print line number and local variable tables");
  46.       this.error("   -public    Show only public classes and members");
  47.       this.error("   -protected Show protected/public classes and members");
  48.       this.error("   -package   Show package/protected/public classes");
  49.       this.error("              and members (default)");
  50.       this.error("   -private   Show all classes and members");
  51.       this.error("   -s         Print internal type signatures");
  52.       this.error("   -verbose   Print stack size, number of locals and args for methods");
  53.       this.error("              If verifying, print reasons for failure");
  54.       this.error("   -version   Print the javap version string");
  55.       this.error("   -verify    Run the verifier");
  56.       this.error("");
  57.    }
  58.  
  59.    private boolean parseArguments(String[] var1) {
  60.       String var2 = System.getProperty("java.class.path");
  61.       boolean var3 = true;
  62.  
  63.       for(int var4 = 0; var4 < var1.length; ++var4) {
  64.          String var5 = var1[var4];
  65.          if (var5.startsWith("-")) {
  66.             if (var5.equals("-l")) {
  67.                this.env.showLineAndLocal = true;
  68.             } else if (!var5.equals("-private") && !var5.equals("-p")) {
  69.                if (var5.equals("-package")) {
  70.                   this.env.showAccess = new ModifierFilter(-9223372036854775803L);
  71.                } else if (var5.equals("-protected")) {
  72.                   this.env.showAccess = new ModifierFilter(5L);
  73.                } else if (var5.equals("-public")) {
  74.                   this.env.showAccess = new ModifierFilter(1L);
  75.                } else if (var5.equals("-b")) {
  76.                   this.env.showBackwardCompatible = true;
  77.                } else if (var5.equals("-c")) {
  78.                   this.env.showDisassembled = true;
  79.                } else if (var5.equals("-s")) {
  80.                   this.env.showInternalSigs = true;
  81.                } else if (var5.equals("-verbose")) {
  82.                   this.env.showVerbose = true;
  83.                } else if (var5.equals("-v")) {
  84.                   this.env.showVerbose = true;
  85.                } else if (var5.equals("-h")) {
  86.                   this.env.doMakeInclude = true;
  87.                } else if (var5.equals("-verify")) {
  88.                   this.env.doVerify = true;
  89.                } else if (var5.equals("-verify-verbose")) {
  90.                   this.env.doVerify = true;
  91.                   ++this.env.verifyLevel;
  92.                } else if (var5.equals("-version")) {
  93.                   this.error("javap version 97/04/22");
  94.                   var3 = false;
  95.                } else {
  96.                   if (!var5.equals("-classpath")) {
  97.                      this.error("invalid flag: " + var5);
  98.                      this.usage();
  99.                      return false;
  100.                   }
  101.  
  102.                   if (var4 + 1 >= var1.length) {
  103.                      this.error("-classpath requires argument");
  104.                      this.usage();
  105.                      return false;
  106.                   }
  107.  
  108.                   ++var4;
  109.                   var2 = var1[var4];
  110.                }
  111.             } else {
  112.                this.env.showAccess = new ModifierFilter(-9223372036854775801L);
  113.             }
  114.          } else {
  115.             this.classList.addElement(var5);
  116.             var3 = false;
  117.          }
  118.       }
  119.  
  120.       if (var3) {
  121.          this.usage();
  122.          return false;
  123.       } else {
  124.          this.env.path = new ClassPath(var2);
  125.          return true;
  126.       }
  127.    }
  128.  
  129.    private void displayResults() {
  130.       for(int var1 = 0; var1 < this.classList.size(); ++var1) {
  131.          String var2 = (String)this.classList.elementAt(var1);
  132.          Identifier var3 = Identifier.lookup(var2);
  133.          if (!this.env.classExists(var3)) {
  134.             this.error("Class '" + var2 + "' not found");
  135.          } else {
  136.             try {
  137.                BinaryClass var4 = (BinaryClass)this.env.getClassDefinition(var3);
  138.                var4.hasBeenLoaded(this.env);
  139.                JavaPClassPrinter var5 = new JavaPClassPrinter(var4, this.env);
  140.                var5.print();
  141.             } catch (ClassNotFound var6) {
  142.                this.error("class not found");
  143.             } catch (IOException var7) {
  144.                this.error("I/O Exception");
  145.             }
  146.          }
  147.       }
  148.  
  149.    }
  150.  
  151.    private void exec(String var1) {
  152.       String var2 = System.getProperty("file.separator");
  153.       StringBuffer var3 = new StringBuffer();
  154.       var3.append(System.getProperty("java.home"));
  155.       var3.append(var2).append("bin").append(var2);
  156.       var3.append(var1);
  157.       var3.append(" -classpath ").append(this.env.path);
  158.       if (this.env.showVerbose) {
  159.          var3.append(" -verbose");
  160.       }
  161.  
  162.       for(int var5 = 0; var5 < this.env.verifyLevel; ++var5) {
  163.          var3.append(" -verify-verbose");
  164.       }
  165.  
  166.       for(int var6 = 0; var6 < this.classList.size(); ++var6) {
  167.          String var7 = (String)this.classList.elementAt(var6);
  168.          var3.append(" ").append(var7);
  169.       }
  170.  
  171.       String var4 = var3.toString();
  172.  
  173.       try {
  174.          Process var14 = Runtime.getRuntime().exec(var4);
  175.          InputStream var8 = var14.getInputStream();
  176.          InputStream var9 = var14.getErrorStream();
  177.          byte[] var10 = new byte[256];
  178.          var14.waitFor();
  179.  
  180.          int var11;
  181.          while((var11 = var9.read(var10)) != -1) {
  182.             this.output.write(new String(var10, 0, var11));
  183.          }
  184.  
  185.          while((var11 = var8.read(var10)) != -1) {
  186.             this.output.write(new String(var10, 0, var11));
  187.          }
  188.  
  189.       } catch (IOException var12) {
  190.          this.error("Cannot execute '" + var4 + "' - " + var12);
  191.       } catch (InterruptedException var13) {
  192.          this.error("Cannot execute '" + var4 + "' - " + var13);
  193.       }
  194.    }
  195.  
  196.    private void perform(String[] var1) {
  197.       if (this.parseArguments(var1)) {
  198.          if (this.env.doMakeInclude) {
  199.             this.error("-h is no longer available - use the 'javah' program");
  200.             return;
  201.          }
  202.  
  203.          if (this.env.doVerify) {
  204.             if (this.env.verifyLevel > 0) {
  205.                this.exec("javaverify_g");
  206.                return;
  207.             }
  208.  
  209.             this.exec("javaverify");
  210.             return;
  211.          }
  212.  
  213.          this.displayResults();
  214.       }
  215.  
  216.    }
  217.  
  218.    public static void main(String[] var0) {
  219.       PrintWriter var1 = new PrintWriter(new OutputStreamWriter(System.out));
  220.  
  221.       try {
  222.          JavaP var4 = new JavaP(var1);
  223.          var4.perform(var0);
  224.       } finally {
  225.          var1.close();
  226.       }
  227.  
  228.    }
  229. }
  230.