| /* |
| * Copyright (c) 1994, 2003, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package sun.tools.java; |
| |
| import java.util.Stack; |
| import java.io.IOException; |
| import sun.tools.tree.Context; |
| //JCOV |
| import java.io.File; |
| //end JCOV |
| |
| /** |
| * This class defines the environment for a compilation. |
| * It is used to load classes, resolve class names and |
| * report errors. It is an abstract class, a subclass |
| * must define implementations for some of the functions.<p> |
| * |
| * An environment has a source object associated with it. |
| * This is the thing against which errors are reported, it |
| * is usually a file name, a field or a class.<p> |
| * |
| * Environments can be nested to change the source object.<p> |
| * |
| * WARNING: The contents of this source file are not part of any |
| * supported API. Code that depends on them does so at its own risk: |
| * they are subject to change or removal without notice. |
| * |
| * @author Arthur van Hoff |
| */ |
| |
| public class Environment implements Constants { |
| /** |
| * The actual environment to which everything is forwarded. |
| */ |
| Environment env; |
| |
| /** |
| * External character encoding name |
| */ |
| String encoding; |
| |
| /** |
| * The object that is currently being parsed/compiled. |
| * It is either a file name (String) or a field (MemberDefinition) |
| * or a class (ClassDeclaration or ClassDefinition). |
| */ |
| Object source; |
| |
| public Environment(Environment env, Object source) { |
| if (env != null && env.env != null && env.getClass() == this.getClass()) |
| env = env.env; // a small optimization |
| this.env = env; |
| this.source = source; |
| } |
| public Environment() { |
| this(null, null); |
| } |
| |
| /** |
| * Tells whether an Identifier refers to a package which should be |
| * exempt from the "exists" check in Imports#resolve(). |
| */ |
| public boolean isExemptPackage(Identifier id) { |
| return env.isExemptPackage(id); |
| } |
| |
| /** |
| * Return a class declaration given a fully qualified class name. |
| */ |
| public ClassDeclaration getClassDeclaration(Identifier nm) { |
| return env.getClassDeclaration(nm); |
| } |
| |
| /** |
| * Return a class definition given a fully qualified class name. |
| * <p> |
| * Should be called only with 'internal' class names, i.e., the result |
| * of a call to 'resolveName' or a synthetic class name. |
| */ |
| public final ClassDefinition getClassDefinition(Identifier nm) throws ClassNotFound { |
| if (nm.isInner()) { |
| ClassDefinition c = getClassDefinition(nm.getTopName()); |
| Identifier tail = nm.getFlatName(); |
| walkTail: |
| while (tail.isQualified()) { |
| tail = tail.getTail(); |
| Identifier head = tail.getHead(); |
| //System.out.println("CLASS: " + c + " HEAD: " + head + " TAIL: " + tail); |
| String hname = head.toString(); |
| // If the name is of the form 'ClassName.N$localName', where N is |
| // a number, the field 'N$localName' may not necessarily be a member |
| // of the class named by 'ClassName', but might be a member of some |
| // inaccessible class contained within it. We use 'getLocalClass' |
| // to do the lookup in this case. This is part of a fix for bugid |
| // 4054523 and 4030421. See also 'BatchEnvironment.makeClassDefinition'. |
| // This should also work for anonymous class names of the form |
| // 'ClassName.N'. Note that the '.' qualifications get converted to |
| // '$' characters when determining the external name of the class and |
| // the name of the class file. |
| if (hname.length() > 0 |
| && Character.isDigit(hname.charAt(0))) { |
| ClassDefinition localClass = c.getLocalClass(hname); |
| if (localClass != null) { |
| c = localClass; |
| continue walkTail; |
| } |
| } else { |
| for (MemberDefinition f = c.getFirstMatch(head); |
| f != null; f = f.getNextMatch()) { |
| if (f.isInnerClass()) { |
| c = f.getInnerClass(); |
| continue walkTail; |
| } |
| } |
| } |
| throw new ClassNotFound(Identifier.lookupInner(c.getName(), head)); |
| } |
| //System.out.println("FOUND " + c + " FOR " + nm); |
| return c; |
| } |
| return getClassDeclaration(nm).getClassDefinition(this); |
| } |
| |
| |
| /** |
| * Return a class declaration given a type. Only works for |
| * class types. |
| */ |
| public ClassDeclaration getClassDeclaration(Type t) { |
| return getClassDeclaration(t.getClassName()); |
| } |
| |
| /** |
| * Return a class definition given a type. Only works for |
| * class types. |
| */ |
| public final ClassDefinition getClassDefinition(Type t) throws ClassNotFound { |
| return getClassDefinition(t.getClassName()); |
| } |
| |
| /** |
| * Check if a class exists (without actually loading it). |
| * (Since inner classes cannot in general be examined without |
| * loading source, this method does not accept inner names.) |
| */ |
| public boolean classExists(Identifier nm) { |
| return env.classExists(nm); |
| } |
| |
| public final boolean classExists(Type t) { |
| return !t.isType(TC_CLASS) || classExists(t.getClassName()); |
| } |
| |
| /** |
| * Get the package path for a package |
| */ |
| public Package getPackage(Identifier pkg) throws IOException { |
| return env.getPackage(pkg); |
| } |
| |
| /** |
| * Load the definition of a class. |
| */ |
| public void loadDefinition(ClassDeclaration c) { |
| env.loadDefinition(c); |
| } |
| |
| /** |
| * Return the source of the environment (ie: the thing being compiled/parsed). |
| */ |
| public final Object getSource() { |
| return source; |
| } |
| |
| /** |
| * Resolve a type. Make sure that all the classes referred to by |
| * the type have a definition. Report errors. Return true if |
| * the type is well-formed. Presently used for types appearing |
| * in member declarations, which represent named types internally as |
| * qualified identifiers. Type names appearing in local variable |
| * declarations and within expressions are represented as identifier |
| * or field expressions, and are resolved by 'toType', which delegates |
| * handling of the non-inner portion of the name to this method. |
| * <p> |
| * In 'toType', the various stages of qualification are represented by |
| * separate AST nodes. Here, we are given a single identifier which |
| * contains the entire qualification structure. It is not possible in |
| * general to set the error location to the exact position of a component |
| * that is in error, so an error message must refer to the entire qualified |
| * name. An attempt to keep track of the string length of the components of |
| * the name and to offset the location accordingly fails because the initial |
| * prefix of the name may have been rewritten by an earlier call to |
| * 'resolveName'. See 'SourceMember.resolveTypeStructure'. The situation |
| * is actually even worse than this, because only a single location is |
| * passed in for an entire declaration, which may contain many type names. |
| * All error messages are thus poorly localized. These checks should be |
| * done while traversing the parse tree for the type, not the type descriptor. |
| * <p> |
| * DESIGN NOTE: |
| * As far as I can tell, the two-stage resolution of names represented in |
| * string form is an artifact of the late implementation of inner classes |
| * and the use of mangled names internally within the compiler. All |
| * qualified names should have their hiearchical structure made explicit |
| * in the parse tree at the phase at which they are presented for static |
| * semantic checking. This would affect class names appearing in 'extends', |
| * 'implements', and 'throws' clauses, as well as in member declarations. |
| */ |
| public boolean resolve(long where, ClassDefinition c, Type t) { |
| switch (t.getTypeCode()) { |
| case TC_CLASS: { |
| ClassDefinition def; |
| try { |
| Identifier nm = t.getClassName(); |
| if (!nm.isQualified() && !nm.isInner() && !classExists(nm)) { |
| resolve(nm); // elicit complaints about ambiguity |
| } |
| def = getQualifiedClassDefinition(where, nm, c, false); |
| if (!c.canAccess(this, def.getClassDeclaration())) { |
| // Reported error location may be imprecise |
| // if the name is qualified. |
| error(where, "cant.access.class", def); |
| return true; // return false later |
| } |
| def.noteUsedBy(c, where, env); |
| } catch (AmbiguousClass ee) { |
| error(where, "ambig.class", ee.name1, ee.name2); |
| return false; |
| } catch (ClassNotFound e) { |
| // For now, report "class.and.package" only when the code |
| // is going to fail anyway. |
| try { |
| if (e.name.isInner() && |
| getPackage(e.name.getTopName()).exists()) { |
| env.error(where, "class.and.package", |
| e.name.getTopName()); |
| } |
| } catch (IOException ee) { |
| env.error(where, "io.exception", "package check"); |
| } |
| // This error message is also emitted for 'new' expressions. |
| // error(where, "class.not.found", e.name, "declaration"); |
| error(where, "class.not.found.no.context", e.name); |
| return false; |
| } |
| return true; |
| } |
| |
| case TC_ARRAY: |
| return resolve(where, c, t.getElementType()); |
| |
| case TC_METHOD: |
| boolean ok = resolve(where, c, t.getReturnType()); |
| Type args[] = t.getArgumentTypes(); |
| for (int i = args.length ; i-- > 0 ; ) { |
| ok &= resolve(where, c, args[i]); |
| } |
| return ok; |
| } |
| return true; |
| } |
| |
| /** |
| * Given its fully-qualified name, verify that a class is defined and accessible. |
| * Used to check components of qualified names in contexts where a class is expected. |
| * Like 'resolve', but is given a single type name, not a type descriptor. |
| */ |
| public boolean resolveByName(long where, ClassDefinition c, Identifier nm) { |
| return resolveByName(where, c, nm, false); |
| } |
| |
| public boolean resolveExtendsByName(long where, ClassDefinition c, Identifier nm) { |
| return resolveByName(where, c, nm, true); |
| } |
| |
| private boolean resolveByName(long where, ClassDefinition c, |
| Identifier nm, boolean isExtends) { |
| ClassDefinition def; |
| try { |
| if (!nm.isQualified() && !nm.isInner() && !classExists(nm)) { |
| resolve(nm); // elicit complaints about ambiguity |
| } |
| def = getQualifiedClassDefinition(where, nm, c, isExtends); |
| ClassDeclaration decl = def.getClassDeclaration(); |
| if (!((!isExtends && c.canAccess(this, decl)) |
| || |
| (isExtends && c.extendsCanAccess(this, decl)))) { |
| error(where, "cant.access.class", def); |
| return true; // return false later |
| } |
| } catch (AmbiguousClass ee) { |
| error(where, "ambig.class", ee.name1, ee.name2); |
| return false; |
| } catch (ClassNotFound e) { |
| // For now, report "class.and.package" only when the code |
| // is going to fail anyway. |
| try { |
| if (e.name.isInner() && |
| getPackage(e.name.getTopName()).exists()) { |
| env.error(where, "class.and.package", |
| e.name.getTopName()); |
| } |
| } catch (IOException ee) { |
| env.error(where, "io.exception", "package check"); |
| } |
| error(where, "class.not.found", e.name, "type name"); |
| return false; |
| } |
| return true; |
| } |
| |
| /** |
| * Like 'getClassDefinition(env)', but check access on each component. |
| * Currently called only by 'resolve' above. It is doubtful that calls |
| * to 'getClassDefinition(env)' are appropriate now. |
| */ |
| public final ClassDefinition |
| getQualifiedClassDefinition(long where, |
| Identifier nm, |
| ClassDefinition ctxClass, |
| boolean isExtends) throws ClassNotFound { |
| if (nm.isInner()) { |
| ClassDefinition c = getClassDefinition(nm.getTopName()); |
| Identifier tail = nm.getFlatName(); |
| walkTail: |
| while (tail.isQualified()) { |
| tail = tail.getTail(); |
| Identifier head = tail.getHead(); |
| // System.out.println("CLASS: " + c + " HEAD: " + head + " TAIL: " + tail); |
| String hname = head.toString(); |
| // Handle synthesized names of local and anonymous classes. |
| // See 'getClassDefinition(env)' above. |
| if (hname.length() > 0 |
| && Character.isDigit(hname.charAt(0))) { |
| ClassDefinition localClass = c.getLocalClass(hname); |
| if (localClass != null) { |
| c = localClass; |
| continue walkTail; |
| } |
| } else { |
| for (MemberDefinition f = c.getFirstMatch(head); |
| f != null; f = f.getNextMatch()) { |
| if (f.isInnerClass()) { |
| ClassDeclaration rdecl = c.getClassDeclaration(); |
| c = f.getInnerClass(); |
| ClassDeclaration fdecl = c.getClassDeclaration(); |
| // This check is presumably applicable even if the |
| // original source-code name (expanded by 'resolveNames') |
| // was a simple, unqualified name. Hopefully, JLS 2e |
| // will clarify the matter. |
| if ((!isExtends |
| && !ctxClass.canAccess(env, fdecl)) |
| || |
| (isExtends |
| && !ctxClass.extendsCanAccess(env, fdecl))) { |
| // Reported error location is imprecise. |
| env.error(where, "no.type.access", head, rdecl, ctxClass); |
| } |
| // The JLS 6.6.2 restrictions on access to protected members |
| // depend in an essential way upon the syntactic form of the name. |
| // Since the compiler has previously expanded the class names |
| // here into fully-qualified form ('resolveNames'), this check |
| // cannot be performed here. Unfortunately, the original names |
| // are clobbered during 'basicCheck', which is also the phase that |
| // resolves the inheritance structure, required to implement the |
| // access restrictions. Pending a large-scale revision of the |
| // name-resolution machinery, we forgo this check, with the result |
| // that the JLS 6.6.2 restrictions are not enforced for some cases |
| // of qualified access to inner classes. Some qualified names are |
| // resolved elsewhere via a different mechanism, and will be |
| // treated correctly -- see 'FieldExpression.checkCommon'. |
| /*---------------------------------------* |
| if (f.isProtected()) { |
| Type rty = Type.tClass(rdecl.getName()); // hack |
| if (!ctxClass.protectedAccess(env, f, rty)) { |
| // Reported error location is imprecise. |
| env.error(where, "invalid.protected.type.use", |
| head, ctxClass, rty); |
| } |
| } |
| *---------------------------------------*/ |
| continue walkTail; |
| } |
| } |
| } |
| throw new ClassNotFound(Identifier.lookupInner(c.getName(), head)); |
| } |
| //System.out.println("FOUND " + c + " FOR " + nm); |
| return c; |
| } |
| return getClassDeclaration(nm).getClassDefinition(this); |
| } |
| |
| /** |
| * Resolve the names within a type, returning the adjusted type. |
| * Adjust class names to reflect scoping. |
| * Do not report errors. |
| * <p> |
| * NOTE: It would be convenient to check for errors here, such as |
| * verifying that each component of a qualified name exists and is |
| * accessible. Why must this be done in a separate phase? |
| * <p> |
| * If the 'synth' argument is true, indicating that the member whose |
| * type is being resolved is synthetic, names are resolved with respect |
| * to the package scope. (Fix for 4097882) |
| */ |
| public Type resolveNames(ClassDefinition c, Type t, boolean synth) { |
| if (tracing) dtEvent("Environment.resolveNames: " + c + ", " + t); |
| switch (t.getTypeCode()) { |
| case TC_CLASS: { |
| Identifier name = t.getClassName(); |
| Identifier rname; |
| if (synth) { |
| rname = resolvePackageQualifiedName(name); |
| } else { |
| rname = c.resolveName(this, name); |
| } |
| if (name != rname) { |
| t = Type.tClass(rname); |
| } |
| break; |
| } |
| |
| case TC_ARRAY: |
| t = Type.tArray(resolveNames(c, t.getElementType(), synth)); |
| break; |
| |
| case TC_METHOD: { |
| Type ret = t.getReturnType(); |
| Type rret = resolveNames(c, ret, synth); |
| Type args[] = t.getArgumentTypes(); |
| Type rargs[] = new Type[args.length]; |
| boolean changed = (ret != rret); |
| for (int i = args.length ; i-- > 0 ; ) { |
| Type arg = args[i]; |
| Type rarg = resolveNames(c, arg, synth); |
| rargs[i] = rarg; |
| if (arg != rarg) { |
| changed = true; |
| } |
| } |
| if (changed) { |
| t = Type.tMethod(rret, rargs); |
| } |
| break; |
| } |
| } |
| return t; |
| } |
| |
| /** |
| * Resolve a class name, using only package and import directives. |
| * Report no errors. |
| * <p> |
| */ |
| public Identifier resolveName(Identifier name) { |
| // This logic is pretty exactly parallel to that of |
| // ClassDefinition.resolveName(). |
| if (name.isQualified()) { |
| // Try to resolve the first identifier component, |
| // because inner class names take precedence over |
| // package prefixes. (Cf. ClassDefinition.resolveName.) |
| Identifier rhead = resolveName(name.getHead()); |
| |
| if (rhead.hasAmbigPrefix()) { |
| // The first identifier component refers to an |
| // ambiguous class. Limp on. We throw away the |
| // rest of the classname as it is irrelevant. |
| // (part of solution for 4059855). |
| return rhead; |
| } |
| |
| if (!this.classExists(rhead)) { |
| return this.resolvePackageQualifiedName(name); |
| } |
| try { |
| return this.getClassDefinition(rhead). |
| resolveInnerClass(this, name.getTail()); |
| } catch (ClassNotFound ee) { |
| // return partially-resolved name someone else can fail on |
| return Identifier.lookupInner(rhead, name.getTail()); |
| } |
| } |
| try { |
| return resolve(name); |
| } catch (AmbiguousClass ee) { |
| // Don't force a resolution of the name if it is ambiguous. |
| // Forcing the resolution would tack the current package |
| // name onto the front of the class, which would be wrong. |
| // Instead, mark the name as ambiguous and let a later stage |
| // find the error by calling env.resolve(name). |
| // (part of solution for 4059855). |
| |
| if (name.hasAmbigPrefix()) { |
| return name; |
| } else { |
| return name.addAmbigPrefix(); |
| } |
| } catch (ClassNotFound ee) { |
| // last chance to make something halfway sensible |
| Imports imports = getImports(); |
| if (imports != null) |
| return imports.forceResolve(this, name); |
| } |
| return name; |
| } |
| |
| /** |
| * Discover if name consists of a package prefix, followed by the |
| * name of a class (that actually exists), followed possibly by |
| * some inner class names. If we can't find a class that exists, |
| * return the name unchanged. |
| * <p> |
| * This routine is used after a class name fails to |
| * be resolved by means of imports or inner classes. |
| * However, import processing uses this routine directly, |
| * since import names must be exactly qualified to start with. |
| */ |
| public final Identifier resolvePackageQualifiedName(Identifier name) { |
| Identifier tail = null; |
| for (;;) { |
| if (classExists(name)) { |
| break; |
| } |
| if (!name.isQualified()) { |
| name = (tail == null) ? name : Identifier.lookup(name, tail); |
| tail = null; |
| break; |
| } |
| Identifier nm = name.getName(); |
| tail = (tail == null)? nm: Identifier.lookup(nm, tail); |
| name = name.getQualifier(); |
| } |
| if (tail != null) |
| name = Identifier.lookupInner(name, tail); |
| return name; |
| } |
| |
| /** |
| * Resolve a class name, using only package and import directives. |
| */ |
| public Identifier resolve(Identifier nm) throws ClassNotFound { |
| if (env == null) return nm; // a pretty useless no-op |
| return env.resolve(nm); |
| } |
| |
| /** |
| * Get the imports used to resolve class names. |
| */ |
| public Imports getImports() { |
| if (env == null) return null; // lame default |
| return env.getImports(); |
| } |
| |
| /** |
| * Create a new class. |
| */ |
| public ClassDefinition makeClassDefinition(Environment origEnv, long where, |
| IdentifierToken name, |
| String doc, int modifiers, |
| IdentifierToken superClass, |
| IdentifierToken interfaces[], |
| ClassDefinition outerClass) { |
| if (env == null) return null; // lame default |
| return env.makeClassDefinition(origEnv, where, name, |
| doc, modifiers, |
| superClass, interfaces, outerClass); |
| } |
| |
| /** |
| * Create a new field. |
| */ |
| public MemberDefinition makeMemberDefinition(Environment origEnv, long where, |
| ClassDefinition clazz, |
| String doc, int modifiers, |
| Type type, Identifier name, |
| IdentifierToken argNames[], |
| IdentifierToken expIds[], |
| Object value) { |
| if (env == null) return null; // lame default |
| return env.makeMemberDefinition(origEnv, where, clazz, doc, modifiers, |
| type, name, argNames, expIds, value); |
| } |
| |
| /** |
| * Returns true if the given method is applicable to the given arguments |
| */ |
| |
| public boolean isApplicable(MemberDefinition m, Type args[]) throws ClassNotFound { |
| Type mType = m.getType(); |
| if (!mType.isType(TC_METHOD)) |
| return false; |
| Type mArgs[] = mType.getArgumentTypes(); |
| if (args.length != mArgs.length) |
| return false; |
| for (int i = args.length ; --i >= 0 ;) |
| if (!isMoreSpecific(args[i], mArgs[i])) |
| return false; |
| return true; |
| } |
| |
| |
| /** |
| * Returns true if "best" is in every argument at least as good as "other" |
| */ |
| public boolean isMoreSpecific(MemberDefinition best, MemberDefinition other) |
| throws ClassNotFound { |
| Type bestType = best.getClassDeclaration().getType(); |
| Type otherType = other.getClassDeclaration().getType(); |
| boolean result = isMoreSpecific(bestType, otherType) |
| && isApplicable(other, best.getType().getArgumentTypes()); |
| // System.out.println("isMoreSpecific: " + best + "/" + other |
| // + " => " + result); |
| return result; |
| } |
| |
| /** |
| * Returns true if "from" is a more specific type than "to" |
| */ |
| |
| public boolean isMoreSpecific(Type from, Type to) throws ClassNotFound { |
| return implicitCast(from, to); |
| } |
| |
| /** |
| * Return true if an implicit cast from this type to |
| * the given type is allowed. |
| */ |
| public boolean implicitCast(Type from, Type to) throws ClassNotFound { |
| if (from == to) |
| return true; |
| |
| int toTypeCode = to.getTypeCode(); |
| |
| switch(from.getTypeCode()) { |
| case TC_BYTE: |
| if (toTypeCode == TC_SHORT) |
| return true; |
| case TC_SHORT: |
| case TC_CHAR: |
| if (toTypeCode == TC_INT) return true; |
| case TC_INT: |
| if (toTypeCode == TC_LONG) return true; |
| case TC_LONG: |
| if (toTypeCode == TC_FLOAT) return true; |
| case TC_FLOAT: |
| if (toTypeCode == TC_DOUBLE) return true; |
| case TC_DOUBLE: |
| default: |
| return false; |
| |
| case TC_NULL: |
| return to.inMask(TM_REFERENCE); |
| |
| case TC_ARRAY: |
| if (!to.isType(TC_ARRAY)) { |
| return (to == Type.tObject || to == Type.tCloneable |
| || to == Type.tSerializable); |
| } else { |
| // both are arrays. recurse down both until one isn't an array |
| do { |
| from = from.getElementType(); |
| to = to.getElementType(); |
| } while (from.isType(TC_ARRAY) && to.isType(TC_ARRAY)); |
| if ( from.inMask(TM_ARRAY|TM_CLASS) |
| && to.inMask(TM_ARRAY|TM_CLASS)) { |
| return isMoreSpecific(from, to); |
| } else { |
| return (from.getTypeCode() == to.getTypeCode()); |
| } |
| } |
| |
| case TC_CLASS: |
| if (toTypeCode == TC_CLASS) { |
| ClassDefinition fromDef = getClassDefinition(from); |
| ClassDefinition toDef = getClassDefinition(to); |
| return toDef.implementedBy(this, |
| fromDef.getClassDeclaration()); |
| } else { |
| return false; |
| } |
| } |
| } |
| |
| |
| /** |
| * Return true if an explicit cast from this type to |
| * the given type is allowed. |
| */ |
| public boolean explicitCast(Type from, Type to) throws ClassNotFound { |
| if (implicitCast(from, to)) { |
| return true; |
| } |
| if (from.inMask(TM_NUMBER)) { |
| return to.inMask(TM_NUMBER); |
| } |
| if (from.isType(TC_CLASS) && to.isType(TC_CLASS)) { |
| ClassDefinition fromClass = getClassDefinition(from); |
| ClassDefinition toClass = getClassDefinition(to); |
| if (toClass.isFinal()) { |
| return fromClass.implementedBy(this, |
| toClass.getClassDeclaration()); |
| } |
| if (fromClass.isFinal()) { |
| return toClass.implementedBy(this, |
| fromClass.getClassDeclaration()); |
| } |
| |
| // The code here used to omit this case. If both types |
| // involved in a cast are interfaces, then JLS 5.5 requires |
| // that we do a simple test -- make sure none of the methods |
| // in toClass and fromClass have the same signature but |
| // different return types. (bug number 4028359) |
| if (toClass.isInterface() && fromClass.isInterface()) { |
| return toClass.couldImplement(fromClass); |
| } |
| |
| return toClass.isInterface() || |
| fromClass.isInterface() || |
| fromClass.superClassOf(this, toClass.getClassDeclaration()); |
| } |
| if (to.isType(TC_ARRAY)) { |
| if (from.isType(TC_ARRAY)) { |
| Type t1 = from.getElementType(); |
| Type t2 = to.getElementType(); |
| while ((t1.getTypeCode() == TC_ARRAY) |
| && (t2.getTypeCode() == TC_ARRAY)) { |
| t1 = t1.getElementType(); |
| t2 = t2.getElementType(); |
| } |
| if (t1.inMask(TM_ARRAY|TM_CLASS) && |
| t2.inMask(TM_ARRAY|TM_CLASS)) { |
| return explicitCast(t1, t2); |
| } |
| } else if (from == Type.tObject || from == Type.tCloneable |
| || from == Type.tSerializable) |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Flags. |
| */ |
| public int getFlags() { |
| return env.getFlags(); |
| } |
| |
| /** |
| * Debugging flags. There used to be a method debug() |
| * that has been replaced because -g has changed meaning |
| * (it now cooperates with -O and line number, variable |
| * range and source file info can be toggled separately). |
| */ |
| public final boolean debug_lines() { |
| return (getFlags() & F_DEBUG_LINES) != 0; |
| } |
| public final boolean debug_vars() { |
| return (getFlags() & F_DEBUG_VARS) != 0; |
| } |
| public final boolean debug_source() { |
| return (getFlags() & F_DEBUG_SOURCE) != 0; |
| } |
| |
| /** |
| * Optimization flags. There used to be a method optimize() |
| * that has been replaced because -O has changed meaning in |
| * javac to be replaced with -O and -O:interclass. |
| */ |
| public final boolean opt() { |
| return (getFlags() & F_OPT) != 0; |
| } |
| public final boolean opt_interclass() { |
| return (getFlags() & F_OPT_INTERCLASS) != 0; |
| } |
| |
| /** |
| * Verbose |
| */ |
| public final boolean verbose() { |
| return (getFlags() & F_VERBOSE) != 0; |
| } |
| |
| /** |
| * Dump debugging stuff |
| */ |
| public final boolean dump() { |
| return (getFlags() & F_DUMP) != 0; |
| } |
| |
| /** |
| * Verbose |
| */ |
| public final boolean warnings() { |
| return (getFlags() & F_WARNINGS) != 0; |
| } |
| |
| /** |
| * Dependencies |
| */ |
| public final boolean dependencies() { |
| return (getFlags() & F_DEPENDENCIES) != 0; |
| } |
| |
| /** |
| * Print Dependencies to stdout |
| */ |
| public final boolean print_dependencies() { |
| return (getFlags() & F_PRINT_DEPENDENCIES) != 0; |
| } |
| |
| /** |
| * Deprecation warnings are enabled. |
| */ |
| public final boolean deprecation() { |
| return (getFlags() & F_DEPRECATION) != 0; |
| } |
| |
| /** |
| * Do not support virtual machines before version 1.2. |
| * This option is not supported and is only here for testing purposes. |
| */ |
| public final boolean version12() { |
| return (getFlags() & F_VERSION12) != 0; |
| } |
| |
| /** |
| * Floating point is strict by default |
| */ |
| public final boolean strictdefault() { |
| return (getFlags() & F_STRICTDEFAULT) != 0; |
| } |
| |
| /** |
| * Release resources, if any. |
| */ |
| public void shutdown() { |
| if (env != null) { |
| env.shutdown(); |
| } |
| } |
| |
| /** |
| * Issue an error. |
| * source - the input source, usually a file name string |
| * offset - the offset in the source of the error |
| * err - the error number (as defined in this interface) |
| * arg1 - an optional argument to the error (null if not applicable) |
| * arg2 - a second optional argument to the error (null if not applicable) |
| * arg3 - a third optional argument to the error (null if not applicable) |
| */ |
| public void error(Object source, long where, String err, Object arg1, Object arg2, Object arg3) { |
| env.error(source, where, err, arg1, arg2, arg3); |
| } |
| public final void error(long where, String err, Object arg1, Object arg2, Object arg3) { |
| error(source, where, err, arg1, arg2, arg3); |
| } |
| public final void error(long where, String err, Object arg1, Object arg2) { |
| error(source, where, err, arg1, arg2, null); |
| } |
| public final void error(long where, String err, Object arg1) { |
| error(source, where, err, arg1, null, null); |
| } |
| public final void error(long where, String err) { |
| error(source, where, err, null, null, null); |
| } |
| |
| /** |
| * Output a string. This can either be an error message or something |
| * for debugging. This should be used instead of println. |
| */ |
| public void output(String msg) { |
| env.output(msg); |
| } |
| |
| private static boolean debugging = (System.getProperty("javac.debug") != null); |
| |
| public static void debugOutput(Object msg) { |
| if (Environment.debugging) |
| System.out.println(msg.toString()); |
| } |
| |
| /** |
| * set character encoding name |
| */ |
| public void setCharacterEncoding(String encoding) { |
| this.encoding = encoding; |
| } |
| |
| /** |
| * Return character encoding name |
| */ |
| public String getCharacterEncoding() { |
| return encoding; |
| } |
| |
| /** |
| * Return major version to use in generated class files. |
| */ |
| public short getMajorVersion() { |
| if (env==null) return JAVA_DEFAULT_VERSION; // needed for javah |
| return env.getMajorVersion(); |
| } |
| |
| /** |
| * Return minor version to use in generated class files. |
| */ |
| public short getMinorVersion() { |
| if (env==null) return JAVA_DEFAULT_MINOR_VERSION; // needed for javah |
| return env.getMinorVersion(); |
| } |
| |
| // JCOV |
| /** |
| * get coverage flag |
| */ |
| public final boolean coverage() { |
| return (getFlags() & F_COVERAGE) != 0; |
| } |
| |
| /** |
| * get flag of generation the coverage data file |
| */ |
| public final boolean covdata() { |
| return (getFlags() & F_COVDATA) != 0; |
| } |
| |
| /** |
| * Return the coverage data file |
| */ |
| public File getcovFile() { |
| return env.getcovFile(); |
| } |
| |
| // end JCOV |
| |
| /** |
| * Debug tracing. |
| * Currently, this code is used only for tracing the loading and |
| * checking of classes, particularly the demand-driven aspects. |
| * This code should probably be integrated with 'debugOutput' above, |
| * but we need to give more thought to the issue of classifying debugging |
| * messages and allowing those only those of interest to be enabled. |
| * |
| * Calls to these methods are generally conditioned on the final variable |
| * 'Constants.tracing', which allows the calls to be completely omitted |
| * in a production release to avoid space and time overhead. |
| */ |
| |
| private static boolean dependtrace = |
| (System.getProperty("javac.trace.depend") != null); |
| |
| public void dtEnter(String s) { |
| if (dependtrace) System.out.println(">>> " + s); |
| } |
| |
| public void dtExit(String s) { |
| if (dependtrace) System.out.println("<<< " + s); |
| } |
| |
| public void dtEvent(String s) { |
| if (dependtrace) System.out.println(s); |
| } |
| |
| /** |
| * Enable diagnostic dump of class modifier bits, including those |
| * in InnerClasses attributes, as they are written to the classfile. |
| * In the future, may also enable dumping field and method modifiers. |
| */ |
| |
| private static boolean dumpmodifiers = |
| (System.getProperty("javac.dump.modifiers") != null); |
| |
| public boolean dumpModifiers() { return dumpmodifiers; } |
| |
| } |
