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 java.io.IOException;
	import java.io.InputStream;
	import java.util.Vector;
	import java.util.Enumeration;

	/**
	* Batch file parser, this needs more work.
	*
	* 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 BatchParser extends Parser {
	/**
	* The current package
	*/
	protected Identifier pkg;

	/**
	* The current imports
	*/
	protected Imports imports;

	/**
	* The classes defined in this file
	*/
	protected Vector classes;


	/**
	* The current class
	*/
	protected SourceClass sourceClass;

	/**
	* The toplevel environment
	*/
	protected Environment toplevelEnv;

	/**
	* Create a batch file parser
	*/
	public BatchParser(Environment env, InputStream in) throws IOException {
	super(env, in);

	imports = new Imports(env);
	classes = new Vector();
	toplevelEnv = imports.newEnvironment(env);
	}

	/**
	* Package declaration
	*/
	public void packageDeclaration(long where, IdentifierToken t) {
	Identifier nm = t.getName();
	//System.out.println("package " + nm);
	if (pkg == null) {
	// This code has been changed to pass an IdentifierToken,
	// rather than an Identifier, to setCurrentPackage(). Imports
	// now needs the location of the token.
	pkg = t.getName();
	imports.setCurrentPackage(t);
	} else {
	env.error(where, "package.repeated");
	}
	}

	/**
	* Import class
	*/
	public void importClass(long pos, IdentifierToken t) {
	//System.out.println("import class " + t);
	imports.addClass(t);
	}

	/**
	* Import package
	*/
	public void importPackage(long pos, IdentifierToken t) {
	//System.out.println("import package " + t);
	imports.addPackage(t);
	}

	/**
	* Define class
	*/
	public ClassDefinition beginClass(long where, String doc, int mod,
	IdentifierToken t,
	IdentifierToken sup,
	IdentifierToken interfaces[]) {

	// If this class is nested, the modifier bits set here will
	// be copied into the 'SourceMember' object for the inner class
	// created during the call to 'makeClassDefinition' below.
	// When writing the class file, we will look there for the
	// 'untransformed' modifiers. The modifiers in the ClassDefinition
	// object will end up as the 'transformed' modifiers. Note that
	// there are some bits set here that are not legal class modifiers
	// according to the JVMS, e.g., M_PRIVATE and M_STATIC. These are
	// masked off while writing the class file, but are preserved in
	// the InnerClasses attributes.

	if (tracing) toplevelEnv.dtEnter("beginClass: " + sourceClass);

	SourceClass outerClass = sourceClass;

	if (outerClass == null && pkg != null) {
	t = new IdentifierToken(t.getWhere(),
	Identifier.lookup(pkg, t.getName()));
	}

	// The defaults for anonymous and local classes should be documented!

	if ((mod & M_ANONYMOUS) != 0) {
	mod \|= (M_FINAL \| M_PRIVATE);
	}
	if ((mod & M_LOCAL) != 0) {
	mod \|= M_PRIVATE;
	}

	// Certain modifiers are implied as follows:
	//
	// 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. (InnerClasses)
	// 3a. A type which is a member of an interface is implicitly deemed
	// to be public, whether it is explicitly marked so or not. (InnerClasses)
	// 3b. A type which is a member of an interface is implicitly deemed
	// to be static, whether it is explicitly marked so or not. (InnerClasses)

	if ((mod & M_INTERFACE) != 0) {
	// Rule 1.
	mod \|= M_ABSTRACT;
	if (outerClass != null) {
	// Rule 2.
	mod \|= M_STATIC;
	}
	}

	if (outerClass != null && outerClass.isInterface()) {
	// Rule 3a.
	// For interface members, neither 'private' nor 'protected'
	// are legal modifiers. We avoid setting M_PUBLIC in some
	// cases in order to avoid interfering with error detection
	// and reporting. This is patched up, after reporting an
	// error, by 'SourceClass.addMember'.
	if ((mod & (M_PRIVATE \| M_PROTECTED)) == 0)
	mod \|= M_PUBLIC;
	// Rule 3b.
	mod \|= M_STATIC;
	}

	// For nested classes, we must transform 'protected' to 'public'
	// and 'private' to package scope. This must be done later,
	// because any modifiers set here will be copied into the
	// 'MemberDefinition' for the nested class, which must represent
	// the original untransformed modifiers. Also, compile-time
	// checks should be performed against the actual, untransformed
	// modifiers. This is in contrast to transformations that implement
	// implicit modifiers, such as M_STATIC and M_FINAL for fields
	// of interfaces.

	sourceClass = (SourceClass)
	toplevelEnv.makeClassDefinition(toplevelEnv, where, t,
	doc, mod, sup,
	interfaces, outerClass);

	sourceClass.getClassDeclaration().setDefinition(sourceClass, CS_PARSED);
	env = new Environment(toplevelEnv, sourceClass);

	if (tracing) toplevelEnv.dtEvent("beginClass: SETTING UP DEPENDENCIES");

	// The code which adds artificial dependencies between
	// classes in the same source file has been moved to
	// BatchEnvironment#parseFile().

	if (tracing) toplevelEnv.dtEvent("beginClass: ADDING TO CLASS LIST");

	classes.addElement(sourceClass);

	if (tracing) toplevelEnv.dtExit("beginClass: " + sourceClass);

	return sourceClass;
	}

	/**
	* Report the current class under construction.
	*/
	public ClassDefinition getCurrentClass() {
	return sourceClass;
	}

	/**
	* End class
	*/
	public void endClass(long where, ClassDefinition c) {

	if (tracing) toplevelEnv.dtEnter("endClass: " + sourceClass);

	// c == sourceClass; don't bother to check
	sourceClass.setEndPosition(where);
	SourceClass outerClass = (SourceClass) sourceClass.getOuterClass();
	sourceClass = outerClass;
	env = toplevelEnv;
	if (sourceClass != null)
	env = new Environment(env, sourceClass);

	if (tracing) toplevelEnv.dtExit("endClass: " + sourceClass);
	}

	/**
	* Define a method
	*/
	public void defineField(long where, ClassDefinition c,
	String doc, int mod, Type t,
	IdentifierToken name, IdentifierToken args[],
	IdentifierToken exp[], Node val) {
	// c == sourceClass; don't bother to check
	Identifier nm = name.getName();
	// Members that are nested classes are not created with 'defineField',
	// so these transformations do not apply to them. See 'beginClass' above.
	if (sourceClass.isInterface()) {
	// Members of interfaces are implicitly public.
	if ((mod & (M_PRIVATE \| M_PROTECTED)) == 0)
	// For interface members, neither 'private' nor 'protected'
	// are legal modifiers. Avoid setting M_PUBLIC in some cases
	// to avoid interfering with later error detection. This will
	// be fixed up after the error is reported.
	mod \|= M_PUBLIC;
	// Methods of interfaces are implicitly abstract.
	// Fields of interfaces are implicitly static and final.
	if (t.isType(TC_METHOD)) {
	mod \|= M_ABSTRACT;
	} else {
	mod \|= M_STATIC \| M_FINAL;
	}
	}
	if (nm.equals(idInit)) {
	// The parser reports "idInit" when in reality it has found
	// that there is no method name at all present.
	// So, decide if it's really a constructor, or a syntax error.
	Type rt = t.getReturnType();
	Identifier retname = !rt.isType(TC_CLASS) ? idStar /no match/
	: rt.getClassName();
	Identifier clsname = sourceClass.getLocalName();
	if (clsname.equals(retname)) {
	t = Type.tMethod(Type.tVoid, t.getArgumentTypes());
	} else if (clsname.equals(retname.getFlatName().getName())) {
	// It appears to be a constructor with spurious qualification.
	t = Type.tMethod(Type.tVoid, t.getArgumentTypes());
	env.error(where, "invalid.method.decl.qual");
	} else if (retname.isQualified() \|\| retname.equals(idStar)) {
	// It appears to be a type name with no method name.
	env.error(where, "invalid.method.decl.name");
	return;
	} else {
	// We assume the type name is missing, even though the
	// simple name that's present might have been intended
	// to be a type: "String (){}" vs. "toString(){}".
	env.error(where, "invalid.method.decl");
	return;
	}
	}

	if (args == null && t.isType(TC_METHOD)) {
	args = new IdentifierToken[0];
	}

	if (exp == null && t.isType(TC_METHOD)) {
	exp = new IdentifierToken[0];
	}

	MemberDefinition f = env.makeMemberDefinition(env, where, sourceClass,
	doc, mod, t, nm,
	args, exp, val);
	if (env.dump()) {
	f.print(System.out);
	}
	}
	}

Back to index...