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