/* ____ ____ ____ ____ ______ *\
** / __// __ \/ __// __ \/ ____/ SOcos COmpiles Scala **
** __\_ \/ /_/ / /__/ /_/ /\_ \ (c) 2002, LAMP/EPFL **
** /_____/\____/\___/\____/____/ **
\* */
// $Id$
package scalac.atree;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import scalac.Unit;
import scalac.ast.Tree;
import scalac.ast.Tree.Ident;
import scalac.ast.Tree.Template;
import scalac.symtab.Definitions;
import scalac.symtab.Symbol;
import scalac.symtab.TermSymbol;
import scalac.symtab.Type;
import scalac.util.Debug;
import scalac.util.Name;
/** This class translates syntax trees into attributed trees. */
public class ATreeFromSTree {
//########################################################################
// Private Fields
/** The global definitions */
private final Definitions definitions;
/** The attributed tree factory */
private final ATreeFactory make;
/** A mapping from primitive classes to initialization state */
private final Map/*<Symbol,Boolean>*/ states;
/** A mapping from primitive methods to generators */
private final Map/*<Symbol,Generator>*/ generators;
//########################################################################
// Public Constructors
/** Initializes this instance. */
public ATreeFromSTree(Definitions definitions) {
this.definitions = definitions;
this.make = new ATreeFactory();
this.states = new HashMap();
this.generators = new HashMap();
Symbol[] classes = {
definitions.ANY_CLASS,
definitions.JAVA_OBJECT_CLASS,
definitions.JAVA_STRING_CLASS,
definitions.JAVA_THROWABLE_CLASS,
definitions.ARRAY_CLASS,
definitions.UNIT_CLASS,
definitions.BOOLEAN_CLASS,
definitions.BYTE_CLASS,
definitions.SHORT_CLASS,
definitions.CHAR_CLASS,
definitions.INT_CLASS,
definitions.LONG_CLASS,
definitions.FLOAT_CLASS,
definitions.DOUBLE_CLASS,
};
for (int i = 0; i < classes.length; i++)
states.put(classes[i], Boolean.FALSE);
}
//########################################################################
// Public Methods - Translating units
/** Translates the unit's body and stores the result in it. */
public void translate(Unit unit) {
template(unit.repository = new ARepository(), unit.body);
}
//########################################################################
// Private Methods - Translating templates
/** Translates the templates and adds them to the repository. */
private void template(ARepository repository, Tree[] trees) {
for (int i = 0; i < trees.length; i++) template(repository, trees[i]);
}
/** Translates the template and adds it to the repository. */
private void template(ARepository repository, Tree tree) {
switch (tree) {
case Empty:
return;
case ClassDef(_, _, _, _, _, Template(_, Tree[] body)):
AClass clasz = new AClass(tree.symbol());
// !!! add static field to global modules
repository.addClass(clasz);
member(clasz, body);
return;
case PackageDef(_, Template(_, Tree[] body)):
template(repository, body);
return;
default:
throw Debug.abort("illegal case", tree);
}
}
//########################################################################
// Private Methods - Translating members
/** Translates the members and adds them to the class. */
private void member(AClass clasz, Tree[] trees) {
for (int i = 0; i < trees.length; i++) member(clasz, trees[i]);
}
/** Translates the member and adds it to the class. */
private void member(AClass clasz, Tree tree) {
switch (tree) {
case Empty:
return;
case ClassDef(_, _, _, _, _, _):
template(clasz, tree);
return;
case ValDef(_, _, _, Tree rhs):
AField field = new AField(tree.symbol(), false);
clasz.addField(field);
return;
case DefDef(_, _, _, _, _, Tree rhs):
AMethod method = new AMethod(tree.symbol(), false);
clasz.addMethod(method);
if (!method.isAbstract()) method.setCode(expression(rhs));
return;
default:
throw Debug.abort("illegal case", tree);
}
}
//########################################################################
// Private Methods - Translating statements
/** Translates the statements. */
private ACode[] statement(List locals, Tree[] trees, int start, int count){
List codes = new ArrayList();
for (int i = start; i < start + count; i++) {
ACode code = statement(locals, trees[i]);
if (code != ACode.Void) codes.add(code);
}
return (ACode[])codes.toArray(new ACode[codes.size()]);
}
/** Translates the statement. */
private ACode statement(List locals, Tree tree) {
switch (tree) {
case Empty:
return make.Void;
case ValDef(_, _, _, Tree rhs):
Symbol symbol = tree.symbol();
locals.add(symbol);
ALocation location = ALocation.Local(symbol, false);
return make.Store(tree, location, expression(rhs));
default:
return ACode.Drop(expression(tree), tree.type());
}
}
//########################################################################
// Private Methods - Translating expressions
/** Translates the expressions. */
private ACode[] expression(Tree[] trees) {
ACode[] codes = new ACode[trees.length];
for (int i = 0; i < codes.length; i++) codes[i] = expression(trees[i]);
return codes;
}
/** Translates the expression. */
private ACode expression(Tree tree) {
switch (tree) {
case LabelDef(_, Ident[] idents, Tree rhs):
Symbol[] locals = Tree.symbolOf(idents);
return make.Label(tree, tree.symbol(), locals, expression(rhs));
case Block(Tree[] statements):
if (statements.length == 0) return make.Void;
int statement_count = statements.length - 1;
List locals = new ArrayList();
ACode[] codes = statement(locals,statements,0, statement_count);
ACode value = expression(statements[statement_count]);
if (locals.size() == 0 && codes.length == 0) return value;
Symbol[] symbols =
(Symbol[])locals.toArray(new Symbol[locals.size()]);
return make.Block(tree, symbols, codes, value);
case Assign(Tree lhs, Tree rhs):
return make.Block(tree, Symbol.EMPTY_ARRAY, new ACode[] {
make.Store(tree, location(lhs), expression(rhs))},
make.Void);
case If(Tree cond, Tree thenp, Tree elsep):
ACode test = expression(cond);
return make.If(tree, test, expression(thenp), expression(elsep));
case Switch(Tree test, int[] tags, Tree[] bodies, Tree otherwise):
int[][] tagss = new int[tags.length][];
for (int i = 0; i < tagss.length; i++)
tagss[i] = new int[] {tags[i]};
ACode[] codes = new ACode[bodies.length + 1];
for (int i = 0; i < bodies.length; i++)
codes[i] = expression(bodies[i]);
codes[tags.length] = expression(otherwise);
return make.Switch(tree, expression(test), tagss, codes);
case Return(Tree value):
return make.Return(tree, tree.symbol(), expression(value));
case Throw(Tree value):
return make.Throw(tree, expression(value));
case New(Template(Tree[] bases, _)):
switch (bases[0]) {
case Apply(TypeApply(Tree fun, Tree[] targs), Tree[] vargs):
return apply(tree, method(fun), targs, vargs);
case Apply(Tree fun, Tree[] vargs):
return apply(tree, method(fun), Tree.EMPTY_ARRAY, vargs);
default:
throw Debug.abort("illegal case", bases[0]);
}
case Apply(TypeApply(Tree fun, Tree[] targs), Tree[] vargs):
return apply(tree, fun, targs, vargs);
case Apply(Tree fun, Tree[] vargs):
return apply(tree, fun, Tree.EMPTY_ARRAY, vargs);
case Super(_, _):
case This(_):
return make.This(tree, tree.symbol());
case Select(_, _):
case Ident(_):
return make.Load(tree, location(tree));
case Literal(AConstant value):
return make.Constant(tree, value);
default:
throw Debug.abort("illegal case", tree);
}
}
/** Translates the application. */
private ACode apply(Tree tree, Tree fun, Tree[] targs, Tree[] vargs) {
switch (fun) {
case Ident(_):
return make.Goto(tree, fun.symbol(), expression(vargs));
default:
return apply(tree, method(fun), targs, vargs);
}
}
/** Translates the application. */
private ACode apply(Tree tree, AFunction function,Tree[]targs,Tree[]vargs){
Type[] types = Tree.typeOf(targs);
switch (function) {
case Method(ACode object, Symbol method, AInvokeStyle style):
if (!style.isDynamic()) break;
Symbol clasz = method.owner();
Object state = states.get(clasz);
if (state == null) break;
if (state != Boolean.TRUE) addGeneratorsOf(clasz);
Object generator = generators.get(method);
if (generator == null) break;
return generate((Generator)generator, tree, object, types, vargs);
}
return make.Apply(tree, function, types, expression(vargs));
}
//########################################################################
// Private Methods - Translating functions
/** Translates the method. */
private AFunction method(Tree tree) {
Symbol symbol = tree.symbol();
switch (tree) {
case Select(Tree qualifier, _):
if (symbol.isJava() && symbol.owner().isModuleClass())
return AFunction.Method(make.Void, symbol, AInvokeStyle.StaticClass); // !!! qualifier is ignored !
ACode object = expression(qualifier);
return AFunction.Method(object, symbol, invokeStyle(qualifier));
case Ident(_):
return AFunction.Method(make.Void, symbol, AInvokeStyle.New);
default:
throw Debug.abort("illegal case", tree);
}
}
/** Returns the InvokeStyle to use for the qualifier. */
private AInvokeStyle invokeStyle(Tree qualifier) {
switch (qualifier) {
case Super(_, _):
return AInvokeStyle.StaticInstance;
default:
return AInvokeStyle.Dynamic;
}
}
//########################################################################
// Private Methods - Translating locations
/** Translates the location. */
private ALocation location(Tree tree) {
Symbol symbol = tree.symbol();
switch (tree) {
case Select(Tree qualifier, _):
if (symbol.isModule())
return ALocation.Module(symbol); // !!! qualifier is ignored !
if (symbol.isJava() && symbol.owner().isModuleClass())
return ALocation.Field(make.Void, symbol, true); // !!! qualifier is ignored !
return ALocation.Field(expression(qualifier), symbol, false);
case Ident(_):
if (symbol.isModule()) return ALocation.Module(symbol);
return ALocation.Local(symbol, symbol.isParameter());
default:
throw Debug.abort("illegal case", tree);
}
}
//########################################################################
// Private Methods - Translating constants
/** Translates the constant. */
private AConstant constant(Object value) {
if (value instanceof Boolean ) return make.BOOLEAN((Boolean )value);
if (value instanceof Byte ) return make.BYTE (((Byte )value));
if (value instanceof Short ) return make.SHORT ((Short )value);
if (value instanceof Character) return make.CHAR ((Character)value);
if (value instanceof Integer ) return make.INT ((Integer )value);
if (value instanceof Long ) return make.LONG ((Long )value);
if (value instanceof Float ) return make.FLOAT ((Float )value);
if (value instanceof Double ) return make.DOUBLE ((Double )value);
if (value instanceof String ) return make.STRING ((String )value);
throw Debug.abort("illegal constant", value +" -- "+ value.getClass());
}
//########################################################################
// Private Methods - Generating code for primitive methods
/** Applies generator to given object and arguments. */
private ACode generate(Generator generator, Tree tree, ACode object,
Type[] targs, Tree[] vargs)
{
switch (generator) {
case ANYID:
assert targs.length == 0 && vargs.length == 1: tree;
return make.EQ(tree, ATypeKind.REF, object, expression(vargs[0]));
case ANYEQ:
Symbol lf = newLocal(tree, definitions.ANY_TYPE());
Symbol rg = newLocal(tree, definitions.ANY_TYPE());
return make.Block(tree,
new Symbol[] {lf, rg},
new ACode[] {
store(tree, lf, object),
store(tree, rg, expression(vargs[0]))},
make.If(tree,
make.EQ(tree, ATypeKind.REF, load(tree, lf)),
make.EQ(tree, ATypeKind.REF, load(tree, rg)),
make.Apply(tree,
AFunction.Method(
load(tree, lf),
definitions.ANY_EQUALS,
AInvokeStyle.Dynamic),
Type.EMPTY_ARRAY,
new ACode[] {load(tree, rg)})));
case ANYNE:
Symbol lf = newLocal(tree, definitions.ANY_TYPE());
Symbol rg = newLocal(tree, definitions.ANY_TYPE());
return make.Block(tree,
new Symbol[] {lf, rg},
new ACode[] {
store(tree, lf, object),
store(tree, rg, expression(vargs[0]))},
make.If(tree,
make.EQ(tree, ATypeKind.REF, load(tree, lf)),
make.NE(tree, ATypeKind.REF, load(tree, rg)),
make.NOT(tree,
ATypeKind.BOOL,
make.Apply(tree,
AFunction.Method(
load(tree, lf),
definitions.ANY_EQUALS,
AInvokeStyle.Dynamic),
Type.EMPTY_ARRAY,
new ACode[] {load(tree, rg)}))));
case ISAS(boolean cast):
assert targs.length == 1 && vargs.length == 0: tree;
return make.IsAs(tree, object, targs[0], cast);
case SYNCHRONIZED:
assert targs.length == 1 && vargs.length == 1: tree;
return make.Synchronized(tree, object, expression(vargs[0]));
case THROW:
assert targs.length == 0 && vargs.length == 0: tree;
return make.Throw(tree, object);
case CONCAT(ATypeKind prefix):
assert targs.length == 0 && vargs.length == 1: tree;
ATypeKind suffix = kind(vargs[0].type());
ACode argument = expression(vargs[0]);
return make.CONCAT(tree, prefix, suffix, object, argument);
default:
throw Debug.abort("unknown case", generator);
}
}
/** Generates a load operation with given variable. */
private ACode load(Tree tree, Symbol local) {
assert local.owner().isNone(): Debug.show(local);
return make.Load(tree, ALocation.Local(local, false));
}
/** Generates a store operation with given variable and value. */
private ACode store(Tree tree, Symbol local, ACode value) {
assert local.owner().isNone(): Debug.show(local);
return make.Store(tree, ALocation.Local(local, false), value);
}
/** Creates a variable with tree's position and given type. */
private Symbol newLocal(Tree tree, Type type) {
Symbol owner = Symbol.NONE; // !!!
Name name = Name.fromString("local"); // !!!
return new TermSymbol(tree.pos, name, owner, 0).setType(type);
}
/** Returns the type kind of given type. */
private ATypeKind kind(Type type) {
switch (type) {
case SingleType(_, _):
case ConstantType(_, _):
return kind(type.singleDeref());
case TypeRef(_, Symbol clasz, _):
if (clasz == definitions.BOOLEAN_CLASS) return ATypeKind.BOOL;
if (clasz == definitions.BYTE_CLASS) return ATypeKind.I1;
if (clasz == definitions.SHORT_CLASS) return ATypeKind.I2;
if (clasz == definitions.CHAR_CLASS) return ATypeKind.U2;
if (clasz == definitions.INT_CLASS) return ATypeKind.I4;
if (clasz == definitions.LONG_CLASS) return ATypeKind.I8;
if (clasz == definitions.FLOAT_CLASS) return ATypeKind.R4;
if (clasz == definitions.DOUBLE_CLASS) return ATypeKind.R8;
if (clasz == definitions.JAVA_STRING_CLASS) return ATypeKind.STR;
return ATypeKind.REF;
default:
return ATypeKind.REF;
}
}
//########################################################################
// Private Methods - Collecting primitive methods
/** Associates generators to primitive methods of given class. */
private void addGeneratorsOf(Symbol clasz) {
if (clasz == definitions.ANY_CLASS) {
addGenerator(definitions.ANY_EQ, Generator.ANYID);
addGenerator(definitions.ANY_EQEQ, Generator.ANYEQ);
addGenerator(definitions.ANY_BANGEQ, Generator.ANYNE);
addGenerator(definitions.ANY_IS, Generator.ISAS(false));
addGenerator(definitions.ANY_AS, Generator.ISAS(true));
}
if (clasz == definitions.JAVA_OBJECT_CLASS) {
addGenerator(definitions.ANYREF_SYNCHRONIZED, Generator.SYNCHRONIZED);
}
if (clasz == definitions.JAVA_STRING_CLASS) {
addGenerator(definitions.JAVA_STRING_PLUS, Generator.CONCAT(ATypeKind.STR));
}
if (clasz == definitions.JAVA_THROWABLE_CLASS) {
addGenerator(definitions.JAVA_THROWABLE_THROW, Generator.THROW);
}
if (clasz == definitions.ARRAY_CLASS) {
// !!! addAll(defs.ARRAY_CLASS, Names.length, Primitive.LENGTH, 1);
// !!! addAll(defs.ARRAY_CLASS, Names.apply, Primitive.APPLY, 2);
// !!! addAll(defs.ARRAY_CLASS, Names.update, Primitive.UPDATE, 1);
}
if (clasz == definitions.UNIT_CLASS) {
// !!!
}
if (clasz == definitions.BOOLEAN_CLASS) {
// !!!
}
if (clasz == definitions.BYTE_CLASS) {
// !!!
}
if (clasz == definitions.SHORT_CLASS) {
// !!!
}
if (clasz == definitions.CHAR_CLASS) {
// !!!
}
if (clasz == definitions.INT_CLASS) {
// !!!
}
if (clasz == definitions.LONG_CLASS) {
// !!!
}
if (clasz == definitions.FLOAT_CLASS) {
// !!!
}
if (clasz == definitions.DOUBLE_CLASS) {
// !!!
}
states.put(clasz, Boolean.TRUE);
}
/** Associates given generator to given primitive method. */
private void addGenerator(Symbol method, Generator generator) {
generators.put(method, generator);
}
//########################################################################
// Private Class - Code generators
/** Code generators for primitive methods. */
private static class Generator {
case ANYID;
case ANYEQ;
case ANYNE;
case ISAS(boolean cast);
case SYNCHRONIZED;
case THROW;
case CONCAT(ATypeKind prefix);
}
//########################################################################
}
