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 / MethodExpression.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-07-08  |  15.4 KB  |  595 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.Type;
  16.  
  17. public class MethodExpression extends NaryExpression {
  18.    // $FF: renamed from: id sun.tools.java.Identifier
  19.    Identifier field_0;
  20.    ClassDefinition clazz;
  21.    FieldDefinition field;
  22.    Expression implementation;
  23.    static final int MAXINLINECOST = 30;
  24.  
  25.    public MethodExpression(int var1, Expression var2, Identifier var3, Expression[] var4) {
  26.       super(47, var1, Type.tError, var2, var4);
  27.       this.field_0 = var3;
  28.    }
  29.  
  30.    public MethodExpression(int var1, Expression var2, FieldDefinition var3, Expression[] var4) {
  31.       super(47, var1, var3.getType().getReturnType(), var2, var4);
  32.       this.field_0 = var3.getName();
  33.       this.field = var3;
  34.       this.clazz = var3.getClassDefinition();
  35.    }
  36.  
  37.    public Expression getImplementation() {
  38.       return (Expression)(this.implementation != null ? this.implementation : this);
  39.    }
  40.  
  41.    public Vset checkValue(Environment var1, Context var2, Vset var3, Hashtable var4) {
  42.       Object var5 = null;
  43.       boolean var6 = false;
  44.       boolean var7 = false;
  45.       Expression[] var8 = super.args;
  46.       if (this.field_0.equals(Constants.idInit)) {
  47.          ClassDefinition var9 = var2.field.getClassDefinition();
  48.  
  49.          try {
  50.             Expression var10 = null;
  51.             if (super.right instanceof SuperExpression) {
  52.                var9 = var9.getSuperClass().getClassDefinition(var1);
  53.                var10 = ((SuperExpression)super.right).outerArg;
  54.             }
  55.  
  56.             var8 = NewInstanceExpression.insertOuterLink(var1, var2, super.where, var9, var10, var8);
  57.          } catch (ClassNotFound var15) {
  58.          }
  59.       }
  60.  
  61.       Type[] var20 = new Type[var8.length];
  62.  
  63.       try {
  64.          ClassDeclaration var19;
  65.          if (super.right != null) {
  66.             if (this.field_0.equals(Constants.idInit)) {
  67.                int var23 = var2.getThisNumber();
  68.                if (!var2.field.isConstructor()) {
  69.                   var1.error(super.where, "invalid.constr.invoke");
  70.                   return var3.addVar(var23);
  71.                }
  72.  
  73.                if (var3.testVar(var23)) {
  74.                   var1.error(super.where, "constr.invoke.not.first");
  75.                   return var3;
  76.                }
  77.  
  78.                var3 = var3.addVar(var23);
  79.                if (super.right instanceof SuperExpression) {
  80.                   var3 = super.right.checkAmbigName(var1, var2, var3, var4, this);
  81.                } else {
  82.                   var3 = super.right.checkValue(var1, var2, var3, var4);
  83.                }
  84.             } else {
  85.                var3 = super.right.checkAmbigName(var1, var2, var3, var4, this);
  86.                if (super.right.type == Type.tPackage) {
  87.                   FieldExpression.reportFailedPackagePrefix(var1, super.right);
  88.                   return var3;
  89.                }
  90.  
  91.                if (super.right instanceof TypeExpression) {
  92.                   var7 = true;
  93.                }
  94.             }
  95.  
  96.             if (super.right.type.isType(10)) {
  97.                var19 = var1.getClassDeclaration(super.right.type);
  98.             } else {
  99.                if (!super.right.type.isType(9)) {
  100.                   if (!super.right.type.isType(13)) {
  101.                      var1.error(super.where, "invalid.method.invoke", super.right.type);
  102.                   }
  103.  
  104.                   return var3;
  105.                }
  106.  
  107.                var6 = true;
  108.                var19 = var1.getClassDeclaration(Type.tObject);
  109.             }
  110.          } else {
  111.             var7 = var2.field.isStatic();
  112.             ClassDefinition var22 = var2.field.getClassDefinition();
  113.  
  114.             FieldDefinition var11;
  115.             for(var11 = null; var22 != null; var22 = var22.getOuterClass()) {
  116.                var11 = var22.findAnyMethod(var1, this.field_0);
  117.                if (var11 != null) {
  118.                   break;
  119.                }
  120.             }
  121.  
  122.             if (var11 == null) {
  123.                var19 = var2.field.getClassDeclaration();
  124.             } else {
  125.                var19 = var22.getClassDeclaration();
  126.                if (var11.getClassDefinition() != var22) {
  127.                   ClassDefinition var12 = var22;
  128.  
  129.                   while((var12 = var12.getOuterClass()) != null) {
  130.                      FieldDefinition var13 = var12.findAnyMethod(var1, this.field_0);
  131.                      if (var13 != null && var13.getClassDefinition() == var12) {
  132.                         var1.error(super.where, "inherited.hides.method", this.field_0, var22.getClassDeclaration(), var12.getClassDeclaration());
  133.                         break;
  134.                      }
  135.                   }
  136.                }
  137.             }
  138.          }
  139.  
  140.          boolean var24 = false;
  141.          if (this.field_0.equals(Constants.idInit)) {
  142.             var3 = var3.clearVar(var2.getThisNumber());
  143.          }
  144.  
  145.          for(int var26 = 0; var26 < var8.length; ++var26) {
  146.             var3 = var8[var26].checkValue(var1, var2, var3, var4);
  147.             var20[var26] = var8[var26].type;
  148.             var24 = var24 || var20[var26].isType(13);
  149.          }
  150.  
  151.          if (this.field_0.equals(Constants.idInit)) {
  152.             var3 = var3.addVar(var2.getThisNumber());
  153.          }
  154.  
  155.          if (var24) {
  156.             return var3;
  157.          }
  158.  
  159.          this.clazz = var19.getClassDefinition(var1);
  160.          ClassDefinition var30 = var2.field.getClassDefinition();
  161.          this.field = this.clazz.matchMethod(var1, var30, this.field_0, var20);
  162.          if (this.field == null) {
  163.             if (this.field_0.equals(Constants.idInit)) {
  164.                if (this.diagnoseMismatch(var1, var8, var20)) {
  165.                   return var3;
  166.                }
  167.  
  168.                String var37 = this.clazz.getName().getName().toString();
  169.                var37 = Type.tMethod(Type.tError, var20).typeString(var37, false, false);
  170.                var1.error(super.where, "unmatched.constr", var37, var19);
  171.                return var3;
  172.             }
  173.  
  174.             String var35 = this.field_0.toString();
  175.             var35 = Type.tMethod(Type.tError, var20).typeString(var35, false, false);
  176.             if (this.clazz.findAnyMethod(var1, this.field_0) == null) {
  177.                if (var2.getField(var1, this.field_0) != null) {
  178.                   var1.error(super.where, "invalid.method", this.field_0, var19);
  179.                } else {
  180.                   var1.error(super.where, "undef.meth", var35, var19);
  181.                }
  182.             } else if (!this.diagnoseMismatch(var1, var8, var20)) {
  183.                var1.error(super.where, "unmatched.meth", var35, var19);
  184.             }
  185.  
  186.             return var3;
  187.          }
  188.  
  189.          super.type = this.field.getType().getReturnType();
  190.          if (var7 && !this.field.isStatic()) {
  191.             var1.error(super.where, "no.static.meth.access", this.field, this.field.getClassDeclaration());
  192.             return var3;
  193.          }
  194.  
  195.          if (this.field.isProtected() && super.right != null && !(super.right instanceof SuperExpression) && !var30.protectedAccess(var1, this.field, super.right.type)) {
  196.             var1.error(super.where, "invalid.protected.method.use", this.field.getName(), this.field.getClassDeclaration(), super.right.type);
  197.             return var3;
  198.          }
  199.  
  200.          if (this.field.isPrivate()) {
  201.             ClassDefinition var34 = this.field.getClassDefinition();
  202.             if (var34 != var30) {
  203.                FieldDefinition var14 = var34.getAccessField(var1, var2, this.field);
  204.                if (var14 != null) {
  205.                   this.field = var14;
  206.                } else {
  207.                   var1.error(super.where, "uplevel.private", this.field, var34);
  208.                }
  209.             }
  210.          }
  211.  
  212.          if (this.field.isAbstract() && super.right != null && super.right.op == 83) {
  213.             var1.error(super.where, "invoke.abstract", this.field, this.field.getClassDeclaration());
  214.             return var3;
  215.          }
  216.  
  217.          if (this.field.reportDeprecated(var1)) {
  218.             var1.error(super.where, "warn.meth.is.deprecated", this.field, this.field.getClassDefinition());
  219.          }
  220.  
  221.          if (this.field.isConstructor() && var2.field.equals(this.field)) {
  222.             var1.error(super.where, "recursive.constr", this.field);
  223.          }
  224.  
  225.          var2.field.getClassDefinition().addDependency(this.field.getClassDeclaration());
  226.       } catch (ClassNotFound var16) {
  227.          var1.error(super.where, "class.not.found", var16.name, var2.field);
  228.          return var3;
  229.       } catch (AmbiguousField var17) {
  230.          var1.error(super.where, "ambig.field", this.field_0, var17.field1, var17.field2);
  231.          return var3;
  232.       }
  233.  
  234.       if (super.right == null && !this.field.isStatic()) {
  235.          super.right = var2.findOuterLink(var1, super.where, this.field);
  236.          var3 = super.right.checkValue(var1, var2, var3, var4);
  237.       }
  238.  
  239.       var20 = this.field.getType().getArgumentTypes();
  240.  
  241.       for(int var25 = 0; var25 < var8.length; ++var25) {
  242.          var8[var25] = ((Node)this).convert(var1, var2, var20[var25], var8[var25]);
  243.       }
  244.  
  245.       if (var8.length > super.args.length) {
  246.          Object var27;
  247.          if (super.right instanceof SuperExpression) {
  248.             var27 = new SuperExpression(super.right.where, var2);
  249.             ((SuperExpression)super.right).outerArg = var8[0];
  250.          } else {
  251.             if (!(super.right instanceof ThisExpression)) {
  252.                throw new CompilerError("this.init");
  253.             }
  254.  
  255.             var27 = new ThisExpression(super.right.where, var2);
  256.          }
  257.  
  258.          for(int var31 = 1; var31 < var8.length; ++var31) {
  259.             super.args[var31 - 1] = var8[var31];
  260.          }
  261.  
  262.          this.implementation = new MethodExpression(super.where, (Expression)var27, this.field, var8);
  263.          this.implementation.type = super.type;
  264.       }
  265.  
  266.       if (var2.field.isConstructor() && this.field.isConstructor() && super.right != null && super.right.op == 83) {
  267.          Expression var28 = this.makeVarInits(var1, var2);
  268.          if (var28 != null) {
  269.             if (this.implementation == null) {
  270.                this.implementation = (Expression)((Node)this).clone();
  271.             }
  272.  
  273.             this.implementation = new CommaExpression(super.where, this.implementation, var28);
  274.          }
  275.       }
  276.  
  277.       ClassDeclaration[] var29 = this.field.getExceptions(var1);
  278.       if (var6 && this.field.getName() == Constants.idClone && this.field.getType().getArgumentTypes().length == 0) {
  279.          var29 = new ClassDeclaration[0];
  280.  
  281.          for(Context var32 = var2; var32 != null; var32 = var32.prev) {
  282.             if (var32.node != null && var32.node.op == 101) {
  283.                ((TryStatement)var32.node).arrayCloneWhere = super.where;
  284.             }
  285.          }
  286.       }
  287.  
  288.       for(int var33 = 0; var33 < var29.length; ++var33) {
  289.          if (var4.get(var29[var33]) == null) {
  290.             var4.put(var29[var33], this);
  291.          }
  292.       }
  293.  
  294.       return var3;
  295.    }
  296.  
  297.    public Vset check(Environment var1, Context var2, Vset var3, Hashtable var4) {
  298.       return this.checkValue(var1, var2, var3, var4);
  299.    }
  300.  
  301.    boolean diagnoseMismatch(Environment var1, Expression[] var2, Type[] var3) throws ClassNotFound {
  302.       Type[] var4 = new Type[1];
  303.       boolean var5 = false;
  304.  
  305.       int var9;
  306.       for(int var6 = 0; var6 < var3.length; var6 = var9 + 1) {
  307.          int var7 = this.clazz.diagnoseMismatch(var1, this.field_0, var3, var6, var4);
  308.          String var8 = this.field_0.equals(Constants.idInit) ? "constructor" : Constants.opNames[super.op];
  309.          if (var7 == -2) {
  310.             var1.error(super.where, "wrong.number.args", var8);
  311.             var5 = true;
  312.          }
  313.  
  314.          if (var7 < 0) {
  315.             break;
  316.          }
  317.  
  318.          var9 = var7 >> 2;
  319.          boolean var10 = (var7 & 2) != 0;
  320.          Type var11 = var4[0];
  321.          String var12 = String.valueOf(var11);
  322.          if (var10) {
  323.             var1.error(var2[var9].where, "explicit.cast.needed", var8, var3[var9], var12);
  324.          } else {
  325.             var1.error(var2[var9].where, "incompatible.type", var8, var3[var9], var12);
  326.          }
  327.  
  328.          var5 = true;
  329.       }
  330.  
  331.       return var5;
  332.    }
  333.  
  334.    private Expression inlineMethod(Environment var1, Context var2, Statement var3, boolean var4) {
  335.       if (var1.dump()) {
  336.          System.out.println("INLINE METHOD " + this.field + " in " + var2.field);
  337.       }
  338.  
  339.       LocalField[] var5 = LocalField.copyArguments(var2, this.field);
  340.       Statement[] var6 = new Statement[var5.length + 2];
  341.       int var7 = 0;
  342.       if (this.field.isStatic()) {
  343.          var6[0] = new ExpressionStatement(super.where, super.right);
  344.       } else {
  345.          if (super.right != null && super.right.op == 83) {
  346.             super.right = new ThisExpression(super.right.where, var2);
  347.          }
  348.  
  349.          var6[0] = new VarDeclarationStatement(super.where, var5[var7++], super.right);
  350.       }
  351.  
  352.       for(int var8 = 0; var8 < super.args.length; ++var8) {
  353.          var6[var8 + 1] = new VarDeclarationStatement(super.where, var5[var7++], super.args[var8]);
  354.       }
  355.  
  356.       var6[var6.length - 1] = var3 != null ? var3.copyInline(var2, var4) : null;
  357.       LocalField.doneWithArguments(var2, var5);
  358.       Type var9 = var4 ? super.type : Type.tVoid;
  359.       InlineMethodExpression var10 = new InlineMethodExpression(super.where, var9, this.field, new CompoundStatement(super.where, var6));
  360.       return var4 ? ((Expression)var10).inlineValue(var1, var2) : ((Expression)var10).inline(var1, var2);
  361.    }
  362.  
  363.    public Expression inline(Environment var1, Context var2) {
  364.       if (this.implementation != null) {
  365.          return this.implementation.inline(var1, var2);
  366.       } else {
  367.          try {
  368.             if (super.right != null) {
  369.                super.right = this.field.isStatic() ? super.right.inline(var1, var2) : super.right.inlineValue(var1, var2);
  370.             }
  371.  
  372.             for(int var3 = 0; var3 < super.args.length; ++var3) {
  373.                super.args[var3] = super.args[var3].inlineValue(var1, var2);
  374.             }
  375.  
  376.             Object var4 = this;
  377.             if (var1.optimize() && this.field.isInlineable(var1, this.clazz.isFinal()) && (this.field_0 == null || !this.field_0.equals(Constants.idInit)) && !var2.field.isInitializer() && var2.field.isMethod() && var2.getInlineFieldContext(this.field) == null) {
  378.                Statement var5 = (Statement)this.field.getValue(var1);
  379.                if (var5 == null || var5.costInline(30, var1, var2) < 30) {
  380.                   var4 = this.inlineMethod(var1, var2, var5, false);
  381.                }
  382.             }
  383.  
  384.             return (Expression)var4;
  385.          } catch (ClassNotFound var6) {
  386.             throw new CompilerError(var6);
  387.          }
  388.       }
  389.    }
  390.  
  391.    public Expression inlineValue(Environment var1, Context var2) {
  392.       if (this.implementation != null) {
  393.          return this.implementation.inlineValue(var1, var2);
  394.       } else {
  395.          try {
  396.             if (super.right != null) {
  397.                super.right = this.field.isStatic() ? super.right.inline(var1, var2) : super.right.inlineValue(var1, var2);
  398.             }
  399.  
  400.             if (this.field.getName().equals(Constants.idInit)) {
  401.                ClassDefinition var3 = this.field.getClassDefinition();
  402.                UplevelReference var4 = var3.getReferencesFrozen();
  403.                if (var4 != null) {
  404.                   var4.willCodeArguments(var1, var2);
  405.                }
  406.             }
  407.  
  408.             for(int var6 = 0; var6 < super.args.length; ++var6) {
  409.                super.args[var6] = super.args[var6].inlineValue(var1, var2);
  410.             }
  411.  
  412.             if (var1.optimize() && this.field.isInlineable(var1, this.clazz.isFinal()) && !var2.field.isInitializer() && var2.field.isMethod() && var2.getInlineFieldContext(this.field) == null) {
  413.                Statement var7 = (Statement)this.field.getValue(var1);
  414.                if (var7 == null || var7.costInline(30, var1, var2) < 30) {
  415.                   return this.inlineMethod(var1, var2, var7, true);
  416.                }
  417.             }
  418.  
  419.             return this;
  420.          } catch (ClassNotFound var5) {
  421.             throw new CompilerError(var5);
  422.          }
  423.       }
  424.    }
  425.  
  426.    public Expression copyInline(Context var1) {
  427.       return this.implementation != null ? this.implementation.copyInline(var1) : super.copyInline(var1);
  428.    }
  429.  
  430.    public int costInline(int var1, Environment var2, Context var3) {
  431.       if (this.implementation != null) {
  432.          return this.implementation.costInline(var1, var2, var3);
  433.       } else if (super.right != null && super.right.op == 83) {
  434.          return var1;
  435.       } else if (var3 == null) {
  436.          return super.costInline(var1, var2, var3);
  437.       } else {
  438.          ClassDefinition var4 = var3.field.getClassDefinition();
  439.  
  440.          try {
  441.             if (var4.canAccess(var2, this.field.getClassDeclaration()) && var4.canAccess(var2, this.field)) {
  442.                if (super.right == null) {
  443.                   return super.costInline(var1, var2, var3);
  444.                }
  445.  
  446.                ClassDeclaration var5 = var2.getClassDeclaration(super.right.type);
  447.                if (var4.canAccess(var2, var5)) {
  448.                   return super.costInline(var1, var2, var3);
  449.                }
  450.             }
  451.          } catch (ClassNotFound var6) {
  452.          }
  453.  
  454.          return var1;
  455.       }
  456.    }
  457.  
  458.    private Expression makeVarInits(Environment var1, Context var2) {
  459.       ClassDefinition var3 = var2.field.getClassDefinition();
  460.       Object var4 = null;
  461.  
  462.       for(FieldDefinition var5 = var3.getFirstField(); var5 != null; var5 = var5.getNextField()) {
  463.          if ((var5.isVariable() || var5.isInitializer()) && !var5.isStatic()) {
  464.             try {
  465.                var5.check(var1);
  466.             } catch (ClassNotFound var10) {
  467.                var1.error(var5.getWhere(), "class.not.found", var10.name, var5.getClassDefinition());
  468.             }
  469.  
  470.             Object var6 = null;
  471.             if (var5.isUplevelValue()) {
  472.                if (var5 != var3.findOuterField()) {
  473.                   continue;
  474.                }
  475.  
  476.                IdentifierExpression var7 = new IdentifierExpression(super.where, var5.getName());
  477.                if (!var7.bind(var1, var2)) {
  478.                   throw new CompilerError("bind " + var7.id);
  479.                }
  480.  
  481.                var6 = var7;
  482.             } else if (var5.isInitializer()) {
  483.                Statement var13 = (Statement)var5.getValue();
  484.                var6 = new InlineMethodExpression(super.where, Type.tVoid, var5, var13);
  485.             } else {
  486.                var6 = (Expression)var5.getValue();
  487.             }
  488.  
  489.             if (var6 != null && !((Expression)var6).equals(0)) {
  490.                int var14 = var5.getWhere();
  491.                Expression var12 = ((Expression)var6).copyInline(var2);
  492.                Object var8 = var12;
  493.                if (var5.isVariable()) {
  494.                   ThisExpression var9 = new ThisExpression(var14, var2);
  495.                   FieldExpression var15 = new FieldExpression(var14, var9, var5);
  496.                   var8 = new AssignExpression(var14, var15, var12);
  497.                }
  498.  
  499.                var4 = var4 == null ? var8 : new CommaExpression(var14, (Expression)var4, (Expression)var8);
  500.             }
  501.          }
  502.       }
  503.  
  504.       return (Expression)var4;
  505.    }
  506.  
  507.    public void codeValue(Environment var1, Context var2, Assembler var3) {
  508.       if (this.implementation != null) {
  509.          throw new CompilerError("codeValue");
  510.       } else {
  511.          boolean var4 = false;
  512.          int var5 = 0;
  513.          if (this.field.isStatic()) {
  514.             if (super.right != null) {
  515.                super.right.code(var1, var2, var3);
  516.             }
  517.          } else if (super.right == null) {
  518.             var3.add(super.where, 25, new Integer(0));
  519.          } else if (super.right.op == 83) {
  520.             var4 = true;
  521.             super.right.codeValue(var1, var2, var3);
  522.             if (Constants.idInit.equals(this.field_0)) {
  523.                ClassDefinition var6 = this.field.getClassDefinition();
  524.                UplevelReference var7 = var6.getReferencesFrozen();
  525.                if (var7 != null) {
  526.                   if (var7.isClientOuterField()) {
  527.                      super.args[var5++].codeValue(var1, var2, var3);
  528.                   }
  529.  
  530.                   var7.codeArguments(var1, var2, var3, super.where, this.field);
  531.                }
  532.             }
  533.          } else {
  534.             super.right.codeValue(var1, var2, var3);
  535.          }
  536.  
  537.          while(var5 < super.args.length) {
  538.             super.args[var5].codeValue(var1, var2, var3);
  539.             ++var5;
  540.          }
  541.  
  542.          if (this.field.isStatic()) {
  543.             var3.add(super.where, 184, this.field);
  544.          } else if (!this.field.isConstructor() && !this.field.isPrivate() && !var4) {
  545.             if (this.field.getClassDefinition().isInterface()) {
  546.                var3.add(super.where, 185, this.field);
  547.             } else {
  548.                var3.add(super.where, 182, this.field);
  549.             }
  550.          } else {
  551.             var3.add(super.where, 183, this.field);
  552.          }
  553.  
  554.          if (var4 && Constants.idInit.equals(this.field_0)) {
  555.             ClassDefinition var8 = var2.field.getClassDefinition();
  556.             UplevelReference var9 = var8.getReferencesFrozen();
  557.             if (var9 != null) {
  558.                var9.codeInitialization(var1, var2, var3, super.where, this.field);
  559.             }
  560.          }
  561.  
  562.       }
  563.    }
  564.  
  565.    public Expression firstConstructor() {
  566.       return this.field_0.equals(Constants.idInit) ? this : null;
  567.    }
  568.  
  569.    public void print(PrintStream var1) {
  570.       var1.print("(" + Constants.opNames[super.op]);
  571.       if (super.right != null) {
  572.          var1.print(" ");
  573.          super.right.print(var1);
  574.       }
  575.  
  576.       var1.print(" " + (this.field_0 == null ? Constants.idInit : this.field_0));
  577.  
  578.       for(int var2 = 0; var2 < super.args.length; ++var2) {
  579.          var1.print(" ");
  580.          if (super.args[var2] != null) {
  581.             super.args[var2].print(var1);
  582.          } else {
  583.             var1.print("<null>");
  584.          }
  585.       }
  586.  
  587.       var1.print(")");
  588.       if (this.implementation != null) {
  589.          var1.print("/IMPL=");
  590.          this.implementation.print(var1);
  591.       }
  592.  
  593.    }
  594. }
  595.