Back to index...

	/*
	* Copyright (c) 1994, 2004, 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.javac;

	import sun.tools.java.*;
	import sun.tools.tree.*;
	import sun.tools.tree.CompoundStatement;
	import sun.tools.asm.Assembler;
	import sun.tools.asm.ConstantPool;
	import java.util.Vector;
	import java.util.Enumeration;
	import java.util.Hashtable;
	import java.util.Iterator;
	import java.io.IOException;
	import java.io.OutputStream;
	import java.io.DataOutputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.File;

	/**
	* This class represents an Java class as it is read from
	* an Java source file.
	*
	* 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.
	*/
	@Deprecated
	public
	class SourceClass extends ClassDefinition {

	/**
	* The toplevel environment, shared with the parser
	*/
	Environment toplevelEnv;

	/**
	* The default constructor
	*/
	SourceMember defConstructor;

	/**
	* The constant pool
	*/
	ConstantPool tab = new ConstantPool();

	/**
	* The list of class dependencies
	*/
	Hashtable deps = new Hashtable(11);

	/**
	* The field used to represent "this" in all of my code.
	*/
	LocalMember thisArg;

	/**
	* Last token of class, as reported by parser.
	*/
	long endPosition;

	/**
	* Access methods for constructors are distinguished from
	* the constructors themselves by a dummy first argument.
	* A unique type used for this purpose and shared by all
	* constructor access methods within a package-member class is
	* maintained here.
	* <p>
	* This field is null except in an outermost class containing
	* one or more classes needing such an access method.
	*/
	private Type dummyArgumentType = null;

	/**
	* Constructor
	*/
	public SourceClass(Environment env, long where,
	ClassDeclaration declaration, String documentation,
	int modifiers, IdentifierToken superClass,
	IdentifierToken interfaces[],
	SourceClass outerClass, Identifier localName) {
	super(env.getSource(), where,
	declaration, modifiers, superClass, interfaces);
	setOuterClass(outerClass);

	this.toplevelEnv = env;
	this.documentation = documentation;

	if (ClassDefinition.containsDeprecated(documentation)) {
	this.modifiers \|= M_DEPRECATED;
	}

	// Check for a package level class which is declared static.
	if (isStatic() && outerClass == null) {
	env.error(where, "static.class", this);
	this.modifiers &=~ M_STATIC;
	}

	// Inner classes cannot be static, nor can they be interfaces
	// (which are implicitly static). Static classes and interfaces
	// can only occur as top-level entities.
	//
	// Note that we do not have to check for local classes declared
	// to be static (this is currently caught by the parser) but
	// we check anyway in case the parser is modified to allow this.
	if (isLocal() \|\| (outerClass != null && !outerClass.isTopLevel())) {
	if (isInterface()) {
	env.error(where, "inner.interface");
	} else if (isStatic()) {
	env.error(where, "static.inner.class", this);
	this.modifiers &=~ M_STATIC;
	if (innerClassMember != null) {
	innerClassMember.subModifiers(M_STATIC);
	}
	}
	}

	if (isPrivate() && outerClass == null) {
	env.error(where, "private.class", this);
	this.modifiers &=~ M_PRIVATE;
	}
	if (isProtected() && outerClass == null) {
	env.error(where, "protected.class", this);
	this.modifiers &=~ M_PROTECTED;
	}
	/----
	if ((isPublic() \|\| isProtected()) && isInsideLocal()) {
	env.error(where, "warn.public.local.class", this);
	}
	----/

	// maybe define an uplevel "A.this" current instance field
	if (!isTopLevel() && !isLocal()) {
	LocalMember outerArg = ((SourceClass)outerClass).getThisArgument();
	UplevelReference r = getReference(outerArg);
	setOuterMember(r.getLocalField(env));
	}

	// Set simple, unmangled local name for a local or anonymous class.
	// NOTE: It would be OK to do this unconditionally, as null is the
	// correct value for a member (non-local) class.
	if (localName != null)
	setLocalName(localName);

	// Check for inner class with same simple name as one of
	// its enclosing classes. Note that 'getLocalName' returns
	// the simple, unmangled source-level name of any class.
	// The previous version of this code was not careful to avoid
	// mangled local class names. This version fixes 4047746.
	Identifier thisName = getLocalName();
	if (thisName != idNull) {
	// Test above suppresses error for nested anonymous classes,
	// which have an internal "name", but are not named in source code.
	for (ClassDefinition scope = outerClass; scope != null;
	scope = scope.getOuterClass()) {
	Identifier outerName = scope.getLocalName();
	if (thisName.equals(outerName))
	env.error(where, "inner.redefined", thisName);
	}
	}
	}

	/**
	* Return last position in this class.
	* @see #getWhere
	*/
	public long getEndPosition() {
	return endPosition;
	}

	public void setEndPosition(long endPosition) {
	this.endPosition = endPosition;
	}


	// JCOV
	/**
	* Return absolute name of source file
	*/
	public String getAbsoluteName() {
	String AbsName = ((ClassFile)getSource()).getAbsoluteName();

	return AbsName;
	}
	//end JCOV

	/**
	* Return imports
	*/
	public Imports getImports() {
	return toplevelEnv.getImports();
	}

	/**
	* Find or create my "this" argument, which is used for all methods.
	*/
	public LocalMember getThisArgument() {
	if (thisArg == null) {
	thisArg = new LocalMember(where, this, 0, getType(), idThis);
	}
	return thisArg;
	}

	/**
	* Add a dependency
	*/
	public void addDependency(ClassDeclaration c) {
	if (tab != null) {
	tab.put(c);
	}
	// If doing -xdepend option, save away list of class dependencies
	// making sure to NOT include duplicates or the class we are in
	// (Hashtable's put() makes sure we don't have duplicates)
	if ( toplevelEnv.print_dependencies() && c != getClassDeclaration() ) {
	deps.put(c,c);
	}
	}

	/**
	* Add a field (check it first)
	*/
	public void addMember(Environment env, MemberDefinition f) {
	// Make sure the access permissions are self-consistent:
	switch (f.getModifiers() & (M_PUBLIC \| M_PRIVATE \| M_PROTECTED)) {
	case M_PUBLIC:
	case M_PRIVATE:
	case M_PROTECTED:
	case 0:
	break;
	default:
	env.error(f.getWhere(), "inconsistent.modifier", f);
	// Cut out the more restrictive modifier(s):
	if (f.isPublic()) {
	f.subModifiers(M_PRIVATE \| M_PROTECTED);
	} else {
	f.subModifiers(M_PRIVATE);
	}
	break;
	}

	// Note exemption for synthetic members below.
	if (f.isStatic() && !isTopLevel() && !f.isSynthetic()) {
	if (f.isMethod()) {
	env.error(f.getWhere(), "static.inner.method", f, this);
	f.subModifiers(M_STATIC);
	} else if (f.isVariable()) {
	if (!f.isFinal() \|\| f.isBlankFinal()) {
	env.error(f.getWhere(), "static.inner.field", f.getName(), this);
	f.subModifiers(M_STATIC);
	}
	// Even if a static passes this test, there is still another
	// check in 'SourceMember.check'. The check is delayed so
	// that the initializer may be inspected more closely, using
	// 'isConstant()'. Part of fix for 4095568.
	} else {
	// Static inner classes are diagnosed in 'SourceClass.<init>'.
	f.subModifiers(M_STATIC);
	}
	}

	if (f.isMethod()) {
	if (f.isConstructor()) {
	if (f.getClassDefinition().isInterface()) {
	env.error(f.getWhere(), "intf.constructor");
	return;
	}
	if (f.isNative() \|\| f.isAbstract() \|\|
	f.isStatic() \|\| f.isSynchronized() \|\| f.isFinal()) {
	env.error(f.getWhere(), "constr.modifier", f);
	f.subModifiers(M_NATIVE \| M_ABSTRACT \|
	M_STATIC \| M_SYNCHRONIZED \| M_FINAL);
	}
	} else if (f.isInitializer()) {
	if (f.getClassDefinition().isInterface()) {
	env.error(f.getWhere(), "intf.initializer");
	return;
	}
	}

	// f is not allowed to return an array of void
	if ((f.getType().getReturnType()).isVoidArray()) {
	env.error(f.getWhere(), "void.array");
	}

	if (f.getClassDefinition().isInterface() &&
	(f.isStatic() \|\| f.isSynchronized() \|\| f.isNative()
	\|\| f.isFinal() \|\| f.isPrivate() \|\| f.isProtected())) {
	env.error(f.getWhere(), "intf.modifier.method", f);
	f.subModifiers(M_STATIC \| M_SYNCHRONIZED \| M_NATIVE \|
	M_FINAL \| M_PRIVATE);
	}
	if (f.isTransient()) {
	env.error(f.getWhere(), "transient.meth", f);
	f.subModifiers(M_TRANSIENT);
	}
	if (f.isVolatile()) {
	env.error(f.getWhere(), "volatile.meth", f);
	f.subModifiers(M_VOLATILE);
	}
	if (f.isAbstract()) {
	if (f.isPrivate()) {
	env.error(f.getWhere(), "abstract.private.modifier", f);
	f.subModifiers(M_PRIVATE);
	}
	if (f.isStatic()) {
	env.error(f.getWhere(), "abstract.static.modifier", f);
	f.subModifiers(M_STATIC);
	}
	if (f.isFinal()) {
	env.error(f.getWhere(), "abstract.final.modifier", f);
	f.subModifiers(M_FINAL);
	}
	if (f.isNative()) {
	env.error(f.getWhere(), "abstract.native.modifier", f);
	f.subModifiers(M_NATIVE);
	}
	if (f.isSynchronized()) {
	env.error(f.getWhere(),"abstract.synchronized.modifier",f);
	f.subModifiers(M_SYNCHRONIZED);
	}
	}
	if (f.isAbstract() \|\| f.isNative()) {
	if (f.getValue() != null) {
	env.error(f.getWhere(), "invalid.meth.body", f);
	f.setValue(null);
	}
	} else {
	if (f.getValue() == null) {
	if (f.isConstructor()) {
	env.error(f.getWhere(), "no.constructor.body", f);
	} else {
	env.error(f.getWhere(), "no.meth.body", f);
	}
	f.addModifiers(M_ABSTRACT);
	}
	}
	Vector arguments = f.getArguments();
	if (arguments != null) {
	// arguments can be null if this is an implicit abstract method
	int argumentLength = arguments.size();
	Type argTypes[] = f.getType().getArgumentTypes();
	for (int i = 0; i < argTypes.length; i++) {
	Object arg = arguments.elementAt(i);
	long where = f.getWhere();
	if (arg instanceof MemberDefinition) {
	where = ((MemberDefinition)arg).getWhere();
	arg = ((MemberDefinition)arg).getName();
	}
	// (arg should be an Identifier now)
	if (argTypes[i].isType(TC_VOID)
	\|\| argTypes[i].isVoidArray()) {
	env.error(where, "void.argument", arg);
	}
	}
	}
	} else if (f.isInnerClass()) {
	if (f.isVolatile() \|\|
	f.isTransient() \|\| f.isNative() \|\| f.isSynchronized()) {
	env.error(f.getWhere(), "inner.modifier", f);
	f.subModifiers(M_VOLATILE \| M_TRANSIENT \|
	M_NATIVE \| M_SYNCHRONIZED);
	}
	// same check as for fields, below:
	if (f.getClassDefinition().isInterface() &&
	(f.isPrivate() \|\| f.isProtected())) {
	env.error(f.getWhere(), "intf.modifier.field", f);
	f.subModifiers(M_PRIVATE \| M_PROTECTED);
	f.addModifiers(M_PUBLIC);
	// Fix up the class itself to agree with
	// the inner-class member.
	ClassDefinition c = f.getInnerClass();
	c.subModifiers(M_PRIVATE \| M_PROTECTED);
	c.addModifiers(M_PUBLIC);
	}
	} else {
	if (f.getType().isType(TC_VOID) \|\| f.getType().isVoidArray()) {
	env.error(f.getWhere(), "void.inst.var", f.getName());
	// REMIND: set type to error
	return;
	}

	if (f.isSynchronized() \|\| f.isAbstract() \|\| f.isNative()) {
	env.error(f.getWhere(), "var.modifier", f);
	f.subModifiers(M_SYNCHRONIZED \| M_ABSTRACT \| M_NATIVE);
	}
	if (f.isStrict()) {
	env.error(f.getWhere(), "var.floatmodifier", f);
	f.subModifiers(M_STRICTFP);
	}
	if (f.isTransient() && isInterface()) {
	env.error(f.getWhere(), "transient.modifier", f);
	f.subModifiers(M_TRANSIENT);
	}
	if (f.isVolatile() && (isInterface() \|\| f.isFinal())) {
	env.error(f.getWhere(), "volatile.modifier", f);
	f.subModifiers(M_VOLATILE);
	}
	if (f.isFinal() && (f.getValue() == null) && isInterface()) {
	env.error(f.getWhere(), "initializer.needed", f);
	f.subModifiers(M_FINAL);
	}

	if (f.getClassDefinition().isInterface() &&
	(f.isPrivate() \|\| f.isProtected())) {
	env.error(f.getWhere(), "intf.modifier.field", f);
	f.subModifiers(M_PRIVATE \| M_PROTECTED);
	f.addModifiers(M_PUBLIC);
	}
	}
	// Do not check for repeated methods here: Types are not yet resolved.
	if (!f.isInitializer()) {
	for (MemberDefinition f2 = getFirstMatch(f.getName());
	f2 != null; f2 = f2.getNextMatch()) {
	if (f.isVariable() && f2.isVariable()) {
	env.error(f.getWhere(), "var.multidef", f, f2);
	return;
	} else if (f.isInnerClass() && f2.isInnerClass() &&
	!f.getInnerClass().isLocal() &&
	!f2.getInnerClass().isLocal()) {
	// Found a duplicate inner-class member.
	// Duplicate local classes are detected in
	// 'VarDeclarationStatement.checkDeclaration'.
	env.error(f.getWhere(), "inner.class.multidef", f);
	return;
	}
	}
	}

	super.addMember(env, f);
	}

	/**
	* Create an environment suitable for checking this class.
	* Make sure the source and imports are set right.
	* Make sure the environment contains no context information.
	* (Actually, throw away env altogether and use toplevelEnv instead.)
	*/
	public Environment setupEnv(Environment env) {
	// In some cases, we go to some trouble to create the 'env' argument
	// that is discarded. We should remove the 'env' argument entirely
	// as well as the vestigial code that supports it. See comments on
	// 'newEnvironment' in 'checkInternal' below.
	return new Environment(toplevelEnv, this);
	}

	/**
	* A source class never reports deprecation, since the compiler
	* allows access to deprecated features that are being compiled
	* in the same job.
	*/
	public boolean reportDeprecated(Environment env) {
	return false;
	}

	/**
	* See if the source file of this class is right.
	* @see ClassDefinition#noteUsedBy
	*/
	public void noteUsedBy(ClassDefinition ref, long where, Environment env) {
	// If this class is not public, watch for cross-file references.
	super.noteUsedBy(ref, where, env);
	ClassDefinition def = this;
	while (def.isInnerClass()) {
	def = def.getOuterClass();
	}
	if (def.isPublic()) {
	return; // already checked
	}
	while (ref.isInnerClass()) {
	ref = ref.getOuterClass();
	}
	if (def.getSource().equals(ref.getSource())) {
	return; // intra-file reference
	}
	((SourceClass)def).checkSourceFile(env, where);
	}

	/**
	* Check this class and all its fields.
	*/
	public void check(Environment env) throws ClassNotFound {
	if (tracing) env.dtEnter("SourceClass.check: " + getName());
	if (isInsideLocal()) {
	// An inaccessible class gets checked when the surrounding
	// block is checked.
	// QUERY: Should this case ever occur?
	// What would invoke checking of a local class aside from
	// checking the surrounding method body?
	if (tracing) env.dtEvent("SourceClass.check: INSIDE LOCAL " +
	getOuterClass().getName());
	getOuterClass().check(env);
	} else {
	if (isInnerClass()) {
	if (tracing) env.dtEvent("SourceClass.check: INNER CLASS " +
	getOuterClass().getName());
	// Make sure the outer is checked first.
	((SourceClass)getOuterClass()).maybeCheck(env);
	}
	Vset vset = new Vset();
	Context ctx = null;
	if (tracing)
	env.dtEvent("SourceClass.check: CHECK INTERNAL " + getName());
	vset = checkInternal(setupEnv(env), ctx, vset);
	// drop vset here
	}
	if (tracing) env.dtExit("SourceClass.check: " + getName());
	}

	private void maybeCheck(Environment env) throws ClassNotFound {
	if (tracing) env.dtEvent("SourceClass.maybeCheck: " + getName());
	// Check this class now, if it has not yet been checked.
	// Cf. Main.compile(). Perhaps this code belongs there somehow.
	ClassDeclaration c = getClassDeclaration();
	if (c.getStatus() == CS_PARSED) {
	// Set it first to avoid vicious circularity:
	c.setDefinition(this, CS_CHECKED);
	check(env);
	}
	}

	private Vset checkInternal(Environment env, Context ctx, Vset vset)
	throws ClassNotFound {
	Identifier nm = getClassDeclaration().getName();
	if (env.verbose()) {
	env.output("[checking class " + nm + "]");
	}

	// Save context enclosing class for later access
	// by 'ClassDefinition.resolveName.'
	classContext = ctx;

	// At present, the call to 'newEnvironment' is not needed.
	// The incoming environment to 'basicCheck' is always passed to
	// 'setupEnv', which discards it completely. This is also the
	// only call to 'newEnvironment', which is now apparently dead code.
	basicCheck(Context.newEnvironment(env, ctx));

	// Validate access for all inner-class components
	// of a qualified name, not just the last one, which
	// is checked below. Yes, this is a dirty hack...
	// Much of this code was cribbed from 'checkSupers'.
	// Part of fix for 4094658.
	ClassDeclaration sup = getSuperClass();
	if (sup != null) {
	long where = getWhere();
	where = IdentifierToken.getWhere(superClassId, where);
	env.resolveExtendsByName(where, this, sup.getName());
	}
	for (int i = 0 ; i < interfaces.length ; i++) {
	ClassDeclaration intf = interfaces[i];
	long where = getWhere();
	// Error localization fails here if interfaces were
	// elided during error recovery from an invalid one.
	if (interfaceIds != null
	&& interfaceIds.length == interfaces.length) {
	where = IdentifierToken.getWhere(interfaceIds[i], where);
	}
	env.resolveExtendsByName(where, this, intf.getName());
	}

	// Does the name already exist in an imported package?
	// See JLS 8.1 for the precise rules.
	if (!isInnerClass() && !isInsideLocal()) {
	// Discard package qualification for the import checks.
	Identifier simpleName = nm.getName();
	try {
	// We want this to throw a ClassNotFound exception
	Imports imports = toplevelEnv.getImports();
	Identifier ID = imports.resolve(env, simpleName);
	if (ID != getName())
	env.error(where, "class.multidef.import", simpleName, ID);
	} catch (AmbiguousClass e) {
	// At least one of e.name1 and e.name2 must be different
	Identifier ID = (e.name1 != getName()) ? e.name1 : e.name2;
	env.error(where, "class.multidef.import", simpleName, ID);
	} catch (ClassNotFound e) {
	// we want this to happen
	}

	// Make sure that no package with the same fully qualified
	// name exists. This is required by JLS 7.1. We only need
	// to perform this check for top level classes -- it isn't
	// necessary for inner classes. (bug 4101529)
	//
	// This change has been backed out because, on WIN32, it
	// failed to distinguish between java.awt.event and
	// java.awt.Event when looking for a directory. We will
	// add this back in later.
	//
	// try {
	// if (env.getPackage(nm).exists()) {
	// env.error(where, "class.package.conflict", nm);
	// }
	// } catch (java.io.IOException ee) {
	// env.error(where, "io.exception.package", nm);
	// }

	// Make sure it was defined in the right file
	if (isPublic()) {
	checkSourceFile(env, getWhere());
	}
	}

	vset = checkMembers(env, ctx, vset);
	return vset;
	}

	private boolean sourceFileChecked = false;

	/**
	* See if the source file of this class is of the right name.
	*/
	public void checkSourceFile(Environment env, long where) {
	// one error per offending class is sufficient
	if (sourceFileChecked) return;
	sourceFileChecked = true;

	String fname = getName().getName() + ".java";
	String src = ((ClassFile)getSource()).getName();
	if (!src.equals(fname)) {
	if (isPublic()) {
	env.error(where, "public.class.file", this, fname);
	} else {
	env.error(where, "warn.package.class.file", this, src, fname);
	}
	}
	}

	// Set true if superclass (but not necessarily superinterfaces) have
	// been checked. If the superclass is still unresolved, then an error
	// message should have been issued, and we assume that no further
	// resolution is possible.
	private boolean supersChecked = false;

	/**
	* Overrides 'ClassDefinition.getSuperClass'.
	*/

	public ClassDeclaration getSuperClass(Environment env) {
	if (tracing) env.dtEnter("SourceClass.getSuperClass: " + this);
	// Superclass may fail to be set because of error recovery,
	// so resolve types here only if 'checkSupers' has not yet
	// completed its checks on the superclass.
	// QUERY: Can we eliminate the need to resolve superclasses on demand?
	// See comments in 'checkSupers' and in 'ClassDefinition.getInnerClass'.
	if (superClass == null && superClassId != null && !supersChecked) {
	resolveTypeStructure(env);
	// We used to report an error here if the superclass was not
	// resolved. Having moved the call to 'checkSupers' from 'basicCheck'
	// into 'resolveTypeStructure', the errors reported here should have
	// already been reported. Furthermore, error recovery can null out
	// the superclass, which would cause a spurious error from the test here.
	}
	if (tracing) env.dtExit("SourceClass.getSuperClass: " + this);
	return superClass;
	}

	/**
	* Check that all superclasses and superinterfaces are defined and
	* well formed. Among other checks, verify that the inheritance
	* graph is acyclic. Called from 'resolveTypeStructure'.
	*/

	private void checkSupers(Environment env) throws ClassNotFound {

	// * DEBUG *
	supersCheckStarted = true;

	if (tracing) env.dtEnter("SourceClass.checkSupers: " + this);

	if (isInterface()) {
	if (isFinal()) {
	Identifier nm = getClassDeclaration().getName();
	env.error(getWhere(), "final.intf", nm);
	// Interfaces have no superclass. Superinterfaces
	// are checked below, in code shared with the class case.
	}
	} else {
	// Check superclass.
	// Call to 'getSuperClass(env)' (note argument) attempts
	// 'resolveTypeStructure' if superclass has not successfully
	// been resolved. Since we have just now called 'resolveSupers'
	// (see our call in 'resolveTypeStructure'), it is not clear
	// that this can do any good. Why not 'getSuperClass()' here?
	if (getSuperClass(env) != null) {
	long where = getWhere();
	where = IdentifierToken.getWhere(superClassId, where);
	try {
	ClassDefinition def =
	getSuperClass().getClassDefinition(env);
	// Resolve superclass and its ancestors.
	def.resolveTypeStructure(env);
	// Access to the superclass should be checked relative
	// to the surrounding context, not as if the reference
	// appeared within the class body. Changed 'canAccess'
	// to 'extendsCanAccess' to fix 4087314.
	if (!extendsCanAccess(env, getSuperClass())) {
	env.error(where, "cant.access.class", getSuperClass());
	// Might it be a better recovery to let the access go through?
	superClass = null;
	} else if (def.isFinal()) {
	env.error(where, "super.is.final", getSuperClass());
	// Might it be a better recovery to let the access go through?
	superClass = null;
	} else if (def.isInterface()) {
	env.error(where, "super.is.intf", getSuperClass());
	superClass = null;
	} else if (superClassOf(env, getSuperClass())) {
	env.error(where, "cyclic.super");
	superClass = null;
	} else {
	def.noteUsedBy(this, where, env);
	}
	if (superClass == null) {
	def = null;
	} else {
	// If we have a valid superclass, check its
	// supers as well, and so on up to root class.
	// Call to 'enclosingClassOf' will raise
	// 'NullPointerException' if 'def' is null,
	// so omit this check as error recovery.
	ClassDefinition sup = def;
	for (;;) {
	if (enclosingClassOf(sup)) {
	// Do we need a similar test for
	// interfaces? See bugid 4038529.
	env.error(where, "super.is.inner");
	superClass = null;
	break;
	}
	// Since we resolved the superclass and its
	// ancestors above, we should not discover
	// any unresolved classes on the superclass
	// chain. It should thus be sufficient to
	// call 'getSuperClass()' (no argument) here.
	ClassDeclaration s = sup.getSuperClass(env);
	if (s == null) {
	// Superclass not resolved due to error.
	break;
	}
	sup = s.getClassDefinition(env);
	}
	}
	} catch (ClassNotFound e) {
	// Error is detected in call to 'getClassDefinition'.
	// The class may actually exist but be ambiguous.
	// Call env.resolve(e.name) to see if it is.
	// env.resolve(name) will definitely tell us if the
	// class is ambiguous, but may not necessarily tell
	// us if the class is not found.
	// (part of solution for 4059855)
	reportError: {
	try {
	env.resolve(e.name);
	} catch (AmbiguousClass ee) {
	env.error(where,
	"ambig.class", ee.name1, ee.name2);
	superClass = null;
	break reportError;
	} catch (ClassNotFound ee) {
	// fall through
	}
	env.error(where, "super.not.found", e.name, this);
	superClass = null;
	} // The break exits this block
	}

	} else {
	// Superclass was null on entry, after call to
	// 'resolveSupers'. This should normally not happen,
	// as 'resolveSupers' sets 'superClass' to a non-null
	// value for all named classes, except for one special
	// case: 'java.lang.Object', which has no superclass.
	if (isAnonymous()) {
	// checker should have filled it in first
	throw new CompilerError("anonymous super");
	} else if (!getName().equals(idJavaLangObject)) {
	throw new CompilerError("unresolved super");
	}
	}
	}

	// At this point, if 'superClass' is null due to an error
	// in the user program, a message should have been issued.
	supersChecked = true;

	// Check interfaces
	for (int i = 0 ; i < interfaces.length ; i++) {
	ClassDeclaration intf = interfaces[i];
	long where = getWhere();
	if (interfaceIds != null
	&& interfaceIds.length == interfaces.length) {
	where = IdentifierToken.getWhere(interfaceIds[i], where);
	}
	try {
	ClassDefinition def = intf.getClassDefinition(env);
	// Resolve superinterface and its ancestors.
	def.resolveTypeStructure(env);
	// Check superinterface access in the correct context.
	// Changed 'canAccess' to 'extendsCanAccess' to fix 4087314.
	if (!extendsCanAccess(env, intf)) {
	env.error(where, "cant.access.class", intf);
	} else if (!intf.getClassDefinition(env).isInterface()) {
	env.error(where, "not.intf", intf);
	} else if (isInterface() && implementedBy(env, intf)) {
	env.error(where, "cyclic.intf", intf);
	} else {
	def.noteUsedBy(this, where, env);
	// Interface is OK, leave it in the interface list.
	continue;
	}
	} catch (ClassNotFound e) {
	// The interface may actually exist but be ambiguous.
	// Call env.resolve(e.name) to see if it is.
	// env.resolve(name) will definitely tell us if the
	// interface is ambiguous, but may not necessarily tell
	// us if the interface is not found.
	// (part of solution for 4059855)
	reportError2: {
	try {
	env.resolve(e.name);
	} catch (AmbiguousClass ee) {
	env.error(where,
	"ambig.class", ee.name1, ee.name2);
	superClass = null;
	break reportError2;
	} catch (ClassNotFound ee) {
	// fall through
	}
	env.error(where, "intf.not.found", e.name, this);
	superClass = null;
	} // The break exits this block
	}
	// Remove this interface from the list of interfaces
	// as recovery from an error.
	ClassDeclaration newInterfaces[] =
	new ClassDeclaration[interfaces.length - 1];
	System.arraycopy(interfaces, 0, newInterfaces, 0, i);
	System.arraycopy(interfaces, i + 1, newInterfaces, i,
	newInterfaces.length - i);
	interfaces = newInterfaces;
	--i;
	}
	if (tracing) env.dtExit("SourceClass.checkSupers: " + this);
	}

	/**
	* Check all of the members of this class.
	* <p>
	* Inner classes are checked in the following way. Any class which
	* is immediately contained in a block (anonymous and local classes)
	* is checked along with its containing method; see the
	* SourceMember.check() method for more information. Member classes
	* of this class are checked immediately after this class, unless this
	* class is insideLocal(), in which case, they are checked with the
	* rest of the members.
	*/
	private Vset checkMembers(Environment env, Context ctx, Vset vset)
	throws ClassNotFound {

	// bail out if there were any errors
	if (getError()) {
	return vset;
	}

	// Make sure that all of our member classes have been
	// basicCheck'ed before we check the rest of our members.
	// If our member classes haven't been basicCheck'ed, then they
	// may not have <init> methods. It is important that they
	// have <init> methods so we can process NewInstanceExpressions
	// correctly. This problem didn't occur before 1.2beta1.
	// This is a fix for bug 4082816.
	for (MemberDefinition f = getFirstMember();
	f != null; f = f.getNextMember()) {
	if (f.isInnerClass()) {
	// System.out.println("Considering " + f + " in " + this);
	SourceClass cdef = (SourceClass) f.getInnerClass();
	if (cdef.isMember()) {
	cdef.basicCheck(env);
	}
	}
	}

	if (isFinal() && isAbstract()) {
	env.error(where, "final.abstract", this.getName().getName());
	}

	// This class should be abstract if there are any abstract methods
	// in our parent classes and interfaces which we do not override.
	// There are odd cases when, even though we cannot access some
	// abstract method from our superclass, that abstract method can
	// still force this class to be abstract. See the discussion in
	// bug id 1240831.
	if (!isInterface() && !isAbstract() && mustBeAbstract(env)) {
	// Set the class abstract.
	modifiers \|= M_ABSTRACT;

	// Tell the user which methods force this class to be abstract.

	// First list all of the "unimplementable" abstract methods.
	Iterator iter = getPermanentlyAbstractMethods();
	while (iter.hasNext()) {
	MemberDefinition method = (MemberDefinition) iter.next();
	// We couldn't override this method even if we
	// wanted to. Try to make the error message
	// as non-confusing as possible.
	env.error(where, "abstract.class.cannot.override",
	getClassDeclaration(), method,
	method.getDefiningClassDeclaration());
	}

	// Now list all of the traditional abstract methods.
	iter = getMethods(env);
	while (iter.hasNext()) {
	// For each method, check if it is abstract. If it is,
	// output an appropriate error message.
	MemberDefinition method = (MemberDefinition) iter.next();
	if (method.isAbstract()) {
	env.error(where, "abstract.class",
	getClassDeclaration(), method,
	method.getDefiningClassDeclaration());
	}
	}
	}

	// Check the instance variables in a pre-pass before any constructors.
	// This lets constructors "in-line" any initializers directly.
	// It also lets us do some definite assignment checks on variables.
	Context ctxInit = new Context(ctx);
	Vset vsInst = vset.copy();
	Vset vsClass = vset.copy();

	// Do definite assignment checking on blank finals.
	// Other variables do not need such checks. The simple textual
	// ordering constraints implemented by MemberDefinition.canReach()
	// are necessary and sufficient for the other variables.
	// Note that within non-static code, all statics are always
	// definitely assigned, and vice-versa.
	for (MemberDefinition f = getFirstMember();
	f != null; f = f.getNextMember()) {
	if (f.isVariable() && f.isBlankFinal()) {
	// The following allocates a LocalMember object as a proxy
	// to represent the field.
	int number = ctxInit.declareFieldNumber(f);
	if (f.isStatic()) {
	vsClass = vsClass.addVarUnassigned(number);
	vsInst = vsInst.addVar(number);
	} else {
	vsInst = vsInst.addVarUnassigned(number);
	vsClass = vsClass.addVar(number);
	}
	}
	}

	// For instance variable checks, use a context with a "this" parameter.
	Context ctxInst = new Context(ctxInit, this);
	LocalMember thisArg = getThisArgument();
	int thisNumber = ctxInst.declare(env, thisArg);
	vsInst = vsInst.addVar(thisNumber);

	// Do all the initializers in order, checking the definite
	// assignment of blank finals. Separate static from non-static.
	for (MemberDefinition f = getFirstMember();
	f != null; f = f.getNextMember()) {
	try {
	if (f.isVariable() \|\| f.isInitializer()) {
	if (f.isStatic()) {
	vsClass = f.check(env, ctxInit, vsClass);
	} else {
	vsInst = f.check(env, ctxInst, vsInst);
	}
	}
	} catch (ClassNotFound ee) {
	env.error(f.getWhere(), "class.not.found", ee.name, this);
	}
	}

	checkBlankFinals(env, ctxInit, vsClass, true);

	// Check the rest of the field definitions.
	// (Note: Re-checking a field is a no-op.)
	for (MemberDefinition f = getFirstMember();
	f != null; f = f.getNextMember()) {
	try {
	if (f.isConstructor()) {
	// When checking a constructor, an explicit call to
	// 'this(...)' makes all blank finals definitely assigned.
	// See 'MethodExpression.checkValue'.
	Vset vsCon = f.check(env, ctxInit, vsInst.copy());
	// May issue multiple messages for the same variable!!
	checkBlankFinals(env, ctxInit, vsCon, false);
	// (drop vsCon here)
	} else {
	Vset vsFld = f.check(env, ctx, vset.copy());
	// (drop vsFld here)
	}
	} catch (ClassNotFound ee) {
	env.error(f.getWhere(), "class.not.found", ee.name, this);
	}
	}

	// Must mark class as checked before visiting inner classes,
	// as they may in turn request checking of the current class
	// as an outer class. Fix for bug id 4056774.
	getClassDeclaration().setDefinition(this, CS_CHECKED);

	// Also check other classes in the same nest.
	// All checking of this nest must be finished before any
	// of its classes emit bytecode.
	// Otherwise, the inner classes might not have a chance to
	// add access or class literal fields to the outer class.
	for (MemberDefinition f = getFirstMember();
	f != null; f = f.getNextMember()) {
	if (f.isInnerClass()) {
	SourceClass cdef = (SourceClass) f.getInnerClass();
	if (!cdef.isInsideLocal()) {
	cdef.maybeCheck(env);
	}
	}
	}

	// Note: Since inner classes cannot set up-level variables,
	// the returned vset is always equal to the passed-in vset.
	// Still, we'll return it for the sake of regularity.
	return vset;
	}

	/** Make sure all my blank finals exist now. */

	private void checkBlankFinals(Environment env, Context ctxInit, Vset vset,
	boolean isStatic) {
	for (int i = 0; i < ctxInit.getVarNumber(); i++) {
	if (!vset.testVar(i)) {
	MemberDefinition ff = ctxInit.getElement(i);
	if (ff != null && ff.isBlankFinal()
	&& ff.isStatic() == isStatic
	&& ff.getClassDefinition() == this) {
	env.error(ff.getWhere(),
	"final.var.not.initialized", ff.getName());
	}
	}
	}
	}

	/**
	* Check this class has its superclass and its interfaces. Also
	* force it to have an <init> method (if it doesn't already have one)
	* and to have all the abstract methods of its parents.
	*/
	private boolean basicChecking = false;
	private boolean basicCheckDone = false;
	protected void basicCheck(Environment env) throws ClassNotFound {

	if (tracing) env.dtEnter("SourceClass.basicCheck: " + getName());

	super.basicCheck(env);

	if (basicChecking \|\| basicCheckDone) {
	if (tracing) env.dtExit("SourceClass.basicCheck: OK " + getName());
	return;
	}

	if (tracing) env.dtEvent("SourceClass.basicCheck: CHECKING " + getName());

	basicChecking = true;

	env = setupEnv(env);

	Imports imports = env.getImports();
	if (imports != null) {
	imports.resolve(env);
	}

	resolveTypeStructure(env);

	// Check the existence of the superclass and all interfaces.
	// Also responsible for breaking inheritance cycles. This call
	// has been moved to 'resolveTypeStructure', just after the call
	// to 'resolveSupers', as inheritance cycles must be broken before
	// resolving types within the members. Fixes 4073739.
	// checkSupers(env);

	if (!isInterface()) {

	// Add implicit <init> method, if necessary.
	// QUERY: What keeps us from adding an implicit constructor
	// when the user explicitly declares one? Is it truly guaranteed
	// that the declaration for such an explicit constructor will have
	// been processed by the time we arrive here? In general, 'basicCheck'
	// is called very early, prior to the normal member checking phase.
	if (!hasConstructor()) {
	Node code = new CompoundStatement(getWhere(), new Statement[0]);
	Type t = Type.tMethod(Type.tVoid);

	// Default constructors inherit the access modifiers of their
	// class. For non-inner classes, this follows from JLS 8.6.7,
	// as the only possible modifier is 'public'. For the sake of
	// robustness in the presence of errors, we ignore any other
	// modifiers. For inner classes, the rule needs to be extended
	// in some way to account for the possibility of private and
	// protected classes. We make the 'obvious' extension, however,
	// the inner classes spec is silent on this issue, and a definitive
	// resolution is needed. See bugid 4087421.
	// WORKAROUND: A private constructor might need an access method,
	// but it is not possible to create one due to a restriction in
	// the verifier. (This is a known problem -- see 4015397.)
	// We therefore do not inherit the 'private' modifier from the class,
	// allowing the default constructor to be package private. This
	// workaround can be observed via reflection, but is otherwise
	// undetectable, as the constructor is always accessible within
	// the class in which its containing (private) class appears.
	int accessModifiers = getModifiers() &
	(isInnerClass() ? (M_PUBLIC \| M_PROTECTED) : M_PUBLIC);
	env.makeMemberDefinition(env, getWhere(), this, null,
	accessModifiers,
	t, idInit, null, null, code);
	}
	}

	// Only do the inheritance/override checks if they are turned on.
	// The idea here is that they will be done in javac, but not
	// in javadoc. See the comment for turnOffChecks(), above.
	if (doInheritanceChecks) {

	// Verify the compatibility of all inherited method definitions
	// by collecting all of our inheritable methods.
	collectInheritedMethods(env);
	}

	basicChecking = false;
	basicCheckDone = true;
	if (tracing) env.dtExit("SourceClass.basicCheck: " + getName());
	}

	/**
	* Add a group of methods to this class as miranda methods.
	*
	* For a definition of Miranda methods, see the comment above the
	* method addMirandaMethods() in the file
	* sun/tools/java/ClassDeclaration.java
	*/
	protected void addMirandaMethods(Environment env,
	Iterator mirandas) {

	while(mirandas.hasNext()) {
	MemberDefinition method =
	(MemberDefinition)mirandas.next();

	addMember(method);

	//System.out.println("adding miranda method " + newMethod +
	// " to " + this);
	}
	}

	/**
	* <em>After parsing is complete</em>, resolve all names
	* except those inside method bodies or initializers.
	* In particular, this is the point at which we find out what
	* kinds of variables and methods there are in the classes,
	* and therefore what is each class's interface to the world.
	* <p>
	* Also perform certain other transformations, such as inserting
	* "this$C" arguments into constructors, and reorganizing structure
	* to flatten qualified member names.
	* <p>
	* Do not perform type-based or name-based consistency checks
	* or normalizations (such as default nullary constructors),
	* and do not attempt to compile code against this class,
	* until after this phase.
	*/

	private boolean resolving = false;

	public void resolveTypeStructure(Environment env) {

	if (tracing)
	env.dtEnter("SourceClass.resolveTypeStructure: " + getName());

	// Resolve immediately enclosing type, which in turn
	// forces resolution of all enclosing type declarations.
	ClassDefinition oc = getOuterClass();
	if (oc != null && oc instanceof SourceClass
	&& !((SourceClass)oc).resolved) {
	// Do the outer class first, always.
	((SourceClass)oc).resolveTypeStructure(env);
	// (Note: this.resolved is probably true at this point.)
	}

	// Punt if we've already resolved this class, or are currently
	// in the process of doing so.
	if (resolved \|\| resolving) {
	if (tracing)
	env.dtExit("SourceClass.resolveTypeStructure: OK " + getName());
	return;
	}

	// Previously, 'resolved' was set here, and served to prevent
	// duplicate resolutions here as well as its function in
	// 'ClassDefinition.addMember'. Now, 'resolving' serves the
	// former purpose, distinct from that of 'resolved'.
	resolving = true;

	if (tracing)
	env.dtEvent("SourceClass.resolveTypeStructure: RESOLVING " + getName());

	env = setupEnv(env);

	// Resolve superclass names to class declarations
	// for the immediate superclass and superinterfaces.
	resolveSupers(env);

	// Check all ancestor superclasses for various
	// errors, verifying definition of all superclasses
	// and superinterfaces. Also breaks inheritance cycles.
	// Calls 'resolveTypeStructure' recursively for ancestors
	// This call used to appear in 'basicCheck', but was not
	// performed early enough. Most of the compiler will barf
	// on inheritance cycles!
	try {
	checkSupers(env);
	} catch (ClassNotFound ee) {
	// Undefined classes should be reported by 'checkSupers'.
	env.error(where, "class.not.found", ee.name, this);
	}

	for (MemberDefinition
	f = getFirstMember() ; f != null ; f = f.getNextMember()) {
	if (f instanceof SourceMember)
	((SourceMember)f).resolveTypeStructure(env);
	}

	resolving = false;

	// Mark class as resolved. If new members are subsequently
	// added to the class, they will be resolved at that time.
	// See 'ClassDefinition.addMember'. Previously, this variable was
	// set prior to the calls to 'checkSupers' and 'resolveTypeStructure'
	// (which may engender further calls to 'checkSupers'). This could
	// lead to duplicate resolution of implicit constructors, as the call to
	// 'basicCheck' from 'checkSupers' could add the constructor while
	// its class is marked resolved, and thus would resolve the constructor,
	// believing it to be a "late addition". It would then be resolved
	// redundantly during the normal traversal of the members, which
	// immediately follows in the code above.
	resolved = true;

	// Now we have enough information to detect method repeats.
	for (MemberDefinition
	f = getFirstMember() ; f != null ; f = f.getNextMember()) {
	if (f.isInitializer()) continue;
	if (!f.isMethod()) continue;
	for (MemberDefinition f2 = f; (f2 = f2.getNextMatch()) != null; ) {
	if (!f2.isMethod()) continue;
	if (f.getType().equals(f2.getType())) {
	env.error(f.getWhere(), "meth.multidef", f);
	continue;
	}
	if (f.getType().equalArguments(f2.getType())) {
	env.error(f.getWhere(), "meth.redef.rettype", f, f2);
	continue;
	}
	}
	}
	if (tracing)
	env.dtExit("SourceClass.resolveTypeStructure: " + getName());
	}

	protected void resolveSupers(Environment env) {
	if (tracing)
	env.dtEnter("SourceClass.resolveSupers: " + this);
	// Find the super class
	if (superClassId != null && superClass == null) {
	superClass = resolveSuper(env, superClassId);
	// Special-case java.lang.Object here (not in the parser).
	// In all other cases, if we have a valid 'superClassId',
	// we return with a valid and non-null 'superClass' value.
	if (superClass == getClassDeclaration()
	&& getName().equals(idJavaLangObject)) {
	superClass = null;
	superClassId = null;
	}
	}
	// Find interfaces
	if (interfaceIds != null && interfaces == null) {
	interfaces = new ClassDeclaration[interfaceIds.length];
	for (int i = 0 ; i < interfaces.length ; i++) {
	interfaces[i] = resolveSuper(env, interfaceIds[i]);
	for (int j = 0; j < i; j++) {
	if (interfaces[i] == interfaces[j]) {
	Identifier id = interfaceIds[i].getName();
	long where = interfaceIds[j].getWhere();
	env.error(where, "intf.repeated", id);
	}
	}
	}
	}
	if (tracing)
	env.dtExit("SourceClass.resolveSupers: " + this);
	}

	private ClassDeclaration resolveSuper(Environment env, IdentifierToken t) {
	Identifier name = t.getName();
	if (tracing)
	env.dtEnter("SourceClass.resolveSuper: " + name);
	if (isInnerClass())
	name = outerClass.resolveName(env, name);
	else
	name = env.resolveName(name);
	ClassDeclaration result = env.getClassDeclaration(name);
	// Result is never null, as a new 'ClassDeclaration' is
	// created if one with the given name does not exist.
	if (tracing) env.dtExit("SourceClass.resolveSuper: " + name);
	return result;
	}

	/**
	* During the type-checking of an outer method body or initializer,
	* this routine is called to check a local class body
	* in the proper context.
	* @param sup the named super class or interface (if anonymous)
	* @param args the actual arguments (if anonymous)
	*/
	public Vset checkLocalClass(Environment env, Context ctx, Vset vset,
	ClassDefinition sup,
	Expression args[], Type argTypes[]
	) throws ClassNotFound {
	env = setupEnv(env);

	if ((sup != null) != isAnonymous()) {
	throw new CompilerError("resolveAnonymousStructure");
	}
	if (isAnonymous()) {
	resolveAnonymousStructure(env, sup, args, argTypes);
	}

	// Run the checks in the lexical context from the outer class.
	vset = checkInternal(env, ctx, vset);

	// This is now done by 'checkInternal' via its call to 'checkMembers'.
	// getClassDeclaration().setDefinition(this, CS_CHECKED);

	return vset;
	}

	/**
	* As with checkLocalClass, run the inline phase for a local class.
	*/
	public void inlineLocalClass(Environment env) {
	for (MemberDefinition
	f = getFirstMember(); f != null; f = f.getNextMember()) {
	if ((f.isVariable() \|\| f.isInitializer()) && !f.isStatic()) {
	continue; // inlined inside of constructors only
	}
	try {
	((SourceMember)f).inline(env);
	} catch (ClassNotFound ee) {
	env.error(f.getWhere(), "class.not.found", ee.name, this);
	}
	}
	if (getReferencesFrozen() != null && !inlinedLocalClass) {
	inlinedLocalClass = true;
	// add more constructor arguments for uplevel references
	for (MemberDefinition
	f = getFirstMember(); f != null; f = f.getNextMember()) {
	if (f.isConstructor()) {
	//((SourceMember)f).addUplevelArguments(false);
	((SourceMember)f).addUplevelArguments();
	}
	}
	}
	}
	private boolean inlinedLocalClass = false;

	/**
	* Check a class which is inside a local class, but is not itself local.
	*/
	public Vset checkInsideClass(Environment env, Context ctx, Vset vset)
	throws ClassNotFound {
	if (!isInsideLocal() \|\| isLocal()) {
	throw new CompilerError("checkInsideClass");
	}
	return checkInternal(env, ctx, vset);
	}

	/**
	* Just before checking an anonymous class, decide its true
	* inheritance, and build its (sole, implicit) constructor.
	*/
	private void resolveAnonymousStructure(Environment env,
	ClassDefinition sup,
	Expression args[], Type argTypes[]
	) throws ClassNotFound {

	if (tracing) env.dtEvent("SourceClass.resolveAnonymousStructure: " +
	this + ", super " + sup);

	// Decide now on the superclass.

	// This check has been removed as part of the fix for 4055017.
	// In the anonymous class created to hold the 'class$' method
	// of an interface, 'superClassId' refers to 'java.lang.Object'.
	/---------------------
	if (!(superClass == null && superClassId.getName() == idNull)) {
	throw new CompilerError("superclass "+superClass);
	}
	---------------------/

	if (sup.isInterface()) {
	// allow an interface in the "super class" position
	int ni = (interfaces == null) ? 0 : interfaces.length;
	ClassDeclaration i1[] = new ClassDeclaration[1+ni];
	if (ni > 0) {
	System.arraycopy(interfaces, 0, i1, 1, ni);
	if (interfaceIds != null && interfaceIds.length == ni) {
	IdentifierToken id1[] = new IdentifierToken[1+ni];
	System.arraycopy(interfaceIds, 0, id1, 1, ni);
	id1[0] = new IdentifierToken(sup.getName());
	}
	}
	i1[0] = sup.getClassDeclaration();
	interfaces = i1;

	sup = toplevelEnv.getClassDefinition(idJavaLangObject);
	}
	superClass = sup.getClassDeclaration();

	if (hasConstructor()) {
	throw new CompilerError("anonymous constructor");
	}

	// Synthesize an appropriate constructor.
	Type t = Type.tMethod(Type.tVoid, argTypes);
	IdentifierToken names[] = new IdentifierToken[argTypes.length];
	for (int i = 0; i < names.length; i++) {
	names[i] = new IdentifierToken(args[i].getWhere(),
	Identifier.lookup("$"+i));
	}
	int outerArg = (sup.isTopLevel() \|\| sup.isLocal()) ? 0 : 1;
	Expression superArgs[] = new Expression[-outerArg + args.length];
	for (int i = outerArg ; i < args.length ; i++) {
	superArgs[-outerArg + i] = new IdentifierExpression(names[i]);
	}
	long where = getWhere();
	Expression superExp;
	if (outerArg == 0) {
	superExp = new SuperExpression(where);
	} else {
	superExp = new SuperExpression(where,
	new IdentifierExpression(names[0]));
	}
	Expression superCall = new MethodExpression(where,
	superExp, idInit,
	superArgs);
	Statement body[] = { new ExpressionStatement(where, superCall) };
	Node code = new CompoundStatement(where, body);
	int mod = M_SYNTHETIC; // ISSUE: make M_PRIVATE, with wrapper?
	env.makeMemberDefinition(env, where, this, null,
	mod, t, idInit, names, null, code);
	}

	/**
	* Convert class modifiers to a string for diagnostic purposes.
	* Accepts modifiers applicable to inner classes and that appear
	* in the InnerClasses attribute only, as well as those that may
	* appear in the class modifier proper.
	*/

	private static int classModifierBits[] =
	{ ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL,
	ACC_INTERFACE, ACC_ABSTRACT, ACC_SUPER, M_ANONYMOUS, M_LOCAL,
	M_STRICTFP, ACC_STRICT};

	private static String classModifierNames[] =
	{ "PUBLIC", "PRIVATE", "PROTECTED", "STATIC", "FINAL",
	"INTERFACE", "ABSTRACT", "SUPER", "ANONYMOUS", "LOCAL",
	"STRICTFP", "STRICT"};

	static String classModifierString(int mods) {
	String s = "";
	for (int i = 0; i < classModifierBits.length; i++) {
	if ((mods & classModifierBits[i]) != 0) {
	s = s + " " + classModifierNames[i];
	mods &= ~classModifierBits[i];
	}
	}
	if (mods != 0) {
	s = s + " ILLEGAL:" + Integer.toHexString(mods);
	}
	return s;
	}

	/**
	* Find or create an access method for a private member,
	* or return null if this is not possible.
	*/
	public MemberDefinition getAccessMember(Environment env, Context ctx,
	MemberDefinition field, boolean isSuper) {
	return getAccessMember(env, ctx, field, false, isSuper);
	}

	public MemberDefinition getUpdateMember(Environment env, Context ctx,
	MemberDefinition field, boolean isSuper) {
	if (!field.isVariable()) {
	throw new CompilerError("method");
	}
	return getAccessMember(env, ctx, field, true, isSuper);
	}

	private MemberDefinition getAccessMember(Environment env, Context ctx,
	MemberDefinition field,
	boolean isUpdate,
	boolean isSuper) {

	// The 'isSuper' argument is really only meaningful when the
	// target member is a method, in which case an 'invokespecial'
	// is needed. For fields, 'getfield' and 'putfield' instructions
	// are generated in either case, and 'isSuper' currently plays
	// no essential role. Nonetheless, we maintain the distinction
	// consistently for the time being.

	boolean isStatic = field.isStatic();
	boolean isMethod = field.isMethod();

	// Find pre-existing access method.
	// In the case of a field access method, we only look for the getter.
	// A getter is always created whenever a setter is.
	// QUERY: Why doesn't the 'MemberDefinition' object for the field
	// itself just have fields for its getter and setter?
	MemberDefinition af;
	for (af = getFirstMember(); af != null; af = af.getNextMember()) {
	if (af.getAccessMethodTarget() == field) {
	if (isMethod && af.isSuperAccessMethod() == isSuper) {
	break;
	}
	// Distinguish the getter and the setter by the number of
	// arguments.
	int nargs = af.getType().getArgumentTypes().length;
	// This was (nargs == (isStatic ? 0 : 1) + (isUpdate ? 1 : 0))
	// in order to find a setter as well as a getter. This caused
	// allocation of multiple getters.
	if (nargs == (isStatic ? 0 : 1)) {
	break;
	}
	}
	}

	if (af != null) {
	if (!isUpdate) {
	return af;
	} else {
	MemberDefinition uf = af.getAccessUpdateMember();
	if (uf != null) {
	return uf;
	}
	}
	} else if (isUpdate) {
	// must find or create the getter before creating the setter
	af = getAccessMember(env, ctx, field, false, isSuper);
	}

	// If we arrive here, we are creating a new access member.

	Identifier anm;
	Type dummyType = null;

	if (field.isConstructor()) {
	// For a constructor, we use the same name as for all
	// constructors ("<init>"), but add a distinguishing
	// argument of an otherwise unused "dummy" type.
	anm = idInit;
	// Get the dummy class, creating it if necessary.
	SourceClass outerMostClass = (SourceClass)getTopClass();
	dummyType = outerMostClass.dummyArgumentType;
	if (dummyType == null) {
	// Create dummy class.
	IdentifierToken sup =
	new IdentifierToken(0, idJavaLangObject);
	IdentifierToken interfaces[] = {};
	IdentifierToken t = new IdentifierToken(0, idNull);
	int mod = M_ANONYMOUS \| M_STATIC \| M_SYNTHETIC;
	// If an interface has a public inner class, the dummy class for
	// the constructor must always be accessible. Fix for 4221648.
	if (outerMostClass.isInterface()) {
	mod \|= M_PUBLIC;
	}
	ClassDefinition dummyClass =
	toplevelEnv.makeClassDefinition(toplevelEnv,
	0, t, null, mod,
	sup, interfaces,
	outerMostClass);
	// Check the class.
	// It is likely that a full check is not really necessary,
	// but it is essential that the class be marked as parsed.
	dummyClass.getClassDeclaration().setDefinition(dummyClass, CS_PARSED);
	Expression argsX[] = {};
	Type argTypesX[] = {};
	try {
	ClassDefinition supcls =
	toplevelEnv.getClassDefinition(idJavaLangObject);
	dummyClass.checkLocalClass(toplevelEnv, null,
	new Vset(), supcls, argsX, argTypesX);
	} catch (ClassNotFound ee) {};
	// Get class type.
	dummyType = dummyClass.getType();
	outerMostClass.dummyArgumentType = dummyType;
	}
	} else {
	// Otherwise, we use the name "access$N", for the
	// smallest value of N >= 0 yielding an unused name.
	for (int i = 0; ; i++) {
	anm = Identifier.lookup(prefixAccess + i);
	if (getFirstMatch(anm) == null) {
	break;
	}
	}
	}

	Type argTypes[];
	Type t = field.getType();

	if (isStatic) {
	if (!isMethod) {
	if (!isUpdate) {
	Type at[] = { };
	argTypes = at;
	t = Type.tMethod(t); // nullary getter
	} else {
	Type at[] = { t };
	argTypes = at;
	t = Type.tMethod(Type.tVoid, argTypes); // unary setter
	}
	} else {
	// Since constructors are never static, we don't
	// have to worry about a dummy argument here.
	argTypes = t.getArgumentTypes();
	}
	} else {
	// All access methods for non-static members get an explicit
	// 'this' pointer as an extra argument, as the access methods
	// themselves must be static. EXCEPTION: Access methods for
	// constructors are non-static.
	Type classType = this.getType();
	if (!isMethod) {
	if (!isUpdate) {
	Type at[] = { classType };
	argTypes = at;
	t = Type.tMethod(t, argTypes); // nullary getter
	} else {
	Type at[] = { classType, t };
	argTypes = at;
	t = Type.tMethod(Type.tVoid, argTypes); // unary setter
	}
	} else {
	// Target is a method, possibly a constructor.
	Type at[] = t.getArgumentTypes();
	int nargs = at.length;
	if (field.isConstructor()) {
	// Access method is a constructor.
	// Requires a dummy argument.
	MemberDefinition outerThisArg =
	((SourceMember)field).getOuterThisArg();
	if (outerThisArg != null) {
	// Outer instance link must be the first argument.
	// The following is a sanity check that will catch
	// most cases in which in this requirement is violated.
	if (at[0] != outerThisArg.getType()) {
	throw new CompilerError("misplaced outer this");
	}
	// Strip outer 'this' argument.
	// It will be added back when the access method is checked.
	argTypes = new Type[nargs];
	argTypes[0] = dummyType;
	for (int i = 1; i < nargs; i++) {
	argTypes[i] = at[i];
	}
	} else {
	// There is no outer instance.
	argTypes = new Type[nargs+1];
	argTypes[0] = dummyType;
	for (int i = 0; i < nargs; i++) {
	argTypes[i+1] = at[i];
	}
	}
	} else {
	// Access method is static.
	// Requires an explicit 'this' argument.
	argTypes = new Type[nargs+1];
	argTypes[0] = classType;
	for (int i = 0; i < nargs; i++) {
	argTypes[i+1] = at[i];
	}
	}
	t = Type.tMethod(t.getReturnType(), argTypes);
	}
	}

	int nlen = argTypes.length;
	long where = field.getWhere();
	IdentifierToken names[] = new IdentifierToken[nlen];
	for (int i = 0; i < nlen; i++) {
	names[i] = new IdentifierToken(where, Identifier.lookup("$"+i));
	}

	Expression access = null;
	Expression thisArg = null;
	Expression args[] = null;

	if (isStatic) {
	args = new Expression[nlen];
	for (int i = 0 ; i < nlen ; i++) {
	args[i] = new IdentifierExpression(names[i]);
	}
	} else {
	if (field.isConstructor()) {
	// Constructor access method is non-static, so
	// 'this' works normally.
	thisArg = new ThisExpression(where);
	// Remove dummy argument, as it is not
	// passed to the target method.
	args = new Expression[nlen-1];
	for (int i = 1 ; i < nlen ; i++) {
	args[i-1] = new IdentifierExpression(names[i]);
	}
	} else {
	// Non-constructor access method is static, so
	// we use the first argument as 'this'.
	thisArg = new IdentifierExpression(names[0]);
	// Remove first argument.
	args = new Expression[nlen-1];
	for (int i = 1 ; i < nlen ; i++) {
	args[i-1] = new IdentifierExpression(names[i]);
	}
	}
	access = thisArg;
	}

	if (!isMethod) {
	access = new FieldExpression(where, access, field);
	if (isUpdate) {
	access = new AssignExpression(where, access, args[0]);
	}
	} else {
	// If true, 'isSuper' forces a non-virtual call.
	access = new MethodExpression(where, access, field, args, isSuper);
	}

	Statement code;
	if (t.getReturnType().isType(TC_VOID)) {
	code = new ExpressionStatement(where, access);
	} else {
	code = new ReturnStatement(where, access);
	}
	Statement body[] = { code };
	code = new CompoundStatement(where, body);

	// Access methods are now static (constructors excepted), and no longer final.
	// This change was mandated by the interaction of the access method
	// naming conventions and the restriction against overriding final
	// methods.
	int mod = M_SYNTHETIC;
	if (!field.isConstructor()) {
	mod \|= M_STATIC;
	}

	// Create the synthetic method within the class in which the referenced
	// private member appears. The 'env' argument to 'makeMemberDefinition'
	// is suspect because it represents the environment at the point at
	// which a reference takes place, while it should represent the
	// environment in which the definition of the synthetic method appears.
	// We get away with this because 'env' is used only to access globals
	// such as 'Environment.error', and also as an argument to
	// 'resolveTypeStructure', which immediately discards it using
	// 'setupEnv'. Apparently, the current definition of 'setupEnv'
	// represents a design change that has not been thoroughly propagated.
	// An access method is declared with same list of exceptions as its
	// target. As the exceptions are simply listed by name, the correctness
	// of this approach requires that the access method be checked
	// (name-resolved) in the same context as its target method This
	// should always be the case.
	SourceMember newf = (SourceMember)
	env.makeMemberDefinition(env, where, this,
	null, mod, t, anm, names,
	field.getExceptionIds(), code);
	// Just to be safe, copy over the name-resolved exceptions from the
	// target so that the context in which the access method is checked
	// doesn't matter.
	newf.setExceptions(field.getExceptions(env));

	newf.setAccessMethodTarget(field);
	if (isUpdate) {
	af.setAccessUpdateMember(newf);
	}
	newf.setIsSuperAccessMethod(isSuper);

	// The call to 'check' is not needed, as the access method will be
	// checked by the containing class after it is added. This is the
	// idiom followed in the implementation of class literals. (See
	// 'FieldExpression.java'.) In any case, the context is wrong in the
	// call below. The access method must be checked in the context in
	// which it is declared, i.e., the class containing the referenced
	// private member, not the (inner) class in which the original member
	// reference occurs.
	//
	// try {
	// newf.check(env, ctx, new Vset());
	// } catch (ClassNotFound ee) {
	// env.error(where, "class.not.found", ee.name, this);
	// }

	// The comment above is inaccurate. While it is often the case
	// that the containing class will check the access method, this is
	// by no means guaranteed. In fact, an access method may be added
	// after the checking of its class is complete. In this case, however,
	// the context in which the class was checked will have been saved in
	// the class definition object (by the fix for 4095716), allowing us
	// to check the field now, and in the correct context.
	// This fixes bug 4098093.

	Context checkContext = newf.getClassDefinition().getClassContext();
	if (checkContext != null) {
	//System.out.println("checking late addition: " + this);
	try {
	newf.check(env, checkContext, new Vset());
	} catch (ClassNotFound ee) {
	env.error(where, "class.not.found", ee.name, this);
	}
	}


	//System.out.println("[Access member '" +
	// newf + "' created for field '" +
	// field +"' in class '" + this + "']");

	return newf;
	}

	/**
	* Find an inner class of 'this', chosen arbitrarily.
	* Result is always an actual class, never an interface.
	* Returns null if none found.
	*/
	SourceClass findLookupContext() {
	// Look for an immediate inner class.
	for (MemberDefinition f = getFirstMember();
	f != null;
	f = f.getNextMember()) {
	if (f.isInnerClass()) {
	SourceClass ic = (SourceClass)f.getInnerClass();
	if (!ic.isInterface()) {
	return ic;
	}
	}
	}
	// Look for a class nested within an immediate inner interface.
	// At this point, we have given up on finding a minimally-nested
	// class (which would require a breadth-first traversal). It doesn't
	// really matter which inner class we find.
	for (MemberDefinition f = getFirstMember();
	f != null;
	f = f.getNextMember()) {
	if (f.isInnerClass()) {
	SourceClass lc =
	((SourceClass)f.getInnerClass()).findLookupContext();
	if (lc != null) {
	return lc;
	}
	}
	}
	// No inner classes.
	return null;
	}

	private MemberDefinition lookup = null;

	/**
	* Get helper method for class literal lookup.
	*/
	public MemberDefinition getClassLiteralLookup(long fwhere) {

	// If we have already created a lookup method, reuse it.
	if (lookup != null) {
	return lookup;
	}

	// If the current class is a nested class, make sure we put the
	// lookup method in the outermost class. Set 'lookup' for the
	// intervening inner classes so we won't have to do the search
	// again.
	if (outerClass != null) {
	lookup = outerClass.getClassLiteralLookup(fwhere);
	return lookup;
	}

	// If we arrive here, there was no existing 'class$' method.

	ClassDefinition c = this;
	boolean needNewClass = false;

	if (isInterface()) {
	// The top-level type is an interface. Try to find an existing
	// inner class in which to create the helper method. Any will do.
	c = findLookupContext();
	if (c == null) {
	// The interface has no inner classes. Create an anonymous
	// inner class to hold the helper method, as an interface must
	// not have any methods. The tests above for prior creation
	// of a 'class$' method assure that only one such class is
	// allocated for each outermost class containing a class
	// literal embedded somewhere within. Part of fix for 4055017.
	needNewClass = true;
	IdentifierToken sup =
	new IdentifierToken(fwhere, idJavaLangObject);
	IdentifierToken interfaces[] = {};
	IdentifierToken t = new IdentifierToken(fwhere, idNull);
	int mod = M_PUBLIC \| M_ANONYMOUS \| M_STATIC \| M_SYNTHETIC;
	c = (SourceClass)
	toplevelEnv.makeClassDefinition(toplevelEnv,
	fwhere, t, null, mod,
	sup, interfaces, this);
	}
	}


	// The name of the class-getter stub is "class$"
	Identifier idDClass = Identifier.lookup(prefixClass);
	Type strarg[] = { Type.tString };

	// Some sanity checks of questionable value.
	//
	// This check became useless after matchMethod() was modified
	// to not return synthetic methods.
	//
	//try {
	// lookup = c.matchMethod(toplevelEnv, c, idDClass, strarg);
	//} catch (ClassNotFound ee) {
	// throw new CompilerError("unexpected missing class");
	//} catch (AmbiguousMember ee) {
	// throw new CompilerError("synthetic name clash");
	//}
	//if (lookup != null && lookup.getClassDefinition() == c) {
	// // Error if method found was not inherited.
	// throw new CompilerError("unexpected duplicate");
	//}
	// Some sanity checks of questionable value.

	/* // The helper function looks like this.
	* // It simply maps a checked exception to an unchecked one.
	* static Class class$(String class$) {
	* try { return Class.forName(class$); }
	* catch (ClassNotFoundException forName) {
	* throw new NoClassDefFoundError(forName.getMessage());
	* }
	* }
	*/
	long w = c.getWhere();
	IdentifierToken arg = new IdentifierToken(w, idDClass);
	Expression e = new IdentifierExpression(arg);
	Expression a1[] = { e };
	Identifier idForName = Identifier.lookup("forName");
	e = new MethodExpression(w, new TypeExpression(w, Type.tClassDesc),
	idForName, a1);
	Statement body = new ReturnStatement(w, e);
	// map the exceptions
	Identifier idClassNotFound =
	Identifier.lookup("java.lang.ClassNotFoundException");
	Identifier idNoClassDefFound =
	Identifier.lookup("java.lang.NoClassDefFoundError");
	Type ctyp = Type.tClass(idClassNotFound);
	Type exptyp = Type.tClass(idNoClassDefFound);
	Identifier idGetMessage = Identifier.lookup("getMessage");
	e = new IdentifierExpression(w, idForName);
	e = new MethodExpression(w, e, idGetMessage, new Expression[0]);
	Expression a2[] = { e };
	e = new NewInstanceExpression(w, new TypeExpression(w, exptyp), a2);
	Statement handler = new CatchStatement(w, new TypeExpression(w, ctyp),
	new IdentifierToken(idForName),
	new ThrowStatement(w, e));
	Statement handlers[] = { handler };
	body = new TryStatement(w, body, handlers);

	Type mtype = Type.tMethod(Type.tClassDesc, strarg);
	IdentifierToken args[] = { arg };

	// Use default (package) access. If private, an access method would
	// be needed in the event that the class literal belonged to an interface.
	// Also, making it private tickles bug 4098316.
	lookup = toplevelEnv.makeMemberDefinition(toplevelEnv, w,
	c, null,
	M_STATIC \| M_SYNTHETIC,
	mtype, idDClass,
	args, null, body);

	// If a new class was created to contain the helper method,
	// check it now.
	if (needNewClass) {
	if (c.getClassDeclaration().getStatus() == CS_CHECKED) {
	throw new CompilerError("duplicate check");
	}
	c.getClassDeclaration().setDefinition(c, CS_PARSED);
	Expression argsX[] = {};
	Type argTypesX[] = {};
	try {
	ClassDefinition sup =
	toplevelEnv.getClassDefinition(idJavaLangObject);
	c.checkLocalClass(toplevelEnv, null,
	new Vset(), sup, argsX, argTypesX);
	} catch (ClassNotFound ee) {};
	}

	return lookup;
	}


	/**
	* A list of active ongoing compilations. This list
	* is used to stop two compilations from saving the
	* same class.
	*/
	private static Vector active = new Vector();

	/**
	* Compile this class
	*/
	public void compile(OutputStream out)
	throws InterruptedException, IOException {
	Environment env = toplevelEnv;
	synchronized (active) {
	while (active.contains(getName())) {
	active.wait();
	}
	active.addElement(getName());
	}

	try {
	compileClass(env, out);
	} catch (ClassNotFound e) {
	throw new CompilerError(e);
	} finally {
	synchronized (active) {
	active.removeElement(getName());
	active.notifyAll();
	}
	}
	}

	/**
	* Verify that the modifier bits included in 'required' are
	* all present in 'mods', otherwise signal an internal error.
	* Note that errors in the source program may corrupt the modifiers,
	* thus we rely on the fact that 'CompilerError' exceptions are
	* silently ignored after an error message has been issued.
	*/
	private static void assertModifiers(int mods, int required) {
	if ((mods & required) != required) {
	throw new CompilerError("illegal class modifiers");
	}
	}

	protected void compileClass(Environment env, OutputStream out)
	throws IOException, ClassNotFound {
	Vector variables = new Vector();
	Vector methods = new Vector();
	Vector innerClasses = new Vector();
	CompilerMember init = new CompilerMember(new MemberDefinition(getWhere(), this, M_STATIC, Type.tMethod(Type.tVoid), idClassInit, null, null), new Assembler());
	Context ctx = new Context((Context)null, init.field);

	for (ClassDefinition def = this; def.isInnerClass(); def = def.getOuterClass()) {
	innerClasses.addElement(def);
	}
	// Reverse the order, so that outer levels come first:
	int ncsize = innerClasses.size();
	for (int i = ncsize; --i >= 0; )
	innerClasses.addElement(innerClasses.elementAt(i));
	for (int i = ncsize; --i >= 0; )
	innerClasses.removeElementAt(i);

	// System.out.println("compile class " + getName());

	boolean haveDeprecated = this.isDeprecated();
	boolean haveSynthetic = this.isSynthetic();
	boolean haveConstantValue = false;
	boolean haveExceptions = false;

	// Generate code for all fields
	for (SourceMember field = (SourceMember)getFirstMember();
	field != null;
	field = (SourceMember)field.getNextMember()) {

	//System.out.println("compile field " + field.getName());

	haveDeprecated \|= field.isDeprecated();
	haveSynthetic \|= field.isSynthetic();

	try {
	if (field.isMethod()) {
	haveExceptions \|=
	(field.getExceptions(env).length > 0);

	if (field.isInitializer()) {
	if (field.isStatic()) {
	field.code(env, init.asm);
	}
	} else {
	CompilerMember f =
	new CompilerMember(field, new Assembler());
	field.code(env, f.asm);
	methods.addElement(f);
	}
	} else if (field.isInnerClass()) {
	innerClasses.addElement(field.getInnerClass());
	} else if (field.isVariable()) {
	field.inline(env);
	CompilerMember f = new CompilerMember(field, null);
	variables.addElement(f);
	if (field.isStatic()) {
	field.codeInit(env, ctx, init.asm);

	}
	haveConstantValue \|=
	(field.getInitialValue() != null);
	}
	} catch (CompilerError ee) {
	ee.printStackTrace();
	env.error(field, 0, "generic",
	field.getClassDeclaration() + ":" + field +
	"@" + ee.toString(), null, null);
	}
	}
	if (!init.asm.empty()) {
	init.asm.add(getWhere(), opc_return, true);
	methods.addElement(init);
	}

	// bail out if there were any errors
	if (getNestError()) {
	return;
	}

	int nClassAttrs = 0;

	// Insert constants
	if (methods.size() > 0) {
	tab.put("Code");
	}
	if (haveConstantValue) {
	tab.put("ConstantValue");
	}

	String sourceFile = null;
	if (env.debug_source()) {
	sourceFile = ((ClassFile)getSource()).getName();
	tab.put("SourceFile");
	tab.put(sourceFile);
	nClassAttrs += 1;
	}

	if (haveExceptions) {
	tab.put("Exceptions");
	}

	if (env.debug_lines()) {
	tab.put("LineNumberTable");
	}
	if (haveDeprecated) {
	tab.put("Deprecated");
	if (this.isDeprecated()) {
	nClassAttrs += 1;
	}
	}
	if (haveSynthetic) {
	tab.put("Synthetic");
	if (this.isSynthetic()) {
	nClassAttrs += 1;
	}
	}
	// JCOV
	if (env.coverage()) {
	nClassAttrs += 2; // AbsoluteSourcePath, TimeStamp
	tab.put("AbsoluteSourcePath");
	tab.put("TimeStamp");
	tab.put("CoverageTable");
	}
	// end JCOV
	if (env.debug_vars()) {
	tab.put("LocalVariableTable");
	}
	if (innerClasses.size() > 0) {
	tab.put("InnerClasses");
	nClassAttrs += 1; // InnerClasses
	}

	// JCOV
	String absoluteSourcePath = "";
	long timeStamp = 0;

	if (env.coverage()) {
	absoluteSourcePath = getAbsoluteName();
	timeStamp = System.currentTimeMillis();
	tab.put(absoluteSourcePath);
	}
	// end JCOV
	tab.put(getClassDeclaration());
	if (getSuperClass() != null) {
	tab.put(getSuperClass());
	}
	for (int i = 0 ; i < interfaces.length ; i++) {
	tab.put(interfaces[i]);
	}

	// Sort the methods in order to make sure both constant pool
	// entries and methods are in a deterministic order from run
	// to run (this allows comparing class files for a fixed point
	// to validate the compiler)
	CompilerMember[] ordered_methods =
	new CompilerMember[methods.size()];
	methods.copyInto(ordered_methods);
	java.util.Arrays.sort(ordered_methods);
	for (int i=0; i<methods.size(); i++)
	methods.setElementAt(ordered_methods[i], i);

	// Optimize Code and Collect method constants
	for (Enumeration e = methods.elements() ; e.hasMoreElements() ; ) {
	CompilerMember f = (CompilerMember)e.nextElement();
	try {
	f.asm.optimize(env);
	f.asm.collect(env, f.field, tab);
	tab.put(f.name);
	tab.put(f.sig);
	ClassDeclaration exp[] = f.field.getExceptions(env);
	for (int i = 0 ; i < exp.length ; i++) {
	tab.put(exp[i]);
	}
	} catch (Exception ee) {
	ee.printStackTrace();
	env.error(f.field, -1, "generic", f.field.getName() + "@" + ee.toString(), null, null);
	f.asm.listing(System.out);
	}
	}

	// Collect field constants
	for (Enumeration e = variables.elements() ; e.hasMoreElements() ; ) {
	CompilerMember f = (CompilerMember)e.nextElement();
	tab.put(f.name);
	tab.put(f.sig);

	Object val = f.field.getInitialValue();
	if (val != null) {
	tab.put((val instanceof String) ? new StringExpression(f.field.getWhere(), (String)val) : val);
	}
	}

	// Collect inner class constants
	for (Enumeration e = innerClasses.elements();
	e.hasMoreElements() ; ) {
	ClassDefinition inner = (ClassDefinition)e.nextElement();
	tab.put(inner.getClassDeclaration());

	// If the inner class is local, we do not need to add its
	// outer class here -- the outer_class_info_index is zero.
	if (!inner.isLocal()) {
	ClassDefinition outer = inner.getOuterClass();
	tab.put(outer.getClassDeclaration());
	}

	// If the local name of the class is idNull, don't bother to
	// add it to the constant pool. We won't need it.
	Identifier inner_local_name = inner.getLocalName();
	if (inner_local_name != idNull) {
	tab.put(inner_local_name.toString());
	}
	}

	// Write header
	DataOutputStream data = new DataOutputStream(out);
	data.writeInt(JAVA_MAGIC);
	data.writeShort(toplevelEnv.getMinorVersion());
	data.writeShort(toplevelEnv.getMajorVersion());
	tab.write(env, data);

	// Write class information
	int cmods = getModifiers() & MM_CLASS;

	// Certain modifiers are implied:
	// 1. Any interface (nested or not) is implicitly deemed to be abstract,
	// whether it is explicitly marked so or not. (Java 1.0.)
	// 2. A interface which is a member of a type is implicitly deemed to
	// be static, whether it is explicitly marked so or not.
	// 3a. A type which is a member of an interface is implicitly deemed
	// to be public, whether it is explicitly marked so or not.
	// 3b. A type which is a member of an interface is implicitly deemed
	// to be static, whether it is explicitly marked so or not.
	// All of these rules are implemented in 'BatchParser.beginClass',
	// but the results are verified here.

	if (isInterface()) {
	// Rule 1.
	// The VM spec states that ACC_ABSTRACT must be set when
	// ACC_INTERFACE is; this was not done by javac prior to 1.2,
	// and the runtime compensates by setting it. Making sure
	// it is set here will allow the runtime hack to eventually
	// be removed. Rule 2 doesn't apply to transformed modifiers.
	assertModifiers(cmods, ACC_ABSTRACT);
	} else {
	// Contrary to the JVM spec, we only set ACC_SUPER for classes,
	// not interfaces. This is a workaround for a bug in IE3.0,
	// which refuses interfaces with ACC_SUPER on.
	cmods \|= ACC_SUPER;
	}

	// If this is a nested class, transform access modifiers.
	if (outerClass != null) {
	// If private, transform to default (package) access.
	// If protected, transform to public.
	// M_PRIVATE and M_PROTECTED are already masked off by MM_CLASS above.
	// cmods &= ~(M_PRIVATE \| M_PROTECTED);
	if (isProtected()) cmods \|= M_PUBLIC;
	// Rule 3a. Note that Rule 3b doesn't apply to transformed modifiers.
	if (outerClass.isInterface()) {
	assertModifiers(cmods, M_PUBLIC);
	}
	}

	data.writeShort(cmods);

	if (env.dumpModifiers()) {
	Identifier cn = getName();
	Identifier nm =
	Identifier.lookup(cn.getQualifier(), cn.getFlatName());
	System.out.println();
	System.out.println("CLASSFILE " + nm);
	System.out.println("---" + classModifierString(cmods));
	}

	data.writeShort(tab.index(getClassDeclaration()));
	data.writeShort((getSuperClass() != null) ? tab.index(getSuperClass()) : 0);
	data.writeShort(interfaces.length);
	for (int i = 0 ; i < interfaces.length ; i++) {
	data.writeShort(tab.index(interfaces[i]));
	}

	// write variables
	ByteArrayOutputStream buf = new ByteArrayOutputStream(256);
	ByteArrayOutputStream attbuf = new ByteArrayOutputStream(256);
	DataOutputStream databuf = new DataOutputStream(buf);

	data.writeShort(variables.size());
	for (Enumeration e = variables.elements() ; e.hasMoreElements() ; ) {
	CompilerMember f = (CompilerMember)e.nextElement();
	Object val = f.field.getInitialValue();

	data.writeShort(f.field.getModifiers() & MM_FIELD);
	data.writeShort(tab.index(f.name));
	data.writeShort(tab.index(f.sig));

	int fieldAtts = (val != null ? 1 : 0);
	boolean dep = f.field.isDeprecated();
	boolean syn = f.field.isSynthetic();
	fieldAtts += (dep ? 1 : 0) + (syn ? 1 : 0);

	data.writeShort(fieldAtts);
	if (val != null) {
	data.writeShort(tab.index("ConstantValue"));
	data.writeInt(2);
	data.writeShort(tab.index((val instanceof String) ? new StringExpression(f.field.getWhere(), (String)val) : val));
	}
	if (dep) {
	data.writeShort(tab.index("Deprecated"));
	data.writeInt(0);
	}
	if (syn) {
	data.writeShort(tab.index("Synthetic"));
	data.writeInt(0);
	}
	}

	// write methods

	data.writeShort(methods.size());
	for (Enumeration e = methods.elements() ; e.hasMoreElements() ; ) {
	CompilerMember f = (CompilerMember)e.nextElement();

	int xmods = f.field.getModifiers() & MM_METHOD;
	// Transform floating point modifiers. M_STRICTFP
	// of member + status of enclosing class turn into
	// ACC_STRICT bit.
	if (((xmods & M_STRICTFP)!=0) \|\| ((cmods & M_STRICTFP)!=0)) {
	xmods \|= ACC_STRICT;
	} else {
	// Use the default
	if (env.strictdefault()) {
	xmods \|= ACC_STRICT;
	}
	}
	data.writeShort(xmods);

	data.writeShort(tab.index(f.name));
	data.writeShort(tab.index(f.sig));
	ClassDeclaration exp[] = f.field.getExceptions(env);
	int methodAtts = ((exp.length > 0) ? 1 : 0);
	boolean dep = f.field.isDeprecated();
	boolean syn = f.field.isSynthetic();
	methodAtts += (dep ? 1 : 0) + (syn ? 1 : 0);

	if (!f.asm.empty()) {
	data.writeShort(methodAtts+1);
	f.asm.write(env, databuf, f.field, tab);
	int natts = 0;
	if (env.debug_lines()) {
	natts++;
	}
	// JCOV
	if (env.coverage()) {
	natts++;
	}
	// end JCOV
	if (env.debug_vars()) {
	natts++;
	}
	databuf.writeShort(natts);

	if (env.debug_lines()) {
	f.asm.writeLineNumberTable(env, new DataOutputStream(attbuf), tab);
	databuf.writeShort(tab.index("LineNumberTable"));
	databuf.writeInt(attbuf.size());
	attbuf.writeTo(buf);
	attbuf.reset();
	}

	//JCOV
	if (env.coverage()) {
	f.asm.writeCoverageTable(env, (ClassDefinition)this, new DataOutputStream(attbuf), tab, f.field.getWhere());
	databuf.writeShort(tab.index("CoverageTable"));
	databuf.writeInt(attbuf.size());
	attbuf.writeTo(buf);
	attbuf.reset();
	}
	// end JCOV
	if (env.debug_vars()) {
	f.asm.writeLocalVariableTable(env, f.field, new DataOutputStream(attbuf), tab);
	databuf.writeShort(tab.index("LocalVariableTable"));
	databuf.writeInt(attbuf.size());
	attbuf.writeTo(buf);
	attbuf.reset();
	}

	data.writeShort(tab.index("Code"));
	data.writeInt(buf.size());
	buf.writeTo(data);
	buf.reset();
	} else {
	//JCOV
	if ((env.coverage()) && ((f.field.getModifiers() & M_NATIVE) > 0))
	f.asm.addNativeToJcovTab(env, (ClassDefinition)this);
	// end JCOV
	data.writeShort(methodAtts);
	}

	if (exp.length > 0) {
	data.writeShort(tab.index("Exceptions"));
	data.writeInt(2 + exp.length * 2);
	data.writeShort(exp.length);
	for (int i = 0 ; i < exp.length ; i++) {
	data.writeShort(tab.index(exp[i]));
	}
	}
	if (dep) {
	data.writeShort(tab.index("Deprecated"));
	data.writeInt(0);
	}
	if (syn) {
	data.writeShort(tab.index("Synthetic"));
	data.writeInt(0);
	}
	}

	// class attributes
	data.writeShort(nClassAttrs);

	if (env.debug_source()) {
	data.writeShort(tab.index("SourceFile"));
	data.writeInt(2);
	data.writeShort(tab.index(sourceFile));
	}

	if (this.isDeprecated()) {
	data.writeShort(tab.index("Deprecated"));
	data.writeInt(0);
	}
	if (this.isSynthetic()) {
	data.writeShort(tab.index("Synthetic"));
	data.writeInt(0);
	}

	// JCOV
	if (env.coverage()) {
	data.writeShort(tab.index("AbsoluteSourcePath"));
	data.writeInt(2);
	data.writeShort(tab.index(absoluteSourcePath));
	data.writeShort(tab.index("TimeStamp"));
	data.writeInt(8);
	data.writeLong(timeStamp);
	}
	// end JCOV

	if (innerClasses.size() > 0) {
	data.writeShort(tab.index("InnerClasses"));
	data.writeInt(2 + 24innerClasses.size());
	data.writeShort(innerClasses.size());
	for (Enumeration e = innerClasses.elements() ;
	e.hasMoreElements() ; ) {
	// For each inner class name transformation, we have a record
	// with the following fields:
	//
	// u2 inner_class_info_index; // CONSTANT_Class_info index
	// u2 outer_class_info_index; // CONSTANT_Class_info index
	// u2 inner_name_index; // CONSTANT_Utf8_info index
	// u2 inner_class_access_flags; // access_flags bitmask
	//
	// The spec states that outer_class_info_index is 0 iff
	// the inner class is not a member of its enclosing class (i.e.
	// it is a local or anonymous class). The spec also states
	// that if a class is anonymous then inner_name_index should
	// be 0.
	//
	// See also the initInnerClasses() method in BinaryClass.java.

	// Generate inner_class_info_index.
	ClassDefinition inner = (ClassDefinition)e.nextElement();
	data.writeShort(tab.index(inner.getClassDeclaration()));

	// Generate outer_class_info_index.
	//
	// Checking isLocal() should probably be enough here,
	// but the check for isAnonymous is added for good
	// measure.
	if (inner.isLocal() \|\| inner.isAnonymous()) {
	data.writeShort(0);
	} else {
	// Query: what about if inner.isInsideLocal()?
	// For now we continue to generate a nonzero
	// outer_class_info_index.
	ClassDefinition outer = inner.getOuterClass();
	data.writeShort(tab.index(outer.getClassDeclaration()));
	}

	// Generate inner_name_index.
	Identifier inner_name = inner.getLocalName();
	if (inner_name == idNull) {
	if (!inner.isAnonymous()) {
	throw new CompilerError("compileClass(), anonymous");
	}
	data.writeShort(0);
	} else {
	data.writeShort(tab.index(inner_name.toString()));
	}

	// Generate inner_class_access_flags.
	int imods = inner.getInnerClassMember().getModifiers()
	& ACCM_INNERCLASS;

	// Certain modifiers are implied for nested types.
	// See rules 1, 2, 3a, and 3b enumerated above.
	// All of these rules are implemented in 'BatchParser.beginClass',
	// but are verified here.

	if (inner.isInterface()) {
	// Rules 1 and 2.
	assertModifiers(imods, M_ABSTRACT \| M_STATIC);
	}
	if (inner.getOuterClass().isInterface()) {
	// Rules 3a and 3b.
	imods &= ~(M_PRIVATE \| M_PROTECTED); // error recovery
	assertModifiers(imods, M_PUBLIC \| M_STATIC);
	}

	data.writeShort(imods);

	if (env.dumpModifiers()) {
	Identifier fn = inner.getInnerClassMember().getName();
	Identifier nm =
	Identifier.lookup(fn.getQualifier(), fn.getFlatName());
	System.out.println("INNERCLASS " + nm);
	System.out.println("---" + classModifierString(imods));
	}

	}
	}

	// Cleanup
	data.flush();
	tab = null;

	// JCOV
	// generate coverage data
	if (env.covdata()) {
	Assembler CovAsm = new Assembler();
	CovAsm.GenVecJCov(env, (ClassDefinition)this, timeStamp);
	}
	// end JCOV
	}

	/**
	* Print out the dependencies for this class (-xdepend) option
	*/

	public void printClassDependencies(Environment env) {

	// Only do this if the -xdepend flag is on
	if ( toplevelEnv.print_dependencies() ) {

	// Name of java source file this class was in (full path)
	// e.g. /home/ohair/Test.java
	String src = ((ClassFile)getSource()).getAbsoluteName();

	// Class name, fully qualified
	// e.g. "java.lang.Object" or "FooBar" or "sun.tools.javac.Main"
	// Inner class names must be mangled, as ordinary '.' qualification
	// is used internally where the spec requires '$' separators.
	// String className = getName().toString();
	String className = Type.mangleInnerType(getName()).toString();

	// Line number where class starts in the src file
	long startLine = getWhere() >> WHEREOFFSETBITS;

	// Line number where class ends in the src file (not used yet)
	long endLine = getEndPosition() >> WHEREOFFSETBITS;

	// First line looks like:
	// CLASS:src,startLine,endLine,className
	System.out.println( "CLASS:"
	+ src + ","
	+ startLine + ","
	+ endLine + ","
	+ className);

	// For each class this class is dependent on:
	// CLDEP:className1,className2
	// where className1 is the name of the class we are in, and
	// classname2 is the name of the class className1
	// is dependent on.
	for(Enumeration e = deps.elements(); e.hasMoreElements(); ) {
	ClassDeclaration data = (ClassDeclaration) e.nextElement();
	// Mangle name of class dependend on.
	String depName =
	Type.mangleInnerType(data.getName()).toString();
	env.output("CLDEP:" + className + "," + depName);
	}
	}
	}
	}

Back to index...