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 / java / Environment.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-07-08  |  10.2 KB  |  471 lines
  1. package sun.tools.java;
  2.  
  3. import java.io.File;
  4. import java.io.IOException;
  5.  
  6. public class Environment implements Constants {
  7.    Environment env;
  8.    String encoding;
  9.    Object source;
  10.    private static boolean debugging = System.getProperty("debug") != null;
  11.  
  12.    public Environment(Environment var1, Object var2) {
  13.       if (var1 != null && var1.env != null && var1.getClass() == this.getClass()) {
  14.          var1 = var1.env;
  15.       }
  16.  
  17.       this.env = var1;
  18.       this.source = var2;
  19.    }
  20.  
  21.    public Environment() {
  22.       this((Environment)null, (Object)null);
  23.    }
  24.  
  25.    public ClassDeclaration getClassDeclaration(Identifier var1) {
  26.       return this.env.getClassDeclaration(var1);
  27.    }
  28.  
  29.    public final ClassDefinition getClassDefinition(Identifier var1) throws ClassNotFound {
  30.       if (!var1.isInner()) {
  31.          return this.getClassDeclaration(var1).getClassDefinition(this);
  32.       } else {
  33.          ClassDefinition var2 = this.getClassDefinition(var1.getTopName());
  34.  
  35.          FieldDefinition var5;
  36.          label27:
  37.          for(Identifier var3 = var1.getFlatName(); var3.isQualified(); var2 = var5.getInnerClass()) {
  38.             var3 = var3.getTail();
  39.             Identifier var4 = var3.getHead();
  40.  
  41.             for(var5 = var2.getFirstMatch(var4); var5 != null; var5 = var5.getNextMatch()) {
  42.                if (var5.isInnerClass()) {
  43.                   continue label27;
  44.                }
  45.             }
  46.  
  47.             throw new ClassNotFound(Identifier.lookupInner(var2.getName(), var4));
  48.          }
  49.  
  50.          return var2;
  51.       }
  52.    }
  53.  
  54.    public ClassDeclaration getClassDeclaration(Type var1) {
  55.       return this.getClassDeclaration(var1.getClassName());
  56.    }
  57.  
  58.    public final ClassDefinition getClassDefinition(Type var1) throws ClassNotFound {
  59.       return this.getClassDefinition(var1.getClassName());
  60.    }
  61.  
  62.    public boolean classExists(Identifier var1) {
  63.       return this.env.classExists(var1);
  64.    }
  65.  
  66.    public final boolean classExists(Type var1) {
  67.       return !var1.isType(10) || this.classExists(var1.getClassName());
  68.    }
  69.  
  70.    public Package getPackage(Identifier var1) throws IOException {
  71.       return this.env.getPackage(var1);
  72.    }
  73.  
  74.    public void loadDefinition(ClassDeclaration var1) {
  75.       this.env.loadDefinition(var1);
  76.    }
  77.  
  78.    public final Object getSource() {
  79.       return this.source;
  80.    }
  81.  
  82.    public boolean resolve(int var1, ClassDefinition var2, Type var3) {
  83.       switch (var3.getTypeCode()) {
  84.          case 9:
  85.             return this.resolve(var1, var2, var3.getElementType());
  86.          case 10:
  87.             try {
  88.                Identifier var12 = var3.getClassName();
  89.                if (!var12.isQualified() && !var12.isInner() && !this.classExists(var12)) {
  90.                   this.resolve(var12);
  91.                }
  92.  
  93.                ClassDefinition var10 = this.getClassDefinition(var3);
  94.                if (!var2.canAccess(this, var10.getClassDeclaration())) {
  95.                   this.error(var1, "cant.access.class", var10);
  96.                   return true;
  97.                }
  98.  
  99.                var10.noteUsedBy(var2, var1, this.env);
  100.                return true;
  101.             } catch (AmbiguousClass var8) {
  102.                this.error(var1, "ambig.class", var8.name1, var8.name2);
  103.                return false;
  104.             } catch (ClassNotFound var9) {
  105.                ClassNotFound var11 = var9;
  106.  
  107.                try {
  108.                   if (var11.name.isInner() && this.getPackage(var11.name.getTopName()).exists()) {
  109.                      this.env.error(var1, "class.and.package", var11.name.getTopName());
  110.                   }
  111.                } catch (IOException var7) {
  112.                   this.env.error(var1, "io.exception", "package check");
  113.                }
  114.  
  115.                this.error(var1, "class.not.found", var9.name, "type declaration");
  116.                return false;
  117.             }
  118.          case 11:
  119.          default:
  120.             return true;
  121.          case 12:
  122.             boolean var4 = this.resolve(var1, var2, var3.getReturnType());
  123.             Type[] var5 = var3.getArgumentTypes();
  124.  
  125.             for(int var6 = var5.length; var6-- > 0; var4 &= this.resolve(var1, var2, var5[var6])) {
  126.             }
  127.  
  128.             return var4;
  129.       }
  130.    }
  131.  
  132.    public Type resolveNames(ClassDefinition var1, Type var2) {
  133.       switch (var2.getTypeCode()) {
  134.          case 9:
  135.             var2 = Type.tArray(this.resolveNames(var1, var2.getElementType()));
  136.             break;
  137.          case 10:
  138.             Identifier var11 = var2.getClassName();
  139.             Identifier var12 = var1.resolveName(this, var11);
  140.             if (var11 != var12) {
  141.                var2 = Type.tClass(var12);
  142.             }
  143.          case 11:
  144.          default:
  145.             break;
  146.          case 12:
  147.             Type var3 = var2.getReturnType();
  148.             Type var4 = this.resolveNames(var1, var3);
  149.             Type[] var5 = var2.getArgumentTypes();
  150.             Type[] var6 = new Type[var5.length];
  151.             boolean var7 = var3 != var4;
  152.             int var8 = var5.length;
  153.  
  154.             while(var8-- > 0) {
  155.                Type var9 = var5[var8];
  156.                Type var10 = this.resolveNames(var1, var9);
  157.                var6[var8] = var10;
  158.                if (var9 != var10) {
  159.                   var7 = true;
  160.                }
  161.             }
  162.  
  163.             if (var7) {
  164.                var2 = Type.tMethod(var4, var6);
  165.             }
  166.       }
  167.  
  168.       return var2;
  169.    }
  170.  
  171.    public Identifier resolveName(Identifier var1) {
  172.       if (this.innerClasses() && var1.isQualified()) {
  173.          Identifier var5 = this.resolveName(var1.getHead());
  174.          if (!this.classExists(var5)) {
  175.             return this.resolvePackageQualifiedName(var1);
  176.          } else {
  177.             try {
  178.                return this.getClassDefinition(var5).resolveInnerClass(this, var1.getTail());
  179.             } catch (ClassNotFound var3) {
  180.                return Identifier.lookupInner(var5, var1.getTail());
  181.             }
  182.          }
  183.       } else {
  184.          try {
  185.             return this.resolve(var1);
  186.          } catch (ClassNotFound var4) {
  187.             Imports var2 = this.getImports();
  188.             return var2 != null ? var2.forceResolve(this, var1) : var1;
  189.          }
  190.       }
  191.    }
  192.  
  193.    public final Identifier resolvePackageQualifiedName(Identifier var1) {
  194.       if (!this.innerClasses()) {
  195.          return var1;
  196.       } else {
  197.          Identifier var2;
  198.          for(var2 = null; !this.classExists(var1); var1 = var1.getQualifier()) {
  199.             if (!var1.isQualified()) {
  200.                var1 = var2 == null ? var1 : Identifier.lookup(var1, var2);
  201.                var2 = null;
  202.                break;
  203.             }
  204.  
  205.             Identifier var3 = var1.getName();
  206.             var2 = var2 == null ? var3 : Identifier.lookup(var3, var2);
  207.          }
  208.  
  209.          if (var2 != null) {
  210.             var1 = Identifier.lookupInner(var1, var2);
  211.          }
  212.  
  213.          return var1;
  214.       }
  215.    }
  216.  
  217.    public Identifier resolve(Identifier var1) throws ClassNotFound {
  218.       return this.env == null ? var1 : this.env.resolve(var1);
  219.    }
  220.  
  221.    public Imports getImports() {
  222.       return this.env == null ? null : this.env.getImports();
  223.    }
  224.  
  225.    public ClassDefinition makeClassDefinition(Environment var1, int var2, IdentifierToken var3, String var4, int var5, IdentifierToken var6, IdentifierToken[] var7, ClassDefinition var8) {
  226.       return this.env == null ? null : this.env.makeClassDefinition(var1, var2, var3, var4, var5, var6, var7, var8);
  227.    }
  228.  
  229.    public FieldDefinition makeFieldDefinition(Environment var1, int var2, ClassDefinition var3, String var4, int var5, Type var6, Identifier var7, IdentifierToken[] var8, IdentifierToken[] var9, Object var10) {
  230.       return this.env == null ? null : this.env.makeFieldDefinition(var1, var2, var3, var4, var5, var6, var7, var8, var9, var10);
  231.    }
  232.  
  233.    public boolean isApplicable(FieldDefinition var1, Type[] var2) throws ClassNotFound {
  234.       Type var3 = var1.getType();
  235.       if (!var3.isType(12)) {
  236.          return false;
  237.       } else {
  238.          Type[] var4 = var3.getArgumentTypes();
  239.          if (var2.length != var4.length) {
  240.             return false;
  241.          } else {
  242.             int var5 = var2.length;
  243.  
  244.             do {
  245.                --var5;
  246.                if (var5 < 0) {
  247.                   return true;
  248.                }
  249.             } while(this.isMoreSpecific(var2[var5], var4[var5]));
  250.  
  251.             return false;
  252.          }
  253.       }
  254.    }
  255.  
  256.    public boolean isMoreSpecific(FieldDefinition var1, FieldDefinition var2) throws ClassNotFound {
  257.       Type var3 = var1.getClassDeclaration().getType();
  258.       Type var4 = var2.getClassDeclaration().getType();
  259.       boolean var5 = this.isMoreSpecific(var3, var4) && this.isApplicable(var2, var1.getType().getArgumentTypes());
  260.       return var5;
  261.    }
  262.  
  263.    public boolean isMoreSpecific(Type var1, Type var2) throws ClassNotFound {
  264.       return this.implicitCast(var1, var2);
  265.    }
  266.  
  267.    public boolean implicitCast(Type var1, Type var2) throws ClassNotFound {
  268.       if (var1 == var2) {
  269.          return true;
  270.       } else {
  271.          int var3 = var2.getTypeCode();
  272.          switch (var1.getTypeCode()) {
  273.             case 1:
  274.                if (var3 == 3) {
  275.                   return true;
  276.                }
  277.             case 2:
  278.             case 3:
  279.                if (var3 == 4) {
  280.                   return true;
  281.                }
  282.             case 4:
  283.                if (var3 == 5) {
  284.                   return true;
  285.                }
  286.             case 5:
  287.                if (var3 == 6) {
  288.                   return true;
  289.                }
  290.             case 6:
  291.                if (var3 == 7) {
  292.                   return true;
  293.                }
  294.             case 7:
  295.             default:
  296.                return false;
  297.             case 8:
  298.                return var2.inMask(1792);
  299.             case 9:
  300.                if (!var2.isType(9)) {
  301.                   if (var2 != Type.tObject && var2 != Type.tCloneable && var2 != Type.tSerializable) {
  302.                      return false;
  303.                   }
  304.  
  305.                   return true;
  306.                } else {
  307.                   do {
  308.                      var1 = var1.getElementType();
  309.                      var2 = var2.getElementType();
  310.                   } while(var1.isType(9) && var2.isType(9));
  311.  
  312.                   if (var1.inMask(1536) && var2.inMask(1536)) {
  313.                      return this.isMoreSpecific(var1, var2);
  314.                   } else {
  315.                      return var1.getTypeCode() == var2.getTypeCode();
  316.                   }
  317.                }
  318.             case 10:
  319.                if (var3 == 10) {
  320.                   ClassDefinition var4 = this.getClassDefinition(var1);
  321.                   ClassDefinition var5 = this.getClassDefinition(var2);
  322.                   return var5.implementedBy(this, var4.getClassDeclaration());
  323.                } else {
  324.                   return false;
  325.                }
  326.          }
  327.       }
  328.    }
  329.  
  330.    public boolean explicitCast(Type var1, Type var2) throws ClassNotFound {
  331.       if (this.implicitCast(var1, var2)) {
  332.          return true;
  333.       } else if (var1.inMask(254)) {
  334.          return var2.inMask(254);
  335.       } else if (var1.isType(10) && var2.isType(10)) {
  336.          ClassDefinition var5 = this.getClassDefinition(var1);
  337.          ClassDefinition var6 = this.getClassDefinition(var2);
  338.          if (var6.isFinal()) {
  339.             return var5.implementedBy(this, var6.getClassDeclaration());
  340.          } else if (var5.isFinal()) {
  341.             return var6.implementedBy(this, var5.getClassDeclaration());
  342.          } else {
  343.             return var6.isInterface() || var5.isInterface() || var5.superClassOf(this, var6.getClassDeclaration());
  344.          }
  345.       } else {
  346.          if (var2.isType(9)) {
  347.             if (var1.isType(9)) {
  348.                Type var3 = var1.getElementType();
  349.  
  350.                Type var4;
  351.                for(var4 = var2.getElementType(); var3.getTypeCode() == 9 && var4.getTypeCode() == 9; var4 = var4.getElementType()) {
  352.                   var3 = var3.getElementType();
  353.                }
  354.  
  355.                if (var3.inMask(1536) && var4.inMask(1536)) {
  356.                   return this.explicitCast(var3, var4);
  357.                }
  358.             } else if (var1 == Type.tObject || var1 == Type.tCloneable || var1 == Type.tSerializable) {
  359.                return true;
  360.             }
  361.          }
  362.  
  363.          return false;
  364.       }
  365.    }
  366.  
  367.    public int getFlags() {
  368.       return this.env.getFlags();
  369.    }
  370.  
  371.    public final boolean debug() {
  372.       return (this.getFlags() & 8) != 0;
  373.    }
  374.  
  375.    public final boolean optimize() {
  376.       return (this.getFlags() & 16) != 0;
  377.    }
  378.  
  379.    public final boolean verbose() {
  380.       return (this.getFlags() & 1) != 0;
  381.    }
  382.  
  383.    public final boolean dump() {
  384.       return (this.getFlags() & 2) != 0;
  385.    }
  386.  
  387.    public final boolean warnings() {
  388.       return (this.getFlags() & 4) != 0;
  389.    }
  390.  
  391.    public final boolean dependencies() {
  392.       return (this.getFlags() & 32) != 0;
  393.    }
  394.  
  395.    public final boolean print_dependencies() {
  396.       return (this.getFlags() & 1024) != 0;
  397.    }
  398.  
  399.    public final boolean innerClasses() {
  400.       return (this.getFlags() & 256) != 0;
  401.    }
  402.  
  403.    public final boolean deprecation() {
  404.       return (this.getFlags() & 512) != 0;
  405.    }
  406.  
  407.    public void innerClassesUsed(int var1) {
  408.       if (!this.innerClasses()) {
  409.          this.error(var1, "no.inner.classes");
  410.       }
  411.    }
  412.  
  413.    public void shutdown() {
  414.       if (this.env != null) {
  415.          this.env.shutdown();
  416.       }
  417.  
  418.    }
  419.  
  420.    public void error(Object var1, int var2, String var3, Object var4, Object var5, Object var6) {
  421.       this.env.error(var1, var2, var3, var4, var5, var6);
  422.    }
  423.  
  424.    public final void error(int var1, String var2, Object var3, Object var4, Object var5) {
  425.       this.error(this.source, var1, var2, var3, var4, var5);
  426.    }
  427.  
  428.    public final void error(int var1, String var2, Object var3, Object var4) {
  429.       this.error(this.source, var1, var2, var3, var4, (Object)null);
  430.    }
  431.  
  432.    public final void error(int var1, String var2, Object var3) {
  433.       this.error(this.source, var1, var2, var3, (Object)null, (Object)null);
  434.    }
  435.  
  436.    public final void error(int var1, String var2) {
  437.       this.error(this.source, var1, var2, (Object)null, (Object)null, (Object)null);
  438.    }
  439.  
  440.    public void output(String var1) {
  441.       this.env.output(var1);
  442.    }
  443.  
  444.    public static void debugOutput(Object var0) {
  445.       if (debugging) {
  446.          System.out.println(var0.toString());
  447.       }
  448.  
  449.    }
  450.  
  451.    public void setCharacterEncoding(String var1) {
  452.       this.encoding = var1;
  453.    }
  454.  
  455.    public String getCharacterEncoding() {
  456.       return this.encoding;
  457.    }
  458.  
  459.    public final boolean coverage() {
  460.       return (this.getFlags() & 64) != 0;
  461.    }
  462.  
  463.    public final boolean covdata() {
  464.       return (this.getFlags() & 128) != 0;
  465.    }
  466.  
  467.    public File getcovFile() {
  468.       return this.env.getcovFile();
  469.    }
  470. }
  471.