Back to index...

	/*
	* 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; }

	}

Back to index...