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 / javac / BatchEnvironment.class (.txt) next >
Encoding:
Java Class File  |  1997-07-08  |  14.5 KB  |  640 lines
  1. package sun.tools.javac;
  2.  
  3. import java.io.BufferedInputStream;
  4. import java.io.DataInputStream;
  5. import java.io.File;
  6. import java.io.FileInputStream;
  7. import java.io.FileNotFoundException;
  8. import java.io.IOException;
  9. import java.io.InputStream;
  10. import java.io.InputStreamReader;
  11. import java.io.OutputStream;
  12. import java.io.PrintStream;
  13. import java.io.Reader;
  14. import java.util.Enumeration;
  15. import java.util.Hashtable;
  16. import java.util.Vector;
  17. import sun.tools.java.BinaryClass;
  18. import sun.tools.java.ClassDeclaration;
  19. import sun.tools.java.ClassDefinition;
  20. import sun.tools.java.ClassFile;
  21. import sun.tools.java.ClassNotFound;
  22. import sun.tools.java.ClassPath;
  23. import sun.tools.java.CompilerError;
  24. import sun.tools.java.Constants;
  25. import sun.tools.java.Environment;
  26. import sun.tools.java.FieldDefinition;
  27. import sun.tools.java.Identifier;
  28. import sun.tools.java.IdentifierToken;
  29. import sun.tools.java.Package;
  30. import sun.tools.java.Parser;
  31. import sun.tools.java.Type;
  32. import sun.tools.tree.Node;
  33.  
  34. public class BatchEnvironment extends Environment implements ErrorConsumer {
  35.    OutputStream out;
  36.    ClassPath path;
  37.    Hashtable packages;
  38.    Vector classesOrdered;
  39.    Hashtable classes;
  40.    public int flags;
  41.    public File covFile;
  42.    public int nerrors;
  43.    public int nwarnings;
  44.    public int ndeprecations;
  45.    Vector deprecationFiles;
  46.    ErrorConsumer errorConsumer;
  47.    String errorFileName;
  48.    ErrorMessage errors;
  49.    private int errorsPushed;
  50.    public int errorLimit;
  51.    private boolean hitErrorLimit;
  52.  
  53.    public BatchEnvironment(ClassPath var1) {
  54.       this(System.out, var1);
  55.    }
  56.  
  57.    public BatchEnvironment(OutputStream var1, ClassPath var2) {
  58.       this(var1, var2, (ErrorConsumer)null);
  59.    }
  60.  
  61.    public BatchEnvironment(OutputStream var1, ClassPath var2, ErrorConsumer var3) {
  62.       this.packages = new Hashtable(31);
  63.       this.classesOrdered = new Vector();
  64.       this.classes = new Hashtable(351);
  65.       this.deprecationFiles = new Vector();
  66.       this.errorLimit = 100;
  67.       this.out = var1;
  68.       this.path = var2;
  69.       if (var3 == null) {
  70.          this.errorConsumer = this;
  71.       } else {
  72.          this.errorConsumer = var3;
  73.       }
  74.    }
  75.  
  76.    public int getFlags() {
  77.       return this.flags;
  78.    }
  79.  
  80.    public File getcovFile() {
  81.       return this.covFile;
  82.    }
  83.  
  84.    public Enumeration getClasses() {
  85.       return this.classesOrdered.elements();
  86.    }
  87.  
  88.    public ClassDeclaration getClassDeclaration(Identifier var1) {
  89.       return this.getClassDeclaration(Type.tClass(var1));
  90.    }
  91.  
  92.    public ClassDeclaration getClassDeclaration(Type var1) {
  93.       ClassDeclaration var2 = (ClassDeclaration)this.classes.get(var1);
  94.       if (var2 == null) {
  95.          this.classes.put(var1, var2 = new ClassDeclaration(var1.getClassName()));
  96.          this.classesOrdered.addElement(var2);
  97.       }
  98.  
  99.       return var2;
  100.    }
  101.  
  102.    public boolean classExists(Identifier var1) {
  103.       if (var1.isInner()) {
  104.          var1 = var1.getTopName();
  105.       }
  106.  
  107.       Type var2 = Type.tClass(var1);
  108.  
  109.       try {
  110.          ClassDeclaration var3 = (ClassDeclaration)this.classes.get(var2);
  111.          return var3 != null ? var3.getName().equals(var1) : this.getPackage(var1.getQualifier()).classExists(var1.getName());
  112.       } catch (IOException var4) {
  113.          return true;
  114.       }
  115.    }
  116.  
  117.    public Identifier generateName(Identifier var1, Identifier var2) {
  118.       Identifier var3 = var1.getFlatName();
  119.       Identifier var4 = Identifier.lookup(var1.getQualifier(), var3.getHead());
  120.       int var5 = 1;
  121.  
  122.       while(true) {
  123.          String var6 = var5 + (var2.equals(Constants.idNull) ? "" : "$" + var2);
  124.          Identifier var7 = Identifier.lookupInner(var4, Identifier.lookup(var6));
  125.          if (this.classes.get(Type.tClass(var7)) == null) {
  126.             return var7;
  127.          }
  128.  
  129.          ++var5;
  130.       }
  131.    }
  132.  
  133.    public Package getPackage(Identifier var1) throws IOException {
  134.       Package var2 = (Package)this.packages.get(var1);
  135.       if (var2 == null) {
  136.          this.packages.put(var1, var2 = new Package(this.path, var1));
  137.       }
  138.  
  139.       return var2;
  140.    }
  141.  
  142.    public void parseFile(ClassFile var1) throws FileNotFoundException {
  143.       long var2 = System.currentTimeMillis();
  144.  
  145.       InputStream var4;
  146.       BatchParser var5;
  147.       try {
  148.          var4 = var1.getInputStream();
  149.          Environment var6 = new Environment(this, var1);
  150.          var6.setCharacterEncoding(((Environment)this).getCharacterEncoding());
  151.          var5 = new BatchParser(var6, new BufferedInputStream(var4));
  152.       } catch (IOException var9) {
  153.          throw new FileNotFoundException();
  154.       }
  155.  
  156.       try {
  157.          ((Parser)var5).parseFile();
  158.       } catch (Exception var8) {
  159.          throw new CompilerError(var8);
  160.       }
  161.  
  162.       try {
  163.          var4.close();
  164.       } catch (IOException var7) {
  165.       }
  166.  
  167.       if (((Environment)this).verbose()) {
  168.          var2 = System.currentTimeMillis() - var2;
  169.          this.output(Main.getText("benv.parsed_in", var1.getPath(), Long.toString(var2)));
  170.       }
  171.  
  172.    }
  173.  
  174.    BinaryClass loadFile(ClassFile var1) throws IOException {
  175.       long var2 = System.currentTimeMillis();
  176.       InputStream var4 = var1.getInputStream();
  177.       BinaryClass var5 = null;
  178.  
  179.       try {
  180.          DataInputStream var6 = new DataInputStream(new BufferedInputStream(var4));
  181.          var5 = BinaryClass.load(new Environment(this, var1), var6, this.loadFileFlags());
  182.       } catch (ClassFormatError var7) {
  183.          ((Environment)this).error(0, "class.format", var1.getPath(), ((Throwable)var7).getMessage());
  184.          return null;
  185.       } catch (Exception var8) {
  186.          ((Throwable)var8).printStackTrace();
  187.       }
  188.  
  189.       var4.close();
  190.       if (((Environment)this).verbose()) {
  191.          var2 = System.currentTimeMillis() - var2;
  192.          this.output(Main.getText("benv.loaded_in", var1.getPath(), Long.toString(var2)));
  193.       }
  194.  
  195.       return var5;
  196.    }
  197.  
  198.    int loadFileFlags() {
  199.       return 0;
  200.    }
  201.  
  202.    boolean needsCompilation(Hashtable var1, ClassDeclaration var2) {
  203.       switch (var2.getStatus()) {
  204.          case 0:
  205.             this.loadDefinition(var2);
  206.             return this.needsCompilation(var1, var2);
  207.          case 1:
  208.             if (var1.get(var2) == null) {
  209.                var1.put(var2, var2);
  210.                BinaryClass var3 = (BinaryClass)var2.getClassDefinition();
  211.                Enumeration var4 = var3.getDependencies();
  212.  
  213.                while(var4.hasMoreElements()) {
  214.                   ClassDeclaration var5 = (ClassDeclaration)var4.nextElement();
  215.                   if (this.needsCompilation(var1, var5)) {
  216.                      var2.setDefinition(var3, 3);
  217.                      return true;
  218.                   }
  219.                }
  220.             }
  221.  
  222.             return false;
  223.          case 2:
  224.             return false;
  225.          default:
  226.             return true;
  227.       }
  228.    }
  229.  
  230.    public void loadDefinition(ClassDeclaration var1) {
  231.       switch (var1.getStatus()) {
  232.          case 0:
  233.             Identifier var14 = var1.getName();
  234.  
  235.             Package var16;
  236.             try {
  237.                var16 = this.getPackage(var14.getQualifier());
  238.             } catch (IOException var12) {
  239.                ((Environment)this).error(0, "io.exception", var1);
  240.                return;
  241.             }
  242.  
  243.             ClassFile var19 = var16.getBinaryFile(var14.getName());
  244.             if (var19 == null) {
  245.                var1.setDefinition((ClassDefinition)null, 3);
  246.                return;
  247.             } else {
  248.                ClassFile var5 = var16.getSourceFile(var14.getName());
  249.                if (var5 == null) {
  250.                   Object var22 = null;
  251.  
  252.                   try {
  253.                      var23 = this.loadFile(var19);
  254.                   } catch (IOException var10) {
  255.                      ((Environment)this).error(0, "io.exception", var19);
  256.                      return;
  257.                   }
  258.  
  259.                   if (var23 != null && !((ClassDefinition)var23).getName().equals(var14)) {
  260.                      ((Environment)this).error(0, "wrong.class", var19.getPath(), var1, var23);
  261.                      var23 = null;
  262.                   }
  263.  
  264.                   if (var23 == null) {
  265.                      var1.setDefinition((ClassDefinition)null, 6);
  266.                      return;
  267.                   } else {
  268.                      if (((ClassDefinition)var23).getSource() != null) {
  269.                         var5 = new ClassFile(new File((String)((ClassDefinition)var23).getSource()));
  270.                         var5 = var16.getSourceFile(var5.getName());
  271.                         if (var5 != null && var5.exists()) {
  272.                            if (var5.lastModified() > var19.lastModified()) {
  273.                               var1.setDefinition(var23, 3);
  274.                               var23.hasBeenLoaded(this);
  275.                               return;
  276.                            }
  277.  
  278.                            var1.setDefinition(var23, ((Environment)this).dependencies() ? 1 : 2);
  279.                            var23.hasBeenLoaded(this);
  280.                            return;
  281.                         }
  282.                      }
  283.  
  284.                      var1.setDefinition(var23, 2);
  285.                      var23.hasBeenLoaded(this);
  286.                      return;
  287.                   }
  288.                } else {
  289.                   BinaryClass var6 = null;
  290.  
  291.                   try {
  292.                      if (var5.lastModified() > var19.lastModified()) {
  293.                         var1.setDefinition((ClassDefinition)null, 3);
  294.                         return;
  295.                      }
  296.  
  297.                      var6 = this.loadFile(var19);
  298.                   } catch (IOException var11) {
  299.                      ((Environment)this).error(0, "io.exception", var19);
  300.                   }
  301.  
  302.                   if (var6 != null && !((ClassDefinition)var6).getName().equals(var14)) {
  303.                      ((Environment)this).error(0, "wrong.class", var19.getPath(), var1, var6);
  304.                      var6 = null;
  305.                   }
  306.  
  307.                   if (var6 != null) {
  308.                      if (((ClassDefinition)var6).getName().equals(var1.getName())) {
  309.                         var1.setDefinition(var6, ((Environment)this).dependencies() ? 1 : 2);
  310.                      } else {
  311.                         var1.setDefinition((ClassDefinition)null, 6);
  312.                         this.getClassDeclaration(((ClassDefinition)var6).getName()).setDefinition(var6, ((Environment)this).dependencies() ? 1 : 2);
  313.                      }
  314.                   } else {
  315.                      var1.setDefinition((ClassDefinition)null, 6);
  316.                   }
  317.  
  318.                   if (var6 != null && var6 == var1.getClassDefinition()) {
  319.                      var6.hasBeenLoaded(this);
  320.                   }
  321.  
  322.                   return;
  323.                }
  324.             }
  325.          case 1:
  326.             Hashtable var13 = new Hashtable();
  327.             if (!this.needsCompilation(var13, var1)) {
  328.                Enumeration var15 = var13.keys();
  329.  
  330.                while(var15.hasMoreElements()) {
  331.                   ClassDeclaration var18 = (ClassDeclaration)var15.nextElement();
  332.                   if (var18.getStatus() == 1) {
  333.                      var18.setDefinition(var18.getClassDefinition(), 2);
  334.                   }
  335.                }
  336.             }
  337.  
  338.             return;
  339.          case 2:
  340.          default:
  341.             return;
  342.          case 3:
  343.             ClassFile var2 = null;
  344.             Package var3 = null;
  345.             if (var1.getClassDefinition() != null) {
  346.                try {
  347.                   var3 = this.getPackage(var1.getName().getQualifier());
  348.                   var2 = var3.getSourceFile((String)var1.getClassDefinition().getSource());
  349.                } catch (IOException var9) {
  350.                   ((Environment)this).error(0, "io.exception", var1);
  351.                }
  352.  
  353.                if (var2 == null) {
  354.                   String var4 = (String)var1.getClassDefinition().getSource();
  355.                   var2 = new ClassFile(new File(var4));
  356.                }
  357.             } else {
  358.                Identifier var17 = var1.getName();
  359.  
  360.                try {
  361.                   var3 = this.getPackage(var17.getQualifier());
  362.                   var2 = var3.getSourceFile(var17.getName());
  363.                } catch (IOException var8) {
  364.                   ((Environment)this).error(0, "io.exception", var1);
  365.                }
  366.  
  367.                if (var2 == null) {
  368.                   var1.setDefinition((ClassDefinition)null, 6);
  369.                   return;
  370.                }
  371.             }
  372.  
  373.             try {
  374.                this.parseFile(var2);
  375.             } catch (FileNotFoundException var7) {
  376.                ((Environment)this).error(0, "io.exception", var2);
  377.             }
  378.  
  379.             if (var1.getClassDefinition() == null || var1.getStatus() == 3) {
  380.                ((Environment)this).error(0, "wrong.source", var2.getPath(), var1, var3);
  381.                var1.setDefinition((ClassDefinition)null, 6);
  382.             }
  383.  
  384.       }
  385.    }
  386.  
  387.    public ClassDefinition makeClassDefinition(Environment var1, int var2, IdentifierToken var3, String var4, int var5, IdentifierToken var6, IdentifierToken[] var7, ClassDefinition var8) {
  388.       Identifier var9 = var3.getName();
  389.       int var10 = var3.getWhere();
  390.       Identifier var11;
  391.       if (!var9.isQualified() && !var9.isInner()) {
  392.          if ((var5 & 196608) != 0) {
  393.             var11 = this.generateName(var8.getName(), var9);
  394.          } else if (var8 != null) {
  395.             var11 = Identifier.lookupInner(var8.getName(), var9);
  396.          } else {
  397.             var11 = var9;
  398.          }
  399.       } else {
  400.          var11 = var9;
  401.       }
  402.  
  403.       ClassDeclaration var12 = var1.getClassDeclaration(var11);
  404.       if (var12.isDefined()) {
  405.          var1.error(var10, "class.multidef", var12.getName(), var12.getClassDefinition().getSource());
  406.          var12 = new ClassDeclaration(var11);
  407.       }
  408.  
  409.       if (var6 == null && !var11.equals(Constants.idJavaLangObject)) {
  410.          var6 = new IdentifierToken(Constants.idJavaLangObject);
  411.       }
  412.  
  413.       SourceClass var13 = new SourceClass(var1, var2, var12, var4, var5, var6, var7, (SourceClass)var8);
  414.       if (var8 != null) {
  415.          var8.addField(var1, new SourceField(var13));
  416.       }
  417.  
  418.       if (((ClassDefinition)var13).isAnonymous()) {
  419.          ((ClassDefinition)var13).setLocalName(Constants.idNull);
  420.       } else if (((ClassDefinition)var13).isLocal()) {
  421.          ((ClassDefinition)var13).setLocalName(var9);
  422.       }
  423.  
  424.       return var13;
  425.    }
  426.  
  427.    public FieldDefinition makeFieldDefinition(Environment var1, int var2, ClassDefinition var3, String var4, int var5, Type var6, Identifier var7, IdentifierToken[] var8, IdentifierToken[] var9, Object var10) {
  428.       Vector var11 = null;
  429.       if (var8 != null) {
  430.          var11 = new Vector(var8.length);
  431.  
  432.          for(int var12 = 0; var12 < var8.length; ++var12) {
  433.             var11.addElement(var8[var12]);
  434.          }
  435.       }
  436.  
  437.       SourceField var13 = new SourceField(var2, var3, var4, var5, var6, var7, var11, var9, (Node)var10);
  438.       var3.addField(var1, var13);
  439.       return var13;
  440.    }
  441.  
  442.    public void shutdown() {
  443.       if (this.path != null) {
  444.          try {
  445.             this.path.close();
  446.          } catch (IOException var2) {
  447.             this.output(Main.getText("benv.failed_to_close_class_path", ((Throwable)var2).toString()));
  448.          }
  449.  
  450.          this.path = null;
  451.       }
  452.  
  453.       super.shutdown();
  454.    }
  455.  
  456.    public String errorString(String var1, Object var2, Object var3, Object var4) {
  457.       Object var5 = null;
  458.       String var6;
  459.       if (var1.startsWith("warn.")) {
  460.          var6 = "javac.err." + var1.substring(5);
  461.       } else {
  462.          var6 = "javac.err." + var1;
  463.       }
  464.  
  465.       return Main.getText(var6, var2 != null ? var2.toString() : null, var3 != null ? var3.toString() : null, var4 != null ? var4.toString() : null);
  466.    }
  467.  
  468.    public void insertError(int var1, String var2) {
  469.       ErrorMessage var3 = new ErrorMessage(var1, var2);
  470.       if (this.errors == null) {
  471.          this.errors = var3;
  472.       } else if (this.errors.where > var1) {
  473.          var3.next = this.errors;
  474.          this.errors = var3;
  475.       } else {
  476.          ErrorMessage var4;
  477.          for(var4 = this.errors; var4.next != null && var4.next.where <= var1; var4 = var4.next) {
  478.          }
  479.  
  480.          var3.next = var4.next;
  481.          var4.next = var3;
  482.       }
  483.    }
  484.  
  485.    public void pushError(String var1, int var2, String var3, String var4, String var5) {
  486.       int var6 = this.errorLimit + this.nwarnings;
  487.       if (++this.errorsPushed >= var6 && this.errorLimit >= 0) {
  488.          if (!this.hitErrorLimit) {
  489.             this.hitErrorLimit = true;
  490.             this.output(this.errorString("too.many.errors", new Integer(this.errorLimit), (Object)null, (Object)null));
  491.          }
  492.  
  493.       } else {
  494.          this.output(var1 + ":" + var2 + ":" + " " + var3);
  495.          this.output(var4);
  496.          this.output(var5);
  497.       }
  498.    }
  499.  
  500.    public void flushErrors() {
  501.       if (this.errors != null) {
  502.          try {
  503.             FileInputStream var1 = new FileInputStream(this.errorFileName);
  504.             char[] var2 = new char[var1.available()];
  505.             InputStreamReader var3 = ((Environment)this).getCharacterEncoding() != null ? new InputStreamReader(var1, ((Environment)this).getCharacterEncoding()) : new InputStreamReader(var1);
  506.             int var4 = ((Reader)var3).read(var2);
  507.             var3.close();
  508.  
  509.             for(ErrorMessage var5 = this.errors; var5 != null; var5 = var5.next) {
  510.                ErrorMessage var6;
  511.                while((var6 = var5.next) != null && var5.where == var6.where && var5.message.equals(var6.message)) {
  512.                   var5 = var6;
  513.                   if (this.nwarnings > 1) {
  514.                      --this.nwarnings;
  515.                   } else {
  516.                      --this.nerrors;
  517.                   }
  518.                }
  519.  
  520.                int var7 = var5.where >>> 18;
  521.                int var8 = var5.where & 262143;
  522.                if (var8 > var4) {
  523.                   var8 = var4;
  524.                }
  525.  
  526.                int var9;
  527.                for(var9 = var8; var9 > 0 && var2[var9 - 1] != '\n' && var2[var9 - 1] != '\r'; --var9) {
  528.                }
  529.  
  530.                int var10;
  531.                for(var10 = var8; var10 < var4 && var2[var10] != '\n' && var2[var10] != '\r'; ++var10) {
  532.                }
  533.  
  534.                String var11 = new String(var2, var9, var10 - var9);
  535.                char[] var12 = new char[var8 - var9 + 1];
  536.  
  537.                for(int var15 = var9; var15 < var8; ++var15) {
  538.                   var12[var15 - var9] = (char)(var2[var15] == '\t' ? 9 : 32);
  539.                }
  540.  
  541.                var12[var8 - var9] = '^';
  542.                String var13 = new String(var12);
  543.                this.errorConsumer.pushError(this.errorFileName, var7, var5.message, var11, var13);
  544.             }
  545.          } catch (IOException var14) {
  546.             this.output("I/O exception");
  547.          }
  548.  
  549.          this.errors = null;
  550.       }
  551.    }
  552.  
  553.    public void reportError(Object var1, int var2, String var3, String var4) {
  554.       if (var1 == null) {
  555.          if (this.errorFileName != null) {
  556.             this.flushErrors();
  557.             this.errorFileName = null;
  558.          }
  559.  
  560.          if (var3.startsWith("warn.")) {
  561.             if (((Environment)this).warnings()) {
  562.                ++this.nwarnings;
  563.                this.output(var4);
  564.             }
  565.  
  566.          } else {
  567.             this.output("error: " + var4);
  568.             ++this.nerrors;
  569.             this.flags |= 65536;
  570.          }
  571.       } else if (var1 instanceof String) {
  572.          String var7 = (String)var1;
  573.          if (!var7.equals(this.errorFileName)) {
  574.             this.flushErrors();
  575.             this.errorFileName = var7;
  576.          }
  577.  
  578.          if (var3.startsWith("warn.")) {
  579.             if (var3.indexOf("is.deprecated") >= 0) {
  580.                ++this.ndeprecations;
  581.                if (!this.deprecationFiles.contains(var1)) {
  582.                   this.deprecationFiles.addElement(var1);
  583.                }
  584.  
  585.                if (!((Environment)this).deprecation()) {
  586.                   return;
  587.                }
  588.             }
  589.  
  590.             ++this.nwarnings;
  591.             if (!((Environment)this).warnings()) {
  592.                return;
  593.             }
  594.          } else {
  595.             ++this.nerrors;
  596.             this.flags |= 65536;
  597.          }
  598.  
  599.          this.insertError(var2, var4);
  600.       } else if (var1 instanceof ClassFile) {
  601.          this.reportError(((ClassFile)var1).getPath(), var2, var3, var4);
  602.       } else if (var1 instanceof Identifier) {
  603.          this.reportError(var1.toString(), var2, var3, var4);
  604.       } else if (var1 instanceof ClassDeclaration) {
  605.          try {
  606.             this.reportError(((ClassDeclaration)var1).getClassDefinition(this), var2, var3, var4);
  607.          } catch (ClassNotFound var6) {
  608.             this.reportError(((ClassDeclaration)var1).getName(), var2, var3, var4);
  609.          }
  610.       } else if (var1 instanceof ClassDefinition) {
  611.          ClassDefinition var5 = (ClassDefinition)var1;
  612.          if (!var3.startsWith("warn.")) {
  613.             var5.setError(true);
  614.          }
  615.  
  616.          this.reportError(var5.getSource(), var2, var3, var4);
  617.       } else if (var1 instanceof FieldDefinition) {
  618.          this.reportError(((FieldDefinition)var1).getClassDeclaration(), var2, var3, var4);
  619.       } else {
  620.          this.output(var1 + ":error=" + var3 + ":" + var4);
  621.       }
  622.    }
  623.  
  624.    public void error(Object var1, int var2, String var3, Object var4, Object var5, Object var6) {
  625.       if (this.errorsPushed < this.errorLimit + this.nwarnings) {
  626.          if (System.getProperty("javac.dump.stack") != null) {
  627.             this.output("javac.err." + var3 + ": " + this.errorString(var3, var4, var5, var6));
  628.             (new Exception("Stack trace")).printStackTrace(new PrintStream(this.out));
  629.          }
  630.  
  631.          this.reportError(var1, var2, var3, this.errorString(var3, var4, var5, var6));
  632.       }
  633.    }
  634.  
  635.    public void output(String var1) {
  636.       PrintStream var2 = this.out instanceof PrintStream ? (PrintStream)this.out : new PrintStream(this.out, true);
  637.       var2.println(var1);
  638.    }
  639. }
  640.