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 / SourceClass.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-07-08  |  30.0 KB  |  1,452 lines
  1. package sun.tools.javac;
  2.  
  3. import java.io.ByteArrayOutputStream;
  4. import java.io.DataOutputStream;
  5. import java.io.IOException;
  6. import java.io.OutputStream;
  7. import java.util.Enumeration;
  8. import java.util.Hashtable;
  9. import java.util.Vector;
  10. import sun.tools.asm.Assembler;
  11. import sun.tools.asm.ConstantPool;
  12. import sun.tools.java.AmbiguousClass;
  13. import sun.tools.java.ClassDeclaration;
  14. import sun.tools.java.ClassDefinition;
  15. import sun.tools.java.ClassFile;
  16. import sun.tools.java.ClassNotFound;
  17. import sun.tools.java.CompilerError;
  18. import sun.tools.java.Constants;
  19. import sun.tools.java.Environment;
  20. import sun.tools.java.FieldDefinition;
  21. import sun.tools.java.Identifier;
  22. import sun.tools.java.IdentifierToken;
  23. import sun.tools.java.Imports;
  24. import sun.tools.java.Type;
  25. import sun.tools.tree.AssignExpression;
  26. import sun.tools.tree.CompoundStatement;
  27. import sun.tools.tree.Context;
  28. import sun.tools.tree.Expression;
  29. import sun.tools.tree.ExpressionStatement;
  30. import sun.tools.tree.FieldExpression;
  31. import sun.tools.tree.IdentifierExpression;
  32. import sun.tools.tree.LocalField;
  33. import sun.tools.tree.MethodExpression;
  34. import sun.tools.tree.Node;
  35. import sun.tools.tree.ReturnStatement;
  36. import sun.tools.tree.Statement;
  37. import sun.tools.tree.StringExpression;
  38. import sun.tools.tree.SuperExpression;
  39. import sun.tools.tree.ThisExpression;
  40. import sun.tools.tree.UplevelReference;
  41. import sun.tools.tree.Vset;
  42.  
  43. public class SourceClass extends ClassDefinition {
  44.    Environment toplevelEnv;
  45.    SourceField defConstructor;
  46.    ConstantPool tab = new ConstantPool();
  47.    Hashtable deps = new Hashtable(11);
  48.    LocalField thisArg;
  49.    int endPosition;
  50.    private boolean sourceFileChecked;
  51.    private boolean basicChecking = false;
  52.    private boolean basicCheckDone = false;
  53.    private boolean inlinedLocalClass = false;
  54.    private static Vector active = new Vector();
  55.  
  56.    public SourceClass(Environment var1, int var2, ClassDeclaration var3, String var4, int var5, IdentifierToken var6, IdentifierToken[] var7, SourceClass var8) {
  57.       super(var1.getSource(), var2, var3, var5, var6, var7);
  58.       ((ClassDefinition)this).setOuterClass(var8);
  59.       this.toplevelEnv = var1;
  60.       super.documentation = var4;
  61.       if (ClassDefinition.containsDeprecated(var4)) {
  62.          super.modifiers |= 262144;
  63.       }
  64.  
  65.       if (((ClassDefinition)this).isStatic() && (var8 == null || !((ClassDefinition)var8).isTopLevel())) {
  66.          if (var8 == null) {
  67.             var1.error(var2, "static.class", this);
  68.          } else {
  69.             var1.error(var2, "static.inner.class", this);
  70.          }
  71.  
  72.          super.modifiers &= -9;
  73.          if (super.innerClassField != null) {
  74.             super.innerClassField.subModifiers(8);
  75.          }
  76.       }
  77.  
  78.       if (((ClassDefinition)this).isPrivate() && var8 == null) {
  79.          var1.error(var2, "private.class", this);
  80.          super.modifiers &= -3;
  81.       }
  82.  
  83.       if (((ClassDefinition)this).isProtected() && var8 == null) {
  84.          var1.error(var2, "protected.class", this);
  85.          super.modifiers &= -5;
  86.       }
  87.  
  88.       if (!((ClassDefinition)this).isTopLevel() && !((ClassDefinition)this).isLocal()) {
  89.          LocalField var9 = var8.getThisArgument();
  90.          UplevelReference var10 = ((ClassDefinition)this).getReference(var9);
  91.          ((ClassDefinition)this).setOuterField(var10.getLocalField(var1));
  92.       }
  93.  
  94.       for(Object var11 = var8; var11 != null; var11 = ((ClassDefinition)var11).getOuterClass()) {
  95.          if (((ClassDefinition)this).getName().getFlatName().getName().equals(((ClassDefinition)var11).getName().getFlatName().getName())) {
  96.             var1.error(var2, "inner.redefined", ((ClassDefinition)this).getName().getFlatName().getName());
  97.          }
  98.       }
  99.  
  100.    }
  101.  
  102.    public int getEndPosition() {
  103.       return this.endPosition;
  104.    }
  105.  
  106.    public void setEndPosition(int var1) {
  107.       this.endPosition = var1;
  108.    }
  109.  
  110.    public String getAbsoluteName() {
  111.       String var1 = ((ClassFile)((ClassDefinition)this).getSource()).getAbsoluteName();
  112.       return var1;
  113.    }
  114.  
  115.    public Imports getImports() {
  116.       return this.toplevelEnv.getImports();
  117.    }
  118.  
  119.    public LocalField getThisArgument() {
  120.       if (this.thisArg == null) {
  121.          this.thisArg = new LocalField(super.where, this, 0, ((ClassDefinition)this).getType(), Constants.idThis);
  122.       }
  123.  
  124.       return this.thisArg;
  125.    }
  126.  
  127.    public void addDependency(ClassDeclaration var1) {
  128.       if (this.tab != null) {
  129.          this.tab.put(var1);
  130.       }
  131.  
  132.       if (this.toplevelEnv.print_dependencies() && var1 != ((ClassDefinition)this).getClassDeclaration()) {
  133.          this.deps.put(var1, var1);
  134.       }
  135.  
  136.    }
  137.  
  138.    void checkOverride(Environment var1, ClassDeclaration var2, FieldDefinition var3) throws ClassNotFound {
  139.       ClassDefinition var4 = var2.getClassDefinition(var1);
  140.  
  141.       for(FieldDefinition var5 = var4.getFirstMatch(var3.getName()); var5 != null; var5 = var5.getNextMatch()) {
  142.          if (!var5.isPrivate() && !var5.isVariable() && var3.getType().equalArguments(var5.getType())) {
  143.             if (!var5.isProtected() && !var5.isPublic() && !var5.isPrivate() && !var3.isConstructor() && !((ClassDefinition)this).getName().getQualifier().equals(var2.getName().getQualifier())) {
  144.                var1.error(var3.getWhere(), "warn.no.override.access", var3, this, var5.getClassDeclaration());
  145.             } else {
  146.                if (var5.isFinal()) {
  147.                   var1.error(var3.getWhere(), "final.meth.override", var3, var5.getClassDeclaration());
  148.                   return;
  149.                }
  150.  
  151.                Type var6 = var3.getType().getReturnType();
  152.                Type var7 = var5.getType().getReturnType();
  153.                if (!var6.equals(var7)) {
  154.                   var1.error(var3.getWhere(), "redef.return.type", var3, var5);
  155.                   return;
  156.                }
  157.  
  158.                if (var3.isStatic() != var5.isStatic()) {
  159.                   String var15 = var5.isStatic() ? "override.static.meth" : "override.instance.method.static";
  160.                   var1.error(var3.getWhere(), var15, var5, var5.getClassDeclaration());
  161.                   return;
  162.                }
  163.  
  164.                if (!var3.isConstructor()) {
  165.                   if (!var3.isPublic() && !var5.isPrivate()) {
  166.                      if (var5.isPublic()) {
  167.                         var1.error(var3.getWhere(), "override.public", var5, var5.getClassDeclaration());
  168.                         return;
  169.                      }
  170.  
  171.                      if (var5.isProtected() && !var3.isProtected()) {
  172.                         var1.error(var3.getWhere(), "override.protected", var5, var5.getClassDeclaration());
  173.                         return;
  174.                      }
  175.  
  176.                      if (var3.isPrivate()) {
  177.                         var1.error(var3.getWhere(), "override.private", var5, var5.getClassDeclaration());
  178.                         return;
  179.                      }
  180.                   }
  181.  
  182.                   if (var5.reportDeprecated(var1) && !var3.isDeprecated()) {
  183.                      var1.error(var3.getWhere(), "warn.override.is.deprecated", var5, var5.getClassDeclaration(), ((ClassDefinition)this).getClassDeclaration());
  184.                   }
  185.  
  186.                   ClassDeclaration[] var8 = var3.getExceptions(var1);
  187.                   ClassDeclaration[] var9 = var5.getExceptions(var1);
  188.  
  189.                   label98:
  190.                   for(int var10 = 0; var10 < var8.length; ++var10) {
  191.                      ClassDefinition var11 = var8[var10].getClassDefinition(var1);
  192.  
  193.                      for(int var12 = 0; var12 < var9.length; ++var12) {
  194.                         if (var11.subClassOf(var1, var9[var12])) {
  195.                            continue label98;
  196.                         }
  197.                      }
  198.  
  199.                      if (!var11.subClassOf(var1, var1.getClassDeclaration(Constants.idJavaLangError)) && !var11.subClassOf(var1, var1.getClassDeclaration(Constants.idJavaLangRuntimeException))) {
  200.                         var1.error(var3.getWhere(), "invalid.throws", var11, var5, var5.getClassDeclaration());
  201.                         break;
  202.                      }
  203.                   }
  204.                }
  205.             }
  206.          }
  207.       }
  208.  
  209.       if (var4.getSuperClass() != null) {
  210.          this.checkOverride(var1, var4.getSuperClass(), var3);
  211.       }
  212.  
  213.       ClassDeclaration[] var13 = var4.getInterfaces();
  214.  
  215.       for(int var14 = 0; var14 < var13.length; ++var14) {
  216.          this.checkOverride(var1, var13[var14], var3);
  217.       }
  218.  
  219.    }
  220.  
  221.    public void addField(Environment var1, FieldDefinition var2) {
  222.       switch (var2.getModifiers() & 7) {
  223.          case 3:
  224.          default:
  225.             var1.error(var2.getWhere(), "warn.inconsistent.modifier", var2);
  226.             if (var2.isPublic()) {
  227.                var2.subModifiers(6);
  228.             } else {
  229.                var2.subModifiers(2);
  230.             }
  231.          case 0:
  232.          case 1:
  233.          case 2:
  234.          case 4:
  235.             if (var2.isStatic() && !((ClassDefinition)this).isTopLevel()) {
  236.                if (var2.isMethod()) {
  237.                   var1.error(super.where, "static.inner.method", var2, this);
  238.                } else if (var2.isVariable()) {
  239.                   var1.error(super.where, "static.inner.field", var2.getName(), this);
  240.                }
  241.  
  242.                var2.subModifiers(8);
  243.             }
  244.  
  245.             if (var2.isMethod()) {
  246.                if (var2.isConstructor()) {
  247.                   if (var2.getClassDefinition().isInterface()) {
  248.                      var1.error(var2.getWhere(), "intf.constructor");
  249.                      return;
  250.                   }
  251.  
  252.                   if (var2.isNative() || var2.isAbstract() || var2.isStatic() || var2.isSynchronized() || var2.isFinal()) {
  253.                      var1.error(var2.getWhere(), "constr.modifier", var2);
  254.                      var2.subModifiers(1336);
  255.                   }
  256.                } else if (var2.isInitializer() && var2.getClassDefinition().isInterface()) {
  257.                   var1.error(var2.getWhere(), "intf.initializer");
  258.                   return;
  259.                }
  260.  
  261.                if (var2.getClassDefinition().isInterface() && (var2.isStatic() || var2.isSynchronized() || var2.isNative() || var2.isFinal() || var2.isPrivate() || var2.isProtected())) {
  262.                   var1.error(var2.getWhere(), "intf.modifier.method", var2);
  263.                   var2.subModifiers(314);
  264.                }
  265.  
  266.                if (var2.isTransient()) {
  267.                   var1.error(var2.getWhere(), "transient.meth", var2);
  268.                   var2.subModifiers(128);
  269.                }
  270.  
  271.                if (var2.isVolatile()) {
  272.                   var1.error(var2.getWhere(), "volatile.meth", var2);
  273.                   var2.subModifiers(64);
  274.                }
  275.  
  276.                if (var2.isStatic() && var2.isAbstract()) {
  277.                   var1.error(var2.getWhere(), "static.modifier", var2);
  278.                   var2.subModifiers(8);
  279.                }
  280.  
  281.                if (!var2.isAbstract() && !var2.isNative()) {
  282.                   if (var2.getValue() == null) {
  283.                      if (var2.isConstructor()) {
  284.                         var1.error(var2.getWhere(), "no.constructor.body", var2);
  285.                      } else {
  286.                         var1.error(var2.getWhere(), "no.meth.body", var2);
  287.                      }
  288.  
  289.                      var2.addModifiers(1024);
  290.                   }
  291.                } else if (var2.getValue() != null) {
  292.                   var1.error(var2.getWhere(), "invalid.meth.body", var2);
  293.                   var2.setValue((Node)null);
  294.                }
  295.  
  296.                Vector var3 = var2.getArguments();
  297.                if (var3 != null) {
  298.                   var3.size();
  299.                   Type[] var4 = var2.getType().getArgumentTypes();
  300.  
  301.                   for(int var5 = 0; var5 < var4.length; ++var5) {
  302.                      Object var6 = var3.elementAt(var5);
  303.                      int var7 = var2.getWhere();
  304.                      if (var6 instanceof FieldDefinition) {
  305.                         var7 = ((FieldDefinition)var6).getWhere();
  306.                         var6 = ((FieldDefinition)var6).getName();
  307.                      }
  308.  
  309.                      if (var4[var5].isType(11)) {
  310.                         var1.error(var7, "void.argument", var6);
  311.                      }
  312.                   }
  313.                }
  314.             } else if (var2.isInnerClass()) {
  315.                if (var2.isVolatile() || var2.isTransient() || var2.isNative() || var2.isSynchronized()) {
  316.                   var1.error(var2.getWhere(), "inner.modifier", var2);
  317.                   var2.subModifiers(480);
  318.                }
  319.  
  320.                if (var2.getClassDefinition().isInterface() && (var2.isPrivate() || var2.isProtected())) {
  321.                   var1.error(var2.getWhere(), "intf.modifier.field", var2);
  322.                   var2.subModifiers(6);
  323.                   var2.addModifiers(1);
  324.                }
  325.             } else {
  326.                if (var2.getType().isType(11)) {
  327.                   var1.error(var2.getWhere(), "void.inst.var", var2.getName());
  328.                   return;
  329.                }
  330.  
  331.                if (var2.isSynchronized() || var2.isAbstract() || var2.isNative()) {
  332.                   var1.error(var2.getWhere(), "var.modifier", var2);
  333.                   var2.subModifiers(1312);
  334.                }
  335.  
  336.                if (var2.isTransient() && ((ClassDefinition)this).isInterface()) {
  337.                   var1.error(var2.getWhere(), "transient.modifier", var2);
  338.                   var2.subModifiers(128);
  339.                }
  340.  
  341.                if (var2.isVolatile() && (((ClassDefinition)this).isInterface() || var2.isFinal())) {
  342.                   var1.error(var2.getWhere(), "volatile.modifier", var2);
  343.                   var2.subModifiers(64);
  344.                }
  345.  
  346.                if (var2.isFinal() && var2.getValue() == null && (((ClassDefinition)this).isInterface() || !var1.innerClasses())) {
  347.                   var1.error(var2.getWhere(), "initializer.needed", var2);
  348.                   var2.subModifiers(16);
  349.                }
  350.  
  351.                if (var2.getClassDefinition().isInterface() && (var2.isPrivate() || var2.isProtected())) {
  352.                   var1.error(var2.getWhere(), "intf.modifier.field", var2);
  353.                   var2.subModifiers(6);
  354.                   var2.addModifiers(1);
  355.                }
  356.             }
  357.  
  358.             if (!var2.isInitializer()) {
  359.                for(FieldDefinition var8 = ((ClassDefinition)this).getFirstMatch(var2.getName()); var8 != null; var8 = var8.getNextMatch()) {
  360.                   if (var2.isVariable() && var8.isVariable()) {
  361.                      var1.error(var2.getWhere(), "var.multidef", var2, var8);
  362.                      return;
  363.                   }
  364.  
  365.                   if (var2.isInnerClass() && var8.isInnerClass() && !var2.getInnerClass().isLocal() && !var8.getInnerClass().isLocal()) {
  366.                      var1.error(var2.getWhere(), "inner.class.multidef", var2);
  367.                      return;
  368.                   }
  369.                }
  370.             }
  371.  
  372.             super.addField(var1, var2);
  373.       }
  374.    }
  375.  
  376.    private void addAbstractMethodsFromInterfaces(Environment var1, ClassDefinition var2) throws ClassNotFound {
  377.       if (var2.isInterface()) {
  378.          for(FieldDefinition var3 = var2.getFirstField(); var3 != null; var3 = var3.getNextField()) {
  379.             if (var3.isMethod() && var3.isAbstract()) {
  380.                FieldDefinition var4 = ((ClassDefinition)this).findMethod(var1, var3.getName(), var3.getType());
  381.                if (var4 != null && var4.getType().equals(var3.getType())) {
  382.                   if (var3.isPublic() && !var4.isPublic()) {
  383.                      var1.error(((ClassDefinition)this).getWhere(), "private.intf.method", this, var4, var2);
  384.                   }
  385.                } else {
  386.                   SourceField var5 = new SourceField(var3, this, var1);
  387.                   ((ClassDefinition)this).addField(var5);
  388.                }
  389.             }
  390.          }
  391.       }
  392.  
  393.       ClassDeclaration[] var7 = var2.getInterfaces();
  394.  
  395.       for(int var8 = 0; var8 < var7.length; ++var8) {
  396.          ClassDefinition var6 = var7[var8].getClassDefinition(var1);
  397.          this.addAbstractMethodsFromInterfaces(var1, var6);
  398.       }
  399.  
  400.    }
  401.  
  402.    public Environment setupEnv(Environment var1) {
  403.       return new Environment(this.toplevelEnv, this);
  404.    }
  405.  
  406.    public boolean reportDeprecated(Environment var1) {
  407.       return false;
  408.    }
  409.  
  410.    public void noteUsedBy(ClassDefinition var1, int var2, Environment var3) {
  411.       super.noteUsedBy(var1, var2, var3);
  412.  
  413.       Object var4;
  414.       for(var4 = this; ((ClassDefinition)var4).isInnerClass(); var4 = ((ClassDefinition)var4).getOuterClass()) {
  415.       }
  416.  
  417.       if (!((ClassDefinition)var4).isPublic()) {
  418.          while(var1.isInnerClass()) {
  419.             var1 = var1.getOuterClass();
  420.          }
  421.  
  422.          if (!((ClassDefinition)var4).getSource().equals(var1.getSource())) {
  423.             ((SourceClass)var4).checkSourceFile(var3, var2);
  424.          }
  425.       }
  426.    }
  427.  
  428.    public void check(Environment var1) throws ClassNotFound {
  429.       if (((ClassDefinition)this).isInsideLocal()) {
  430.          ((ClassDefinition)this).getOuterClass().check(var1);
  431.       } else {
  432.          if (((ClassDefinition)this).isInnerClass()) {
  433.             ((SourceClass)((ClassDefinition)this).getOuterClass()).maybeCheck(var1);
  434.          }
  435.  
  436.          Vset var2 = new Vset();
  437.          Object var3 = null;
  438.          this.checkInternal(this.setupEnv(var1), (Context)var3, var2);
  439.       }
  440.    }
  441.  
  442.    private void maybeCheck(Environment var1) throws ClassNotFound {
  443.       ClassDeclaration var2 = ((ClassDefinition)this).getClassDeclaration();
  444.       if (var2.getStatus() == 4) {
  445.          var2.setDefinition(this, 7);
  446.          this.check(var1);
  447.       }
  448.  
  449.    }
  450.  
  451.    private Vset checkInternal(Environment var1, Context var2, Vset var3) throws ClassNotFound {
  452.       Identifier var4 = ((ClassDefinition)this).getClassDeclaration().getName();
  453.       if (var1.verbose()) {
  454.          var1.output("[checking class " + var4 + "]");
  455.       }
  456.  
  457.       this.basicCheck(Context.newEnvironment(var1, var2));
  458.       if (!((ClassDefinition)this).isInnerClass() && !((ClassDefinition)this).isInsideLocal()) {
  459.          var4 = var4.getName();
  460.  
  461.          try {
  462.             Imports var5 = this.toplevelEnv.getImports();
  463.             Identifier var11 = var5.resolve(var1, var4);
  464.             if (var11 != ((ClassDefinition)this).getName()) {
  465.                var1.error(super.where, "class.multidef.import", var4, var11);
  466.             }
  467.          } catch (AmbiguousClass var7) {
  468.             Identifier var6 = var7.name1 != ((ClassDefinition)this).getName() ? var7.name1 : var7.name2;
  469.             var1.error(super.where, "class.multidef.import", var4, var6);
  470.          } catch (ClassNotFound var8) {
  471.          }
  472.  
  473.          if (((ClassDefinition)this).isPublic()) {
  474.             this.checkSourceFile(var1, ((ClassDefinition)this).getWhere());
  475.          }
  476.       }
  477.  
  478.       var3 = this.checkFields(var1, var2, var3);
  479.       return var3;
  480.    }
  481.  
  482.    public void checkSourceFile(Environment var1, int var2) {
  483.       if (!this.sourceFileChecked) {
  484.          this.sourceFileChecked = true;
  485.          String var3 = ((ClassDefinition)this).getName().getName() + ".java";
  486.          String var4 = ((ClassFile)((ClassDefinition)this).getSource()).getName();
  487.          if (var1.warnings() && !var4.equals(var3)) {
  488.             if (((ClassDefinition)this).isPublic()) {
  489.                var1.error(var2, "public.class.file", this, var3);
  490.                return;
  491.             }
  492.  
  493.             var1.error(var2, "warn.package.class.file", this, var4, var3);
  494.          }
  495.  
  496.       }
  497.    }
  498.  
  499.    private void checkSupers(Environment var1) throws ClassNotFound {
  500.       if (((ClassDefinition)this).isInterface()) {
  501.          if (((ClassDefinition)this).isFinal()) {
  502.             Identifier var2 = ((ClassDefinition)this).getClassDeclaration().getName();
  503.             var1.error(((ClassDefinition)this).getWhere(), "final.intf", var2);
  504.          }
  505.       } else if (((ClassDefinition)this).getSuperClass(var1) != null) {
  506.          int var8 = ((ClassDefinition)this).getWhere();
  507.          var8 = IdentifierToken.getWhere(super.superClassId, var8);
  508.  
  509.          try {
  510.             ClassDefinition var3 = ((ClassDefinition)this).getSuperClass().getClassDefinition(var1);
  511.             var3.resolveTypeStructure(var1);
  512.             if (!((ClassDefinition)this).canAccess(var1, ((ClassDefinition)this).getSuperClass())) {
  513.                var1.error(var8, "cant.access.class", ((ClassDefinition)this).getSuperClass());
  514.                super.superClass = null;
  515.             } else if (var3.isFinal()) {
  516.                var1.error(var8, "super.is.final", ((ClassDefinition)this).getSuperClass());
  517.                super.superClass = null;
  518.             } else if (var3.isInterface()) {
  519.                var1.error(var8, "super.is.intf", ((ClassDefinition)this).getSuperClass());
  520.                super.superClass = null;
  521.             } else if (((ClassDefinition)this).superClassOf(var1, ((ClassDefinition)this).getSuperClass())) {
  522.                var1.error(var8, "cyclic.super");
  523.                super.superClass = null;
  524.             } else {
  525.                var3.noteUsedBy(this, var8, var1);
  526.             }
  527.  
  528.             if (super.superClass == null) {
  529.                var3 = null;
  530.             }
  531.  
  532.             ClassDefinition var4 = var3;
  533.  
  534.             while(true) {
  535.                if (((ClassDefinition)this).enclosingClassOf(var4)) {
  536.                   var1.error(var8, "super.is.inner");
  537.                   super.superClass = null;
  538.                   break;
  539.                }
  540.  
  541.                ClassDeclaration var5 = var4.getSuperClass(var1);
  542.                if (var5 == null) {
  543.                   break;
  544.                }
  545.  
  546.                var4 = var5.getClassDefinition(var1);
  547.             }
  548.          } catch (ClassNotFound var7) {
  549.             var1.error(var8, "super.not.found", var7.name, this);
  550.             super.superClass = null;
  551.          }
  552.       } else if (((ClassDefinition)this).isAnonymous()) {
  553.          throw new CompilerError("anonymous super");
  554.       }
  555.  
  556.       for(int var10 = 0; var10 < super.interfaces.length; ++var10) {
  557.          ClassDeclaration var11 = super.interfaces[var10];
  558.          int var12 = ((ClassDefinition)this).getWhere();
  559.          if (super.interfaceIds != null && super.interfaceIds.length == super.interfaces.length) {
  560.             var12 = IdentifierToken.getWhere(super.interfaceIds[var10], var12);
  561.          }
  562.  
  563.          try {
  564.             ClassDefinition var13 = var11.getClassDefinition(var1);
  565.             var13.resolveTypeStructure(var1);
  566.             if (!((ClassDefinition)this).canAccess(var1, var11)) {
  567.                var1.error(var12, "cant.access.class", var11);
  568.             } else if (!var11.getClassDefinition(var1).isInterface()) {
  569.                var1.error(var12, "not.intf", var11);
  570.             } else {
  571.                if (!((ClassDefinition)this).isInterface() || !((ClassDefinition)this).implementedBy(var1, var11)) {
  572.                   var13.noteUsedBy(this, var12, var1);
  573.                   continue;
  574.                }
  575.  
  576.                var1.error(var12, "cyclic.intf", var11);
  577.             }
  578.          } catch (ClassNotFound var6) {
  579.             var1.error(var12, "intf.not.found", var6.name, this);
  580.          }
  581.  
  582.          ClassDeclaration[] var14 = new ClassDeclaration[super.interfaces.length - 1];
  583.          System.arraycopy(super.interfaces, 0, var14, 0, var10);
  584.          System.arraycopy(super.interfaces, var10 + 1, var14, var10, var14.length - var10);
  585.          super.interfaces = var14;
  586.          --var10;
  587.       }
  588.  
  589.    }
  590.  
  591.    private Vset checkFields(Environment var1, Context var2, Vset var3) throws ClassNotFound {
  592.       if (((ClassDefinition)this).getError()) {
  593.          return var3;
  594.       } else {
  595.          try {
  596.             for(FieldDefinition var4 = ((ClassDefinition)this).getFirstField(); var4 != null; var4 = var4.getNextField()) {
  597.                if (!var4.isVariable() && !var4.isInitializer()) {
  598.                   if (((ClassDefinition)this).getSuperClass() != null) {
  599.                      this.checkOverride(var1, ((ClassDefinition)this).getSuperClass(), var4);
  600.                   }
  601.  
  602.                   for(int var5 = 0; var5 < super.interfaces.length; ++var5) {
  603.                      this.checkOverride(var1, super.interfaces[var5], var4);
  604.                   }
  605.                }
  606.             }
  607.          } catch (ClassNotFound var18) {
  608.             var1.error(((ClassDefinition)this).getWhere(), "class.not.found", var18.name, this);
  609.          }
  610.  
  611.          if (((ClassDefinition)this).getError()) {
  612.             return var3;
  613.          } else {
  614.             if (((ClassDefinition)this).isFinal() && ((ClassDefinition)this).isAbstract()) {
  615.                var1.error(super.where, "final.abstract", ((ClassDefinition)this).getName().getName());
  616.             }
  617.  
  618.             if (!((ClassDefinition)this).isInterface() && !((ClassDefinition)this).isAbstract() && ((ClassDefinition)this).isAbstract(var1)) {
  619.                super.modifiers |= 1024;
  620.                String var19 = ((ClassDefinition)this).isFinal() ? "abstract.class.not.final" : "abstract.class";
  621.                Enumeration var21 = ((ClassDefinition)this).getAbstractFields(var1);
  622.  
  623.                while(var21.hasMoreElements()) {
  624.                   FieldDefinition var6 = (FieldDefinition)var21.nextElement();
  625.                   var1.error(super.where, var19, this, var6, var6.getDefiningClassDeclaration());
  626.                }
  627.             }
  628.  
  629.             Context var20 = new Context(var2);
  630.             Vset var22 = var3.copy();
  631.             Vset var24 = var3.copy();
  632.  
  633.             for(FieldDefinition var7 = ((ClassDefinition)this).getFirstField(); var7 != null; var7 = var7.getNextField()) {
  634.                if (var7.isVariable() && var7.isBlankFinal()) {
  635.                   int var8 = var20.declareMemberNumber(var7);
  636.                   if (var7.isStatic()) {
  637.                      var24 = var24.addVarUnassigned(var8);
  638.                      var22 = var22.addVar(var8);
  639.                   } else {
  640.                      var22 = var22.addVarUnassigned(var8);
  641.                      var24 = var24.addVar(var8);
  642.                   }
  643.                }
  644.             }
  645.  
  646.             Context var25 = new Context(var20, this);
  647.             LocalField var9 = this.getThisArgument();
  648.             int var10 = var25.declare(var1, var9);
  649.             var22 = var22.addVar(var10);
  650.             int var11 = ((ClassDefinition)this).getWhere();
  651.  
  652.             for(FieldDefinition var12 = ((ClassDefinition)this).getFirstField(); var12 != null; var12 = var12.getNextField()) {
  653.                try {
  654.                   if (var12.isVariable() || var12.isInitializer()) {
  655.                      if (var12.isStatic()) {
  656.                         var24 = var12.check(var1, var20, var24);
  657.                         if (var12.isInitializer()) {
  658.                            var11 = var12.getWhere();
  659.                         }
  660.                      } else {
  661.                         var22 = var12.check(var1, var25, var22);
  662.                      }
  663.                   }
  664.                } catch (ClassNotFound var17) {
  665.                   var1.error(var12.getWhere(), "class.not.found", var17.name, this);
  666.                }
  667.             }
  668.  
  669.             this.checkBlankFinals(var1, var20, var24, true, var11);
  670.  
  671.             for(FieldDefinition var13 = ((ClassDefinition)this).getFirstField(); var13 != null; var13 = var13.getNextField()) {
  672.                try {
  673.                   if (var13.isConstructor()) {
  674.                      Vset var14 = var13.check(var1, var20, var22.copy());
  675.                      this.checkBlankFinals(var1, var20, var14, false, var13.getWhere());
  676.                   } else {
  677.                      var13.check(var1, var2, var3.copy());
  678.                   }
  679.                } catch (ClassNotFound var16) {
  680.                   var1.error(var13.getWhere(), "class.not.found", var16.name, this);
  681.                }
  682.             }
  683.  
  684.             for(FieldDefinition var26 = ((ClassDefinition)this).getFirstField(); var26 != null; var26 = var26.getNextField()) {
  685.                if (var26.isInnerClass()) {
  686.                   SourceClass var15 = (SourceClass)var26.getInnerClass();
  687.                   if (!((ClassDefinition)var15).isInsideLocal()) {
  688.                      var15.maybeCheck(var1);
  689.                   }
  690.                }
  691.             }
  692.  
  693.             return var3;
  694.          }
  695.       }
  696.    }
  697.  
  698.    private void checkBlankFinals(Environment var1, Context var2, Vset var3, boolean var4, int var5) {
  699.       for(int var6 = 0; var6 < var2.getVarNumber(); ++var6) {
  700.          if (!var3.testVar(var6)) {
  701.             FieldDefinition var7 = var2.getElement(var6);
  702.             if (var7 != null && var7.isBlankFinal() && var7.isStatic() == var4 && var7.getClassDefinition() == this) {
  703.                var1.error(var5, "final.var.not.initialized", var7.getName());
  704.             }
  705.          }
  706.       }
  707.  
  708.    }
  709.  
  710.    protected void basicCheck(Environment var1) throws ClassNotFound {
  711.       super.basicCheck(var1);
  712.       if (!this.basicChecking && !this.basicCheckDone) {
  713.          this.basicChecking = true;
  714.          var1 = this.setupEnv(var1);
  715.          Imports var2 = var1.getImports();
  716.          if (var2 != null) {
  717.             var2.resolve(var1);
  718.          }
  719.  
  720.          this.resolveTypeStructure(var1);
  721.          this.checkSupers(var1);
  722.          if (!((ClassDefinition)this).isInterface()) {
  723.             if (!((ClassDefinition)this).hasConstructor()) {
  724.                CompoundStatement var3 = new CompoundStatement(((ClassDefinition)this).getWhere(), new Statement[0]);
  725.                Type var4 = Type.tMethod(Type.tVoid);
  726.                var1.makeFieldDefinition(var1, ((ClassDefinition)this).getWhere(), this, (String)null, ((ClassDefinition)this).isPublic() ? 1 : 0, var4, Constants.idInit, (IdentifierToken[])null, (IdentifierToken[])null, var3);
  727.             }
  728.  
  729.             if (!((ClassDefinition)this).getError()) {
  730.                this.addAbstractMethodsFromInterfaces(var1, this);
  731.             }
  732.          }
  733.  
  734.          this.basicChecking = false;
  735.          this.basicCheckDone = true;
  736.       }
  737.    }
  738.  
  739.    public void resolveTypeStructure(Environment var1) {
  740.       ClassDefinition var2 = ((ClassDefinition)this).getOuterClass();
  741.       if (var2 != null && var2 instanceof SourceClass && !((SourceClass)var2).resolved) {
  742.          ((SourceClass)var2).resolveTypeStructure(var1);
  743.       }
  744.  
  745.       if (!super.resolved) {
  746.          super.resolved = true;
  747.          var1 = this.setupEnv(var1);
  748.          this.resolveSupers(var1);
  749.  
  750.          for(FieldDefinition var3 = ((ClassDefinition)this).getFirstField(); var3 != null; var3 = var3.getNextField()) {
  751.             if (var3 instanceof SourceField) {
  752.                ((SourceField)var3).resolveTypeStructure(var1);
  753.             }
  754.          }
  755.  
  756.          for(FieldDefinition var4 = ((ClassDefinition)this).getFirstField(); var4 != null; var4 = var4.getNextField()) {
  757.             if (!var4.isInitializer() && var4.isMethod()) {
  758.                FieldDefinition var5 = var4;
  759.  
  760.                while((var5 = var5.getNextMatch()) != null) {
  761.                   if (var5.isMethod()) {
  762.                      if (var4.getType().equals(var5.getType())) {
  763.                         var1.error(var4.getWhere(), "meth.multidef", var4);
  764.                      } else if (var4.getType().equalArguments(var5.getType())) {
  765.                         var1.error(var4.getWhere(), "meth.redef.rettype", var4, var5);
  766.                      }
  767.                   }
  768.                }
  769.             }
  770.          }
  771.  
  772.       }
  773.    }
  774.  
  775.    protected void resolveSupers(Environment var1) {
  776.       if (super.superClassId != null && super.superClass == null) {
  777.          super.superClass = this.resolveSuper(var1, super.superClassId);
  778.          if (super.superClass == ((ClassDefinition)this).getClassDeclaration() && ((ClassDefinition)this).getName().equals(Constants.idJavaLangObject)) {
  779.             super.superClass = null;
  780.             super.superClassId = null;
  781.          }
  782.       }
  783.  
  784.       if (super.interfaceIds != null && super.interfaces == null) {
  785.          super.interfaces = new ClassDeclaration[super.interfaceIds.length];
  786.  
  787.          for(int var2 = 0; var2 < super.interfaces.length; ++var2) {
  788.             super.interfaces[var2] = this.resolveSuper(var1, super.interfaceIds[var2]);
  789.  
  790.             for(int var3 = 0; var3 < var2; ++var3) {
  791.                if (super.interfaces[var2] == super.interfaces[var3]) {
  792.                   Identifier var4 = super.interfaceIds[var2].getName();
  793.                   int var5 = super.interfaceIds[var3].getWhere();
  794.                   var1.error(var5, "intf.repeated", var4);
  795.                }
  796.             }
  797.          }
  798.       }
  799.  
  800.    }
  801.  
  802.    private ClassDeclaration resolveSuper(Environment var1, IdentifierToken var2) {
  803.       Identifier var3 = var2.getName();
  804.       if (((ClassDefinition)this).isInnerClass()) {
  805.          var3 = super.outerClass.resolveName(var1, var3);
  806.       } else {
  807.          var3 = var1.resolveName(var3);
  808.       }
  809.  
  810.       return var1.getClassDeclaration(var3);
  811.    }
  812.  
  813.    public Vset checkLocalClass(Environment var1, Context var2, Vset var3, ClassDefinition var4, Expression[] var5, Type[] var6) throws ClassNotFound {
  814.       var1 = this.setupEnv(var1);
  815.       if (var4 != null != ((ClassDefinition)this).isAnonymous()) {
  816.          throw new CompilerError("resolveAnonymousStructure");
  817.       } else {
  818.          if (((ClassDefinition)this).isAnonymous()) {
  819.             this.resolveAnonymousStructure(var1, var4, var5, var6);
  820.          }
  821.  
  822.          var3 = this.checkInternal(var1, var2, var3);
  823.          ((ClassDefinition)this).getClassDeclaration().setDefinition(this, 7);
  824.          return var3;
  825.       }
  826.    }
  827.  
  828.    public void inlineLocalClass(Environment var1) {
  829.       for(FieldDefinition var2 = ((ClassDefinition)this).getFirstField(); var2 != null; var2 = var2.getNextField()) {
  830.          if (!var2.isVariable() && !var2.isInitializer() || var2.isStatic()) {
  831.             try {
  832.                ((SourceField)var2).inline(var1);
  833.             } catch (ClassNotFound var4) {
  834.                var1.error(var2.getWhere(), "class.not.found", var4.name, this);
  835.             }
  836.          }
  837.       }
  838.  
  839.       if (((ClassDefinition)this).getReferencesFrozen() != null && !this.inlinedLocalClass) {
  840.          this.inlinedLocalClass = true;
  841.  
  842.          for(FieldDefinition var3 = ((ClassDefinition)this).getFirstField(); var3 != null; var3 = var3.getNextField()) {
  843.             if (var3.isConstructor()) {
  844.                ((SourceField)var3).addUplevelArguments(false);
  845.             }
  846.          }
  847.       }
  848.  
  849.    }
  850.  
  851.    public Vset checkInsideClass(Environment var1, Context var2, Vset var3) throws ClassNotFound {
  852.       if (((ClassDefinition)this).isInsideLocal() && !((ClassDefinition)this).isLocal()) {
  853.          return this.checkInternal(var1, var2, var3);
  854.       } else {
  855.          throw new CompilerError("checkInsideClass");
  856.       }
  857.    }
  858.  
  859.    private void resolveAnonymousStructure(Environment var1, ClassDefinition var2, Expression[] var3, Type[] var4) throws ClassNotFound {
  860.       if (super.superClass == null && super.superClassId.getName() == Constants.idNull) {
  861.          if (var2.isInterface()) {
  862.             int var5 = super.interfaces == null ? 0 : super.interfaces.length;
  863.             ClassDeclaration[] var6 = new ClassDeclaration[1 + var5];
  864.             if (var5 > 0) {
  865.                System.arraycopy(super.interfaces, 0, var6, 1, var5);
  866.                if (super.interfaceIds != null && super.interfaceIds.length == var5) {
  867.                   IdentifierToken[] var7 = new IdentifierToken[1 + var5];
  868.                   System.arraycopy(super.interfaceIds, 0, var7, 1, var5);
  869.                   var7[0] = new IdentifierToken(var2.getName());
  870.                }
  871.             }
  872.  
  873.             var6[0] = var2.getClassDeclaration();
  874.             super.interfaces = var6;
  875.             var2 = this.toplevelEnv.getClassDefinition(Constants.idJavaLangObject);
  876.          }
  877.  
  878.          super.superClass = var2.getClassDeclaration();
  879.          if (((ClassDefinition)this).hasConstructor()) {
  880.             throw new CompilerError("anonymous constructor");
  881.          } else {
  882.             Type var17 = Type.tMethod(Type.tVoid, var4);
  883.             IdentifierToken[] var18 = new IdentifierToken[var4.length];
  884.  
  885.             for(int var19 = 0; var19 < var18.length; ++var19) {
  886.                var18[var19] = new IdentifierToken(var3[var19].getWhere(), Identifier.lookup("$" + var19));
  887.             }
  888.  
  889.             int var8 = !var2.isTopLevel() && !var2.isLocal() ? 1 : 0;
  890.             Expression[] var9 = new Expression[-var8 + var3.length];
  891.  
  892.             for(int var10 = var8; var10 < var3.length; ++var10) {
  893.                var9[-var8 + var10] = new IdentifierExpression(var18[var10]);
  894.             }
  895.  
  896.             int var11 = ((ClassDefinition)this).getWhere();
  897.             SuperExpression var12;
  898.             if (var8 == 0) {
  899.                var12 = new SuperExpression(var11);
  900.             } else {
  901.                var12 = new SuperExpression(var11, new IdentifierExpression(var18[0]));
  902.             }
  903.  
  904.             MethodExpression var13 = new MethodExpression(var11, var12, Constants.idInit, var9);
  905.             Statement[] var14 = new Statement[]{new ExpressionStatement(var11, var13)};
  906.             CompoundStatement var15 = new CompoundStatement(var11, var14);
  907.             int var16 = 524288;
  908.             var1.makeFieldDefinition(var1, var11, this, (String)null, var16, var17, Constants.idInit, var18, (IdentifierToken[])null, var15);
  909.          }
  910.       } else {
  911.          throw new CompilerError("superclass " + super.superClass);
  912.       }
  913.    }
  914.  
  915.    public FieldDefinition getAccessField(Environment var1, Context var2, FieldDefinition var3) {
  916.       return this.getAccessField(var1, var2, var3, false);
  917.    }
  918.  
  919.    public FieldDefinition getUpdateField(Environment var1, Context var2, FieldDefinition var3) {
  920.       if (!var3.isVariable()) {
  921.          throw new CompilerError("method");
  922.       } else {
  923.          return this.getAccessField(var1, var2, var3, true);
  924.       }
  925.    }
  926.  
  927.    private FieldDefinition getAccessField(Environment var1, Context var2, FieldDefinition var3, boolean var4) {
  928.       boolean var5 = var3.isStatic();
  929.       boolean var6 = var3.isMethod();
  930.       if (var3.isConstructor()) {
  931.          return null;
  932.       } else {
  933.          FieldDefinition var7;
  934.          for(var7 = ((ClassDefinition)this).getFirstField(); var7 != null && (var7.getAccessMethodTarget() != var3 || !var6 && var7.getType().getArgumentTypes().length != 0); var7 = var7.getNextField()) {
  935.          }
  936.  
  937.          if (var7 != null) {
  938.             if (!var4) {
  939.                return var7;
  940.             }
  941.  
  942.             FieldDefinition var8 = var7.getAccessUpdateField();
  943.             if (var8 != null) {
  944.                return var8;
  945.             }
  946.          } else if (var4) {
  947.             var7 = this.getAccessField(var1, var2, var3, false);
  948.          }
  949.  
  950.          int var9 = 0;
  951.  
  952.          while(true) {
  953.             Identifier var24 = Identifier.lookup("access$" + var9);
  954.             if (((ClassDefinition)this).getFirstMatch(var24) == null) {
  955.                Type var10 = var3.getType();
  956.                if (!var6) {
  957.                   if (!var4) {
  958.                      var10 = Type.tMethod(var10);
  959.                   } else {
  960.                      Type[] var11 = new Type[]{var10};
  961.                      var10 = Type.tMethod(Type.tVoid, var11);
  962.                   }
  963.                }
  964.  
  965.                int var25 = var3.getWhere();
  966.                Type[] var12 = var10.getArgumentTypes();
  967.                IdentifierToken[] var13 = new IdentifierToken[var12.length];
  968.  
  969.                for(int var14 = 0; var14 < var13.length; ++var14) {
  970.                   var13[var14] = new IdentifierToken(var25, Identifier.lookup("$" + var14));
  971.                }
  972.  
  973.                Expression[] var15 = new Expression[var13.length];
  974.  
  975.                for(int var16 = 0; var16 < var15.length; ++var16) {
  976.                   var15[var16] = new IdentifierExpression(var13[var16]);
  977.                }
  978.  
  979.                ThisExpression var17 = null;
  980.                if (!var5) {
  981.                   var17 = new ThisExpression(var25, this.getThisArgument());
  982.                }
  983.  
  984.                Object var26;
  985.                if (!var6) {
  986.                   var26 = new FieldExpression(var25, var17, var3);
  987.                   if (var4) {
  988.                      var26 = new AssignExpression(var25, (Expression)var26, var15[0]);
  989.                   }
  990.                } else {
  991.                   var26 = new MethodExpression(var25, var17, var3, var15);
  992.                }
  993.  
  994.                Object var18;
  995.                if (var10.getReturnType().isType(11)) {
  996.                   var18 = new ExpressionStatement(var25, (Expression)var26);
  997.                } else {
  998.                   var18 = new ReturnStatement(var25, (Expression)var26);
  999.                }
  1000.  
  1001.                Statement[] var19 = new Statement[]{(Statement)var18};
  1002.                CompoundStatement var27 = new CompoundStatement(var25, var19);
  1003.                int var20 = 524304;
  1004.                if (var5) {
  1005.                   var20 |= 8;
  1006.                }
  1007.  
  1008.                SourceField var21 = (SourceField)var1.makeFieldDefinition(var1, var25, this, (String)null, var20, var10, var24, var13, (IdentifierToken[])null, var27);
  1009.                ((FieldDefinition)var21).setAccessMethodTarget(var3);
  1010.                if (var4) {
  1011.                   var7.setAccessUpdateField(var21);
  1012.                }
  1013.  
  1014.                try {
  1015.                   var21.check(var1, var2, new Vset());
  1016.                } catch (ClassNotFound var23) {
  1017.                   var1.error(var25, "class.not.found", var23.name, this);
  1018.                }
  1019.  
  1020.                return var21;
  1021.             }
  1022.  
  1023.             ++var9;
  1024.          }
  1025.       }
  1026.    }
  1027.  
  1028.    public void compile(OutputStream var1) throws InterruptedException, IOException {
  1029.       Environment var2 = this.toplevelEnv;
  1030.       Vector var3 = active;
  1031.       synchronized(var3){}
  1032.  
  1033.       try {
  1034.          while(active.contains(((ClassDefinition)this).getName())) {
  1035.             active.wait();
  1036.          }
  1037.  
  1038.          active.addElement(((ClassDefinition)this).getName());
  1039.       } catch (Throwable var28) {
  1040.          throw var28;
  1041.       }
  1042.  
  1043.       try {
  1044.          this.compileClass(var2, var1);
  1045.       } catch (ClassNotFound var26) {
  1046.          throw new CompilerError(var26);
  1047.       } finally {
  1048.          Vector var5 = active;
  1049.          synchronized(var5){}
  1050.  
  1051.          try {
  1052.             active.removeElement(((ClassDefinition)this).getName());
  1053.             active.notifyAll();
  1054.          } catch (Throwable var25) {
  1055.             throw var25;
  1056.          }
  1057.  
  1058.       }
  1059.  
  1060.    }
  1061.  
  1062.    protected void compileClass(Environment var1, OutputStream var2) throws IOException, ClassNotFound {
  1063.       Vector var3 = new Vector();
  1064.       Vector var4 = new Vector();
  1065.       Vector var5 = new Vector();
  1066.       CompilerField var6 = new CompilerField(new FieldDefinition(((ClassDefinition)this).getWhere(), this, 8, Type.tMethod(Type.tVoid), Constants.idClassInit, (IdentifierToken[])null, (Node)null), new Assembler());
  1067.       Context var7 = new Context((Context)null, var6.field);
  1068.  
  1069.       for(Object var8 = this; ((ClassDefinition)var8).isInnerClass(); var8 = ((ClassDefinition)var8).getOuterClass()) {
  1070.          var5.addElement(var8);
  1071.       }
  1072.  
  1073.       int var9 = var5.size();
  1074.       int var10 = var9;
  1075.  
  1076.       while(true) {
  1077.          --var10;
  1078.          if (var10 < 0) {
  1079.             int var11 = var9;
  1080.  
  1081.             while(true) {
  1082.                --var11;
  1083.                if (var11 < 0) {
  1084.                   boolean var12 = ((ClassDefinition)this).isDeprecated();
  1085.                   boolean var13 = ((ClassDefinition)this).isSynthetic();
  1086.  
  1087.                   for(FieldDefinition var14 = ((ClassDefinition)this).getFirstField(); var14 != null; var14 = var14.getNextField()) {
  1088.                      var12 |= var14.isDeprecated();
  1089.                      var13 |= var14.isSynthetic();
  1090.  
  1091.                      try {
  1092.                         if (var14.isMethod()) {
  1093.                            if (var14.isInitializer()) {
  1094.                               if (var14.isStatic()) {
  1095.                                  ((SourceField)var14).code(var1, var6.asm);
  1096.                               }
  1097.                            } else {
  1098.                               CompilerField var15 = new CompilerField(var14, new Assembler());
  1099.                               ((SourceField)var14).code(var1, var15.asm);
  1100.                               var4.addElement(var15);
  1101.                            }
  1102.                         } else if (var14.isInnerClass()) {
  1103.                            var5.addElement(var14.getInnerClass());
  1104.                         } else if (var14.isVariable()) {
  1105.                            ((SourceField)var14).inline(var1);
  1106.                            CompilerField var40 = new CompilerField(var14, (Assembler)null);
  1107.                            var3.addElement(var40);
  1108.                            if (var14.isStatic()) {
  1109.                               var14.codeInit(var1, var7, var6.asm);
  1110.                            }
  1111.                         }
  1112.                      } catch (CompilerError var38) {
  1113.                         var38.printStackTrace();
  1114.                         var1.error(var14, 0, "generic", var14.getClassDeclaration() + ":" + var14 + "@" + ((Throwable)var38).toString(), (Object)null, (Object)null);
  1115.                      }
  1116.                   }
  1117.  
  1118.                   if (!var6.asm.empty()) {
  1119.                      var6.asm.add(((ClassDefinition)this).getWhere(), 177, true);
  1120.                      var4.addElement(var6);
  1121.                   }
  1122.  
  1123.                   if (((ClassDefinition)this).getError()) {
  1124.                      return;
  1125.                   } else {
  1126.                      int var41 = 0;
  1127.                      this.tab.put("Code");
  1128.                      this.tab.put("ConstantValue");
  1129.                      this.tab.put("LocalVariables");
  1130.                      this.tab.put("SourceFile");
  1131.                      ++var41;
  1132.                      this.tab.put("Exceptions");
  1133.                      if (!var1.optimize()) {
  1134.                         this.tab.put("LineNumberTable");
  1135.                      }
  1136.  
  1137.                      if (var12) {
  1138.                         this.tab.put("Deprecated");
  1139.                         if (((ClassDefinition)this).isDeprecated()) {
  1140.                            ++var41;
  1141.                         }
  1142.                      }
  1143.  
  1144.                      if (var13) {
  1145.                         this.tab.put("Synthetic");
  1146.                         if (((ClassDefinition)this).isSynthetic()) {
  1147.                            ++var41;
  1148.                         }
  1149.                      }
  1150.  
  1151.                      if (var1.coverage()) {
  1152.                         var41 += 2;
  1153.                         this.tab.put("AbsoluteSourcePath");
  1154.                         this.tab.put("TimeStamp");
  1155.                         this.tab.put("CoverageTable");
  1156.                      }
  1157.  
  1158.                      if (var1.debug()) {
  1159.                         this.tab.put("LocalVariableTable");
  1160.                      }
  1161.  
  1162.                      if (var5.size() > 0) {
  1163.                         if (!var1.innerClasses()) {
  1164.                            throw new CompilerError("compileClass");
  1165.                         }
  1166.  
  1167.                         this.tab.put("InnerClasses");
  1168.                         ++var41;
  1169.                      }
  1170.  
  1171.                      String var16 = ((ClassFile)((ClassDefinition)this).getSource()).getName();
  1172.                      this.tab.put(var16);
  1173.                      String var17 = "";
  1174.                      long var18 = 0L;
  1175.                      if (var1.coverage()) {
  1176.                         var17 = this.getAbsoluteName();
  1177.                         var18 = System.currentTimeMillis();
  1178.                         this.tab.put(var17);
  1179.                      }
  1180.  
  1181.                      this.tab.put(((ClassDefinition)this).getClassDeclaration());
  1182.                      if (((ClassDefinition)this).getSuperClass() != null) {
  1183.                         this.tab.put(((ClassDefinition)this).getSuperClass());
  1184.                      }
  1185.  
  1186.                      for(int var20 = 0; var20 < super.interfaces.length; ++var20) {
  1187.                         this.tab.put(super.interfaces[var20]);
  1188.                      }
  1189.  
  1190.                      Enumeration var21 = var4.elements();
  1191.  
  1192.                      while(var21.hasMoreElements()) {
  1193.                         CompilerField var22 = (CompilerField)var21.nextElement();
  1194.  
  1195.                         try {
  1196.                            var22.asm.optimize(var1);
  1197.                            var22.asm.collect(var1, var22.field, this.tab);
  1198.                            this.tab.put(var22.name);
  1199.                            this.tab.put(var22.sig);
  1200.                            ClassDeclaration[] var23 = var22.field.getExceptions(var1);
  1201.  
  1202.                            for(int var24 = 0; var24 < var23.length; ++var24) {
  1203.                               this.tab.put(var23[var24]);
  1204.                            }
  1205.                         } catch (Exception var39) {
  1206.                            ((Throwable)var39).printStackTrace();
  1207.                            var1.error(var22.field, -1, "generic", var22.field.getName() + "@" + ((Throwable)var39).toString(), (Object)null, (Object)null);
  1208.                            var22.asm.listing(System.out);
  1209.                         }
  1210.                      }
  1211.  
  1212.                      Enumeration var43 = var3.elements();
  1213.  
  1214.                      while(var43.hasMoreElements()) {
  1215.                         CompilerField var44 = (CompilerField)var43.nextElement();
  1216.                         this.tab.put(var44.name);
  1217.                         this.tab.put(var44.sig);
  1218.                         Object var46 = var44.field.getInitialValue();
  1219.                         if (var46 != null) {
  1220.                            this.tab.put(var46 instanceof String ? new StringExpression(var44.field.getWhere(), (String)var46) : var46);
  1221.                         }
  1222.                      }
  1223.  
  1224.                      Enumeration var45 = var5.elements();
  1225.  
  1226.                      while(var45.hasMoreElements()) {
  1227.                         ClassDefinition var47 = (ClassDefinition)var45.nextElement();
  1228.                         ClassDefinition var25 = var47.getOuterClass();
  1229.                         String var26 = var47.getLocalName().toString();
  1230.                         this.tab.put(var47.getClassDeclaration());
  1231.                         this.tab.put(var25.getClassDeclaration());
  1232.                         this.tab.put(var26);
  1233.                      }
  1234.  
  1235.                      DataOutputStream var48 = new DataOutputStream(var2);
  1236.                      var48.writeInt(-889275714);
  1237.                      var48.writeShort(3);
  1238.                      var48.writeShort(45);
  1239.                      this.tab.write(var1, var48);
  1240.                      byte var49 = 32;
  1241.                      if (var1.optimize()) {
  1242.                         var49 = 0;
  1243.                      }
  1244.  
  1245.                      if (((ClassDefinition)this).isInterface()) {
  1246.                         var49 = 0;
  1247.                      }
  1248.  
  1249.                      var48.writeShort((((ClassDefinition)this).getModifiers() | var49) & 1585);
  1250.                      var48.writeShort(this.tab.index(((ClassDefinition)this).getClassDeclaration()));
  1251.                      var48.writeShort(((ClassDefinition)this).getSuperClass() != null ? this.tab.index(((ClassDefinition)this).getSuperClass()) : 0);
  1252.                      var48.writeShort(super.interfaces.length);
  1253.  
  1254.                      for(int var50 = 0; var50 < super.interfaces.length; ++var50) {
  1255.                         var48.writeShort(this.tab.index(super.interfaces[var50]));
  1256.                      }
  1257.  
  1258.                      ByteArrayOutputStream var27 = new ByteArrayOutputStream(256);
  1259.                      ByteArrayOutputStream var28 = new ByteArrayOutputStream(256);
  1260.                      DataOutputStream var29 = new DataOutputStream(var27);
  1261.                      var48.writeShort(var3.size());
  1262.                      Enumeration var30 = var3.elements();
  1263.  
  1264.                      while(var30.hasMoreElements()) {
  1265.                         CompilerField var31 = (CompilerField)var30.nextElement();
  1266.                         Object var32 = var31.field.getInitialValue();
  1267.                         var48.writeShort(var31.field.getModifiers() & 223);
  1268.                         var48.writeShort(this.tab.index(var31.name));
  1269.                         var48.writeShort(this.tab.index(var31.sig));
  1270.                         int var33 = var32 != null ? 1 : 0;
  1271.                         boolean var34 = var31.field.isDeprecated();
  1272.                         boolean var35 = var31.field.isSynthetic();
  1273.                         var33 += (var34 ? 1 : 0) + (var35 ? 1 : 0);
  1274.                         var48.writeShort(var33);
  1275.                         if (var32 != null) {
  1276.                            var48.writeShort(this.tab.index("ConstantValue"));
  1277.                            var48.writeInt(2);
  1278.                            var48.writeShort(this.tab.index(var32 instanceof String ? new StringExpression(var31.field.getWhere(), (String)var32) : var32));
  1279.                         }
  1280.  
  1281.                         if (var34) {
  1282.                            var48.writeShort(this.tab.index("Deprecated"));
  1283.                            var48.writeInt(0);
  1284.                         }
  1285.  
  1286.                         if (var35) {
  1287.                            var48.writeShort(this.tab.index("Synthetic"));
  1288.                            var48.writeInt(0);
  1289.                         }
  1290.                      }
  1291.  
  1292.                      var48.writeShort(var4.size());
  1293.                      Enumeration var51 = var4.elements();
  1294.  
  1295.                      while(var51.hasMoreElements()) {
  1296.                         CompilerField var52 = (CompilerField)var51.nextElement();
  1297.                         var48.writeShort(var52.field.getModifiers() & 1343);
  1298.                         var48.writeShort(this.tab.index(var52.name));
  1299.                         var48.writeShort(this.tab.index(var52.sig));
  1300.                         ClassDeclaration[] var56 = var52.field.getExceptions(var1);
  1301.                         int var58 = var56.length > 0 ? 1 : 0;
  1302.                         boolean var61 = var52.field.isDeprecated();
  1303.                         boolean var36 = var52.field.isSynthetic();
  1304.                         var58 += (var61 ? 1 : 0) + (var36 ? 1 : 0);
  1305.                         if (!var52.asm.empty()) {
  1306.                            var48.writeShort(var58 + 1);
  1307.                            var52.asm.write(var1, var29, var52.field, this.tab);
  1308.                            int var37 = 0;
  1309.                            if (!var1.optimize()) {
  1310.                               ++var37;
  1311.                            }
  1312.  
  1313.                            if (var1.coverage()) {
  1314.                               ++var37;
  1315.                            }
  1316.  
  1317.                            if (var1.debug()) {
  1318.                               ++var37;
  1319.                            }
  1320.  
  1321.                            var29.writeShort(var37);
  1322.                            if (!var1.optimize()) {
  1323.                               var52.asm.writeLineNumberTable(var1, new DataOutputStream(var28), this.tab);
  1324.                               var29.writeShort(this.tab.index("LineNumberTable"));
  1325.                               var29.writeInt(var28.size());
  1326.                               var28.writeTo(var27);
  1327.                               var28.reset();
  1328.                            }
  1329.  
  1330.                            if (var1.coverage()) {
  1331.                               var52.asm.writeCoverageTable(var1, this, new DataOutputStream(var28), this.tab, var52.field.getWhere());
  1332.                               var29.writeShort(this.tab.index("CoverageTable"));
  1333.                               var29.writeInt(var28.size());
  1334.                               var28.writeTo(var27);
  1335.                               var28.reset();
  1336.                            }
  1337.  
  1338.                            if (var1.debug()) {
  1339.                               var52.asm.writeLocalVariableTable(var1, var52.field, new DataOutputStream(var28), this.tab);
  1340.                               var29.writeShort(this.tab.index("LocalVariableTable"));
  1341.                               var29.writeInt(var28.size());
  1342.                               var28.writeTo(var27);
  1343.                               var28.reset();
  1344.                            }
  1345.  
  1346.                            var48.writeShort(this.tab.index("Code"));
  1347.                            var48.writeInt(var27.size());
  1348.                            var27.writeTo(var48);
  1349.                            var27.reset();
  1350.                         } else {
  1351.                            var48.writeShort(var58);
  1352.                         }
  1353.  
  1354.                         if (var56.length > 0) {
  1355.                            var48.writeShort(this.tab.index("Exceptions"));
  1356.                            var48.writeInt(2 + var56.length * 2);
  1357.                            var48.writeShort(var56.length);
  1358.  
  1359.                            for(int var64 = 0; var64 < var56.length; ++var64) {
  1360.                               var48.writeShort(this.tab.index(var56[var64]));
  1361.                            }
  1362.                         }
  1363.  
  1364.                         if (var61) {
  1365.                            var48.writeShort(this.tab.index("Deprecated"));
  1366.                            var48.writeInt(0);
  1367.                         }
  1368.  
  1369.                         if (var36) {
  1370.                            var48.writeShort(this.tab.index("Synthetic"));
  1371.                            var48.writeInt(0);
  1372.                         }
  1373.                      }
  1374.  
  1375.                      var48.writeShort(var41);
  1376.                      var48.writeShort(this.tab.index("SourceFile"));
  1377.                      var48.writeInt(2);
  1378.                      var48.writeShort(this.tab.index(var16));
  1379.                      if (((ClassDefinition)this).isDeprecated()) {
  1380.                         var48.writeShort(this.tab.index("Deprecated"));
  1381.                         var48.writeInt(0);
  1382.                      }
  1383.  
  1384.                      if (((ClassDefinition)this).isSynthetic()) {
  1385.                         var48.writeShort(this.tab.index("Synthetic"));
  1386.                         var48.writeInt(0);
  1387.                      }
  1388.  
  1389.                      if (var1.coverage()) {
  1390.                         var48.writeShort(this.tab.index("AbsoluteSourcePath"));
  1391.                         var48.writeInt(2);
  1392.                         var48.writeShort(this.tab.index(var17));
  1393.                         var48.writeShort(this.tab.index("TimeStamp"));
  1394.                         var48.writeInt(8);
  1395.                         var48.writeLong(var18);
  1396.                      }
  1397.  
  1398.                      if (var5.size() > 0) {
  1399.                         var48.writeShort(this.tab.index("InnerClasses"));
  1400.                         var48.writeInt(2 + 8 * var5.size());
  1401.                         var48.writeShort(var5.size());
  1402.                         Enumeration var53 = var5.elements();
  1403.  
  1404.                         while(var53.hasMoreElements()) {
  1405.                            ClassDefinition var57 = (ClassDefinition)var53.nextElement();
  1406.                            ClassDefinition var60 = var57.getOuterClass();
  1407.                            String var62 = var57.getLocalName().toString();
  1408.                            int var63 = var57.getInnerClassField().getModifiers();
  1409.                            var48.writeShort(this.tab.index(var57.getClassDeclaration()));
  1410.                            var48.writeShort(this.tab.index(var60.getClassDeclaration()));
  1411.                            var48.writeShort(this.tab.index(var62));
  1412.                            var48.writeShort(var63 & 198207);
  1413.                         }
  1414.                      }
  1415.  
  1416.                      var48.flush();
  1417.                      this.tab = null;
  1418.                      if (var1.covdata()) {
  1419.                         Assembler var54 = new Assembler();
  1420.                         var54.GenVecJCov(var1, this, var18);
  1421.                      }
  1422.  
  1423.                      return;
  1424.                   }
  1425.                }
  1426.  
  1427.                var5.removeElementAt(var11);
  1428.             }
  1429.          }
  1430.  
  1431.          var5.addElement(var5.elementAt(var10));
  1432.       }
  1433.    }
  1434.  
  1435.    public void printClassDependencies(Environment var1) {
  1436.       if (this.toplevelEnv.print_dependencies()) {
  1437.          String var2 = ((ClassFile)((ClassDefinition)this).getSource()).getAbsoluteName();
  1438.          String var3 = ((ClassDefinition)this).getName().toString();
  1439.          int var4 = ((ClassDefinition)this).getWhere() >> 18;
  1440.          int var5 = this.getEndPosition() >> 18;
  1441.          System.out.println("CLASS:" + var2 + "," + var4 + "," + var5 + "," + var3);
  1442.          Enumeration var6 = this.deps.elements();
  1443.  
  1444.          while(var6.hasMoreElements()) {
  1445.             ClassDeclaration var7 = (ClassDeclaration)var6.nextElement();
  1446.             var1.output("CLDEP:" + var3 + "," + var7.getName());
  1447.          }
  1448.       }
  1449.  
  1450.    }
  1451. }
  1452.