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 / tree / FieldExpression.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-07-08  |  16.2 KB  |  633 lines
  1. package sun.tools.tree;
  2.  
  3. import java.io.PrintStream;
  4. import java.util.Hashtable;
  5. import sun.tools.asm.Assembler;
  6. import sun.tools.java.AmbiguousField;
  7. import sun.tools.java.ClassDeclaration;
  8. import sun.tools.java.ClassDefinition;
  9. import sun.tools.java.ClassNotFound;
  10. import sun.tools.java.CompilerError;
  11. import sun.tools.java.Constants;
  12. import sun.tools.java.Environment;
  13. import sun.tools.java.FieldDefinition;
  14. import sun.tools.java.Identifier;
  15. import sun.tools.java.IdentifierToken;
  16. import sun.tools.java.Type;
  17.  
  18. public class FieldExpression extends UnaryExpression {
  19.    // $FF: renamed from: id sun.tools.java.Identifier
  20.    Identifier field_0;
  21.    FieldDefinition field;
  22.    Expression implementation;
  23.  
  24.    public FieldExpression(int var1, Expression var2, Identifier var3) {
  25.       super(46, var1, Type.tError, var2);
  26.       this.field_0 = var3;
  27.    }
  28.  
  29.    public FieldExpression(int var1, Expression var2, FieldDefinition var3) {
  30.       super(46, var1, var3.getType(), var2);
  31.       this.field_0 = var3.getName();
  32.       this.field = var3;
  33.    }
  34.  
  35.    public Expression getImplementation() {
  36.       return (Expression)(this.implementation != null ? this.implementation : this);
  37.    }
  38.  
  39.    public static Identifier toIdentifier(Expression var0) {
  40.       StringBuffer var1;
  41.       FieldExpression var2;
  42.       for(var1 = new StringBuffer(); var0.op == 46; var0 = var2.right) {
  43.          var2 = (FieldExpression)var0;
  44.          if (var2.field_0 == Constants.idThis || var2.field_0 == Constants.idClass) {
  45.             return null;
  46.          }
  47.  
  48.          var1.insert(0, var2.field_0);
  49.          var1.insert(0, '.');
  50.       }
  51.  
  52.       if (var0.op != 60) {
  53.          return null;
  54.       } else {
  55.          var1.insert(0, ((IdentifierExpression)var0).id);
  56.          return Identifier.lookup(var1.toString());
  57.       }
  58.    }
  59.  
  60.    Type toType(Environment var1, Context var2) {
  61.       Identifier var3 = toIdentifier(this);
  62.       if (var3 == null) {
  63.          var1.error(super.where, "invalid.type.expr");
  64.          return Type.tError;
  65.       } else {
  66.          Type var4 = Type.tClass(var2.resolveName(var1, var3));
  67.          return var1.resolve(super.where, var2.field.getClassDefinition(), var4) ? var4 : Type.tError;
  68.       }
  69.    }
  70.  
  71.    public Vset checkAmbigName(Environment var1, Context var2, Vset var3, Hashtable var4, UnaryExpression var5) {
  72.       if (this.field_0 == Constants.idThis || this.field_0 == Constants.idClass) {
  73.          var5 = null;
  74.       }
  75.  
  76.       return this.checkCommon(var1, var2, var3, var4, var5);
  77.    }
  78.  
  79.    public Vset checkValue(Environment var1, Context var2, Vset var3, Hashtable var4) {
  80.       return this.checkCommon(var1, var2, var3, var4, (UnaryExpression)null);
  81.    }
  82.  
  83.    static void reportFailedPackagePrefix(Environment var0, Expression var1) {
  84.       Expression var2;
  85.       for(var2 = var1; var2 instanceof UnaryExpression; var2 = ((UnaryExpression)var2).right) {
  86.       }
  87.  
  88.       IdentifierExpression var3 = (IdentifierExpression)var2;
  89.       if (var2 == var1) {
  90.          var0.error(var3.where, "undef.var.or.class", var3.id);
  91.       } else if (var0.innerClasses()) {
  92.          var0.error(var3.where, "undef.var.class.or.package", var3.id);
  93.       } else {
  94.          var0.error(var3.where, "undef.var.or.package", var3.id);
  95.       }
  96.    }
  97.  
  98.    private Vset checkCommon(Environment var1, Context var2, Vset var3, Hashtable var4, UnaryExpression var5) {
  99.       if (this.field != null) {
  100.          return super.right == null ? var3 : super.right.checkAmbigName(var1, var2, var3, var4, this);
  101.       } else {
  102.          var3 = super.right.checkAmbigName(var1, var2, var3, var4, this);
  103.          if (super.right.type == Type.tPackage) {
  104.             if (var5 == null) {
  105.                reportFailedPackagePrefix(var1, super.right);
  106.                return var3;
  107.             } else {
  108.                Identifier var19 = toIdentifier(this);
  109.                if (var19 != null && var1.classExists(var19)) {
  110.                   var5.right = new TypeExpression(super.where, Type.tClass(var19));
  111.                   var1.resolve(super.where, var2.field.getClassDefinition(), var5.right.type);
  112.                   return var3;
  113.                } else {
  114.                   super.type = Type.tPackage;
  115.                   return var3;
  116.                }
  117.             }
  118.          } else {
  119.             try {
  120.                boolean var6 = super.right instanceof TypeExpression;
  121.                if (this.field_0 == Constants.idClass) {
  122.                   if (!var6) {
  123.                      var1.error(super.right.where, "invalid.type.expr");
  124.                   }
  125.  
  126.                   Type var20 = super.right.type;
  127.                   if (!var20.isType(10) && !var20.isType(9)) {
  128.                      if (var20.isType(13)) {
  129.                         super.type = Type.tClassDesc;
  130.                         return var3;
  131.                      }
  132.  
  133.                      Object var22 = null;
  134.                      String var23;
  135.                      switch (var20.getTypeCode()) {
  136.                         case 0:
  137.                            var23 = "Boolean";
  138.                            break;
  139.                         case 1:
  140.                            var23 = "Byte";
  141.                            break;
  142.                         case 2:
  143.                            var23 = "Character";
  144.                            break;
  145.                         case 3:
  146.                            var23 = "Short";
  147.                            break;
  148.                         case 4:
  149.                            var23 = "Integer";
  150.                            break;
  151.                         case 5:
  152.                            var23 = "Long";
  153.                            break;
  154.                         case 6:
  155.                            var23 = "Float";
  156.                            break;
  157.                         case 7:
  158.                            var23 = "Double";
  159.                            break;
  160.                         case 8:
  161.                         case 9:
  162.                         case 10:
  163.                         default:
  164.                            var1.error(super.right.where, "invalid.type.expr");
  165.                            return var3;
  166.                         case 11:
  167.                            var23 = "Void";
  168.                      }
  169.  
  170.                      Identifier var26 = Identifier.lookup(Constants.idJavaLang + "." + var23);
  171.                      TypeExpression var29 = new TypeExpression(super.where, Type.tClass(var26));
  172.                      this.implementation = new FieldExpression(super.where, var29, Constants.idTYPE);
  173.                      var3 = this.implementation.checkValue(var1, var2, var3, var4);
  174.                      super.type = this.implementation.type;
  175.                      return var3;
  176.                   }
  177.  
  178.                   FieldDefinition var21 = getClassLiteralLookup(var1, var2);
  179.                   if (var21 == null) {
  180.                      super.type = Type.tClassDesc;
  181.                      var1.error(super.where, "invalid.field.reference", this.field_0, var20);
  182.                      return var3;
  183.                   }
  184.  
  185.                   String var25 = var20.getTypeSignature();
  186.                   String var28;
  187.                   if (var20.isType(10)) {
  188.                      var28 = var25.substring(1, var25.length() - 1).replace('/', '.');
  189.                   } else {
  190.                      var28 = var25.replace('/', '.');
  191.                   }
  192.  
  193.                   FieldDefinition var11 = getClassLiteralCache(var1, var2, var28);
  194.                   this.implementation = this.makeClassLiteralCacheRef(var1, var2, var21, var11, var28);
  195.                   var3 = this.implementation.checkValue(var1, var2, var3, var4);
  196.                   super.type = this.implementation.type;
  197.                   return var3;
  198.                }
  199.  
  200.                if (!super.right.type.isType(10)) {
  201.                   if (super.right.type.isType(9) && this.field_0.equals(Constants.idLength)) {
  202.                      super.type = Type.tInt;
  203.                      this.implementation = new LengthExpression(super.where, super.right);
  204.                      return var3;
  205.                   }
  206.  
  207.                   if (!super.right.type.isType(13)) {
  208.                      var1.error(super.where, "invalid.field.reference", this.field_0, super.right.type);
  209.                   }
  210.  
  211.                   return var3;
  212.                }
  213.  
  214.                ClassDefinition var7 = var1.getClassDefinition(super.right.type);
  215.                if (this.field_0 == Constants.idThis) {
  216.                   if (!var6) {
  217.                      var1.error(super.right.where, "invalid.type.expr");
  218.                   }
  219.  
  220.                   this.implementation = var2.findOuterLink(var1, super.where, var7, (FieldDefinition)null);
  221.                   var3 = this.implementation.checkValue(var1, var2, var3, var4);
  222.                   super.type = var7.getType();
  223.                   return var3;
  224.                }
  225.  
  226.                this.field = var7.getVariable(var1, this.field_0);
  227.                if (this.field == null && var1.innerClasses() && var6 && var5 != null) {
  228.                   this.field = var7.getInnerClass(var1, this.field_0);
  229.                   if (this.field != null) {
  230.                      return this.checkInnerClass(var1, var2, var3, var4, var5);
  231.                   }
  232.                }
  233.  
  234.                if (this.field == null) {
  235.                   if ((this.field = var7.findAnyMethod(var1, this.field_0)) != null) {
  236.                      var1.error(super.where, "invalid.field", this.field_0, this.field.getClassDeclaration());
  237.                   } else {
  238.                      var1.error(super.where, "no.such.field", this.field_0, var7);
  239.                   }
  240.  
  241.                   return var3;
  242.                }
  243.  
  244.                ClassDefinition var8 = var2.field.getClassDefinition();
  245.                super.type = this.field.getType();
  246.                if (!var8.canAccess(var1, this.field)) {
  247.                   var1.error(super.where, "no.field.access", this.field_0, var7, var2.field.getClassDeclaration());
  248.                   return var3;
  249.                }
  250.  
  251.                if (var6 && !this.field.isStatic()) {
  252.                   ClassDefinition var9 = this.field.getClassDefinition();
  253.                   if (!var9.implementedBy(var1, var2.field.getClassDeclaration()) || var2.field.isStatic()) {
  254.                      var1.error(super.where, "no.static.field.access", this.field_0, var7);
  255.                      return var3;
  256.                   }
  257.  
  258.                   ThisExpression var10 = new ThisExpression(super.right.where);
  259.                   var3 = ((Expression)var10).checkValue(var1, var2, var3, var4);
  260.                   this.implementation = new FieldExpression(super.where, var10, this.field);
  261.                   this.implementation.type = super.type;
  262.                   var6 = false;
  263.                }
  264.  
  265.                if (this.field.isProtected() && !(super.right instanceof SuperExpression) && !var8.protectedAccess(var1, this.field, super.right.type)) {
  266.                   var1.error(super.where, "invalid.protected.field.use", this.field.getName(), this.field.getClassDeclaration(), super.right.type);
  267.                   return var3;
  268.                }
  269.  
  270.                if (this.field.isPrivate()) {
  271.                   ClassDefinition var24 = this.field.getClassDefinition();
  272.                   if (var24 != var8) {
  273.                      FieldDefinition var27 = var24.getAccessField(var1, var2, this.field);
  274.                      if (var27 != null) {
  275.                         this.implementation = new MethodExpression(super.where, super.right, var27, new Expression[0]);
  276.                         return var3;
  277.                      }
  278.  
  279.                      var1.error(super.where, "uplevel.private", this.field_0, var24);
  280.                   }
  281.                }
  282.  
  283.                if (!this.field.isStatic() && super.right.op == 82 && !var3.testVar(var2.getThisNumber())) {
  284.                   var1.error(super.where, "access.inst.before.super", this.field_0);
  285.                }
  286.  
  287.                if (this.field.reportDeprecated(var1)) {
  288.                   var1.error(super.where, "warn.field.is.deprecated", this.field_0, this.field.getClassDefinition());
  289.                }
  290.  
  291.                var2.field.getClassDefinition().addDependency(this.field.getClassDeclaration());
  292.             } catch (ClassNotFound var12) {
  293.                var1.error(super.where, "class.not.found", var12.name, var2.field);
  294.             } catch (AmbiguousField var13) {
  295.                var1.error(super.where, "ambig.field", this.field_0, var13.field1.getClassDeclaration(), var13.field2.getClassDeclaration());
  296.             }
  297.  
  298.             return var3;
  299.          }
  300.       }
  301.    }
  302.  
  303.    private Vset checkInnerClass(Environment var1, Context var2, Vset var3, Hashtable var4, UnaryExpression var5) {
  304.       ClassDefinition var6 = this.field.getInnerClass();
  305.       super.type = var6.getType();
  306.       if (!var6.isTopLevel()) {
  307.          var1.error(super.where, "inner.static.ref", var6.getName());
  308.       }
  309.  
  310.       TypeExpression var7 = new TypeExpression(super.where, super.type);
  311.       ClassDefinition var8 = var2.field.getClassDefinition();
  312.  
  313.       try {
  314.          if (!var8.canAccess(var1, this.field)) {
  315.             ClassDefinition var9 = var1.getClassDefinition(super.right.type);
  316.             var1.error(super.where, "no.type.access", this.field_0, var9, var2.field.getClassDeclaration());
  317.             return var3;
  318.          }
  319.  
  320.          if (this.field.isProtected() && !(super.right instanceof SuperExpression) && !var8.protectedAccess(var1, this.field, super.right.type)) {
  321.             var1.error(super.where, "invalid.protected.field.use", this.field.getName(), this.field.getClassDeclaration(), super.right.type);
  322.             return var3;
  323.          }
  324.  
  325.          var6.noteUsedBy(var8, super.where, var1);
  326.       } catch (ClassNotFound var10) {
  327.          var1.error(super.where, "class.not.found", var10.name, var2.field);
  328.       }
  329.  
  330.       var2.field.getClassDefinition().addDependency(this.field.getClassDeclaration());
  331.       if (var5 == null) {
  332.          return ((Expression)var7).checkValue(var1, var2, var3, var4);
  333.       } else {
  334.          var5.right = var7;
  335.          return var3;
  336.       }
  337.    }
  338.  
  339.    public Vset checkLHS(Environment var1, Context var2, Vset var3, Hashtable var4) {
  340.       boolean var5 = this.field != null;
  341.       this.checkValue(var1, var2, var3, var4);
  342.       if (this.implementation != null) {
  343.          return super.checkLHS(var1, var2, var3, var4);
  344.       } else {
  345.          if (this.field != null && this.field.isFinal() && !var5) {
  346.             if (super.right != null && super.right.op == 82 && !this.field.isStatic()) {
  347.                var3 = checkFinalAssign(var1, var2, var3, super.where, this.field);
  348.             } else {
  349.                var1.error(super.where, "assign.to.final", this.field_0);
  350.             }
  351.          }
  352.  
  353.          return var3;
  354.       }
  355.    }
  356.  
  357.    public Vset checkAssignOp(Environment var1, Context var2, Vset var3, Hashtable var4, Expression var5) {
  358.       this.checkValue(var1, var2, var3, var4);
  359.       if (this.implementation != null) {
  360.          return super.checkLHS(var1, var2, var3, var4);
  361.       } else {
  362.          if (this.field != null && this.field.isFinal()) {
  363.             var1.error(super.where, "assign.to.final", this.field_0);
  364.          }
  365.  
  366.          return var3;
  367.       }
  368.    }
  369.  
  370.    public static Vset checkFinalAssign(Environment var0, Context var1, Vset var2, int var3, FieldDefinition var4) {
  371.       if (var4.isBlankFinal() && var4.getClassDefinition() == var1.field.getClassDefinition()) {
  372.          int var7 = var1.getMemberNumber(var4);
  373.          if (var7 >= 0 && var2.testVarUnassigned(var7)) {
  374.             var2 = var2.addVar(var7);
  375.          } else {
  376.             Identifier var6 = var4.getName();
  377.             var0.error(var3, "assign.to.blank.final", var6);
  378.          }
  379.       } else {
  380.          Identifier var5 = var4.getName();
  381.          var0.error(var3, "assign.to.final", var5);
  382.       }
  383.  
  384.       return var2;
  385.    }
  386.  
  387.    private static FieldDefinition getClassLiteralLookup(Environment var0, Context var1) {
  388.       ClassDefinition var2;
  389.       for(var2 = var1.field.getClassDefinition(); var2.isInnerClass(); var2 = var2.getOuterClass()) {
  390.       }
  391.  
  392.       Identifier var3 = Identifier.lookup("class$");
  393.       Type[] var4 = new Type[]{Type.tString};
  394.  
  395.       FieldDefinition var5;
  396.       try {
  397.          var5 = var2.matchMethod(var0, var2, var3, var4);
  398.       } catch (ClassNotFound var22) {
  399.          return null;
  400.       } catch (AmbiguousField var23) {
  401.          return null;
  402.       }
  403.  
  404.       if (var5 != null) {
  405.          return var5;
  406.       } else {
  407.          int var6 = var2.getWhere();
  408.          IdentifierToken var7 = new IdentifierToken(var6, var3);
  409.          IdentifierExpression var8 = new IdentifierExpression(var7);
  410.          Expression[] var9 = new Expression[]{var8};
  411.          Identifier var10 = Identifier.lookup("forName");
  412.          MethodExpression var24 = new MethodExpression(var6, new TypeExpression(var6, Type.tClassDesc), var10, var9);
  413.          ReturnStatement var11 = new ReturnStatement(var6, var24);
  414.          Identifier var12 = Identifier.lookup("java.lang.ClassNotFoundException");
  415.          Identifier var13 = Identifier.lookup("java.lang.NoClassDefFoundError");
  416.          Type var14 = Type.tClass(var12);
  417.          Type var15 = Type.tClass(var13);
  418.          Identifier var16 = Identifier.lookup("getMessage");
  419.          IdentifierExpression var25 = new IdentifierExpression(var6, var10);
  420.          MethodExpression var26 = new MethodExpression(var6, var25, var16, new Expression[0]);
  421.          Expression[] var17 = new Expression[]{var26};
  422.          NewInstanceExpression var27 = new NewInstanceExpression(var6, new TypeExpression(var6, var15), var17);
  423.          CatchStatement var18 = new CatchStatement(var6, new TypeExpression(var6, var14), new IdentifierToken(var10), new ThrowStatement(var6, var27));
  424.          Statement[] var19 = new Statement[]{var18};
  425.          TryStatement var28 = new TryStatement(var6, var11, var19);
  426.          Type var20 = Type.tMethod(Type.tClassDesc, var4);
  427.          IdentifierToken[] var21 = new IdentifierToken[]{var7};
  428.          return var0.makeFieldDefinition(var0, var6, var2, (String)null, 524296, var20, var3, var21, (IdentifierToken[])null, var28);
  429.       }
  430.    }
  431.  
  432.    private static FieldDefinition getClassLiteralCache(Environment var0, Context var1, String var2) {
  433.       String var3;
  434.       if (!var2.startsWith("[")) {
  435.          var3 = "class$" + var2.replace('.', '$');
  436.       } else {
  437.          var3 = "array$" + var2.substring(1);
  438.          var3 = var3.replace('[', '$');
  439.          if (var2.endsWith(";")) {
  440.             var3 = var3.substring(0, var3.length() - 1);
  441.             var3 = var3.replace('.', '$');
  442.          }
  443.       }
  444.  
  445.       Identifier var4 = Identifier.lookup(var3);
  446.  
  447.       ClassDefinition var5;
  448.       for(var5 = var1.field.getClassDefinition(); var5.isInnerClass(); var5 = var5.getOuterClass()) {
  449.       }
  450.  
  451.       FieldDefinition var6;
  452.       try {
  453.          var6 = var5.getVariable(var0, var4);
  454.       } catch (ClassNotFound var7) {
  455.          return null;
  456.       } catch (AmbiguousField var8) {
  457.          return null;
  458.       }
  459.  
  460.       return var6 != null ? var6 : var0.makeFieldDefinition(var0, var5.getWhere(), var5, (String)null, 524296, Type.tClassDesc, var4, (IdentifierToken[])null, (IdentifierToken[])null, (Object)null);
  461.    }
  462.  
  463.    private Expression makeClassLiteralCacheRef(Environment var1, Context var2, FieldDefinition var3, FieldDefinition var4, String var5) {
  464.       TypeExpression var6 = new TypeExpression(super.where, var4.getClassDefinition().getType());
  465.       FieldExpression var7 = new FieldExpression(super.where, var6, var4);
  466.       NotEqualExpression var8 = new NotEqualExpression(super.where, ((Expression)var7).copyInline(var2), new NullExpression(super.where));
  467.       TypeExpression var9 = new TypeExpression(super.where, var3.getClassDefinition().getType());
  468.       StringExpression var10 = new StringExpression(super.where, var5);
  469.       Expression[] var11 = new Expression[]{var10};
  470.       MethodExpression var12 = new MethodExpression(super.where, var9, var3, var11);
  471.       AssignExpression var13 = new AssignExpression(super.where, ((Expression)var7).copyInline(var2), var12);
  472.       return new ConditionalExpression(super.where, var8, var7, var13);
  473.    }
  474.  
  475.    public boolean isConstant() {
  476.       if (this.implementation != null) {
  477.          return this.implementation.isConstant();
  478.       } else {
  479.          return this.field == null || super.right != null && !(super.right instanceof TypeExpression) && (super.right.op != 82 || super.right.where != super.where) ? false : this.field.isConstant();
  480.       }
  481.    }
  482.  
  483.    public Expression inline(Environment var1, Context var2) {
  484.       if (this.implementation != null) {
  485.          return this.implementation.inline(var1, var2);
  486.       } else {
  487.          return super.right != null ? super.right.inline(var1, var2) : null;
  488.       }
  489.    }
  490.  
  491.    public Expression inlineValue(Environment var1, Context var2) {
  492.       if (this.implementation != null) {
  493.          return this.implementation.inlineValue(var1, var2);
  494.       } else {
  495.          try {
  496.             if (this.field == null) {
  497.                return this;
  498.             } else {
  499.                if (this.field.isFinal()) {
  500.                   Expression var3 = (Expression)this.field.getValue(var1);
  501.                   if (var3 != null && var3.isConstant()) {
  502.                      var3 = var3.copyInline(var2);
  503.                      var3.where = super.where;
  504.                      return (new CommaExpression(super.where, super.right, var3)).inlineValue(var1, var2);
  505.                   }
  506.                }
  507.  
  508.                if (super.right != null) {
  509.                   if (this.field.isStatic()) {
  510.                      Expression var5 = super.right.inline(var1, var2);
  511.                      super.right = null;
  512.                      if (var5 != null) {
  513.                         return new CommaExpression(super.where, var5, this);
  514.                      }
  515.                   } else {
  516.                      super.right = super.right.inlineValue(var1, var2);
  517.                   }
  518.                }
  519.  
  520.                return this;
  521.             }
  522.          } catch (ClassNotFound var4) {
  523.             throw new CompilerError(var4);
  524.          }
  525.       }
  526.    }
  527.  
  528.    public Expression inlineLHS(Environment var1, Context var2) {
  529.       if (this.implementation != null) {
  530.          return this.implementation.inlineLHS(var1, var2);
  531.       } else {
  532.          if (super.right != null) {
  533.             if (this.field.isStatic()) {
  534.                Expression var3 = super.right.inline(var1, var2);
  535.                super.right = null;
  536.                if (var3 != null) {
  537.                   return new CommaExpression(super.where, var3, this);
  538.                }
  539.             } else {
  540.                super.right = super.right.inlineValue(var1, var2);
  541.             }
  542.          }
  543.  
  544.          return this;
  545.       }
  546.    }
  547.  
  548.    public Expression copyInline(Context var1) {
  549.       return this.implementation != null ? this.implementation.copyInline(var1) : super.copyInline(var1);
  550.    }
  551.  
  552.    public int costInline(int var1, Environment var2, Context var3) {
  553.       if (this.implementation != null) {
  554.          return this.implementation.costInline(var1, var2, var3);
  555.       } else if (var3 == null) {
  556.          return 3 + (super.right == null ? 0 : super.right.costInline(var1, var2, var3));
  557.       } else {
  558.          ClassDefinition var4 = var3.field.getClassDefinition();
  559.  
  560.          try {
  561.             if (var4.canAccess(var2, this.field.getClassDeclaration()) && var4.canAccess(var2, this.field)) {
  562.                if (super.right == null) {
  563.                   return 3;
  564.                }
  565.  
  566.                ClassDeclaration var5 = var2.getClassDeclaration(super.right.type);
  567.                if (var4.canAccess(var2, var5)) {
  568.                   return 3 + super.right.costInline(var1, var2, var3);
  569.                }
  570.             }
  571.          } catch (ClassNotFound var6) {
  572.          }
  573.  
  574.          return var1;
  575.       }
  576.    }
  577.  
  578.    int codeLValue(Environment var1, Context var2, Assembler var3) {
  579.       if (this.implementation != null) {
  580.          throw new CompilerError("codeLValue");
  581.       } else if (this.field.isStatic()) {
  582.          if (super.right != null) {
  583.             super.right.code(var1, var2, var3);
  584.             return 1;
  585.          } else {
  586.             return 0;
  587.          }
  588.       } else {
  589.          super.right.codeValue(var1, var2, var3);
  590.          return 1;
  591.       }
  592.    }
  593.  
  594.    void codeLoad(Environment var1, Context var2, Assembler var3) {
  595.       if (this.field == null) {
  596.          throw new CompilerError("should not be null");
  597.       } else if (this.field.isStatic()) {
  598.          var3.add(super.where, 178, this.field);
  599.       } else {
  600.          var3.add(super.where, 180, this.field);
  601.       }
  602.    }
  603.  
  604.    void codeStore(Environment var1, Context var2, Assembler var3) {
  605.       if (this.field.isStatic()) {
  606.          var3.add(super.where, 179, this.field);
  607.       } else {
  608.          var3.add(super.where, 181, this.field);
  609.       }
  610.    }
  611.  
  612.    public void codeValue(Environment var1, Context var2, Assembler var3) {
  613.       this.codeLValue(var1, var2, var3);
  614.       this.codeLoad(var1, var2, var3);
  615.    }
  616.  
  617.    public void print(PrintStream var1) {
  618.       var1.print("(");
  619.       if (super.right != null) {
  620.          super.right.print(var1);
  621.       } else {
  622.          var1.print("<empty>");
  623.       }
  624.  
  625.       var1.print("." + this.field_0 + ")");
  626.       if (this.implementation != null) {
  627.          var1.print("/IMPL=");
  628.          this.implementation.print(var1);
  629.       }
  630.  
  631.    }
  632. }
  633.