diff options
author | paltherr <paltherr@epfl.ch> | 2003-10-16 08:08:44 +0000 |
---|---|---|
committer | paltherr <paltherr@epfl.ch> | 2003-10-16 08:08:44 +0000 |
commit | a9b780036072b8aade4dde0cde77287915ffcc80 (patch) | |
tree | 75acc60bd40cc5253fc4a47fb372ec5532a095d8 /sources | |
parent | 79d406a6e924e5257230f5442e30df75642140aa (diff) | |
download | scala-a9b780036072b8aade4dde0cde77287915ffcc80.tar.gz scala-a9b780036072b8aade4dde0cde77287915ffcc80.tar.bz2 scala-a9b780036072b8aade4dde0cde77287915ffcc80.zip |
- Cleaned
Diffstat (limited to 'sources')
-rw-r--r-- | sources/scalac/transformer/Erasure.java | 176 |
1 files changed, 95 insertions, 81 deletions
diff --git a/sources/scalac/transformer/Erasure.java b/sources/scalac/transformer/Erasure.java index e9b9f3020b..5f4d1e47f6 100644 --- a/sources/scalac/transformer/Erasure.java +++ b/sources/scalac/transformer/Erasure.java @@ -47,6 +47,84 @@ import scalac.util.Debug; */ public class Erasure extends Transformer implements Modifiers { + //######################################################################## + // Private Constants + + private static final Type + UNBOXED_BOOLEAN = Type.unboxedType(TypeTags.BOOLEAN), + UNBOXED_BYTE = Type.unboxedType(TypeTags.BYTE), + UNBOXED_SHORT = Type.unboxedType(TypeTags.SHORT), + UNBOXED_CHAR = Type.unboxedType(TypeTags.CHAR), + UNBOXED_INT = Type.unboxedType(TypeTags.INT), + UNBOXED_LONG = Type.unboxedType(TypeTags.LONG), + UNBOXED_FLOAT = Type.unboxedType(TypeTags.FLOAT), + UNBOXED_DOUBLE = Type.unboxedType(TypeTags.DOUBLE); + + //######################################################################## + // Private Methods - Tree generation + + /** + * Generates a new unboxed array of given size and with elements + * of given type. + */ + private Tree genNewUnboxedArray(int pos, Type element, Tree size) { + switch (element) { + case UnboxedType(int kind): return genNewUnboxedArray(pos, kind, size); + } + if (global.target == global.TARGET_INT) { + global.nextPhase(); + while (!element.symbol().isJava()) element = element.parents()[0]; + global.prevPhase(); + } + String classname = primitives.getNameForClassForName(element); + return + gen.mkAsInstanceOf( + gen.mkApply_V( + gen.mkRef(pos, primitives.NEW_OARRAY), + new Tree[] { size, gen.mkStringLit(pos, classname) }), + Type.UnboxedArrayType(element)); + } + + /** + * Generates a new unboxed array of given size and with elements + * of given unboxed type kind. + */ + private Tree genNewUnboxedArray(int pos, int kind, Tree size) { + return + gen.mkApply_V( + gen.mkRef(pos, primitives.getNewArraySymbol(kind)), + new Tree[] {size}); + } + + /** Generates an unboxed array length operation. */ + private Tree genUnboxedArrayLength(int pos, Tree array) { + Symbol symbol = primitives.getArrayLengthSymbol(array.type()); + Tree[] args = new Tree[] { array }; + return gen.mkApply_V(gen.mkRef(pos, symbol), args); + } + + /** Generates an unboxed array get operation. */ + private Tree genUnboxedArrayGet(int pos, Tree array, Tree index) { + Symbol symbol = primitives.getArrayGetSymbol(array.type()); + index = coerce(index, UNBOXED_INT); + Tree[] args = new Tree[] { array, index }; + return gen.mkApply_V(gen.mkRef(pos, symbol), args); + } + + /** Generates an unboxed array set operation. */ + private Tree genUnboxedArraySet(int pos, Tree array,Tree index,Tree value){ + Symbol symbol = primitives.getArraySetSymbol(array.type()); + index = coerce(index, UNBOXED_INT); + // !!! value = coerce(value, <element type>); + Tree[] args = new Tree[] { array, index, value }; + return gen.mkApply_V(gen.mkRef(pos, symbol), args); + } + + //######################################################################## + //######################################################################## + //######################################################################## + //######################################################################## + private final Definitions definitions; private final Primitives primitives; @@ -446,13 +524,8 @@ public class Erasure extends Transformer implements Modifiers { case Apply(_, Tree[] args): args = transform(args); switch (owntype) { - case UnboxedArrayType(Type elemtp): - switch (elemtp) { - case UnboxedType(int kind): - return genNewArray(tree.pos,args[0],kind); - default: - return genNewArray(tree.pos,args[0],elemtp); - } + case UnboxedArrayType(Type element): + return genNewUnboxedArray(tree.pos, element, args[0]); default: throw Debug.abort("illegal case", owntype); } @@ -494,9 +567,21 @@ public class Erasure extends Transformer implements Modifiers { case Select(Tree array, _): if (isUnboxedArray(array.type().erasure())) { switch (primitives.getPrimitive(fun.symbol())) { - case LENGTH: return transformLength(tree); - case APPLY: return transformApply(tree); - case UPDATE: return transformUpdate(tree); + case LENGTH: + assert args.length == 0: tree; + array = transform(array); + return genUnboxedArrayLength(tree.pos, array); + case APPLY: + assert args.length == 1: tree; + array = transform(array); + Tree index = transform(args[0]); + return genUnboxedArrayGet(tree.pos, array, index); + case UPDATE: + assert args.length == 2: tree; + array = transform(array); + Tree index = transform(args[0]); + Tree value = transform(args[1]); + return genUnboxedArraySet(tree.pos,array,index,value); } } break; @@ -679,53 +764,6 @@ public class Erasure extends Transformer implements Modifiers { return exprs; } - /** Transform an array length */ - Tree transformLength(Tree tree) { - switch (tree) { - case Apply(Select(Tree array, _), Tree[] args): - assert args.length == 0 : Debug.show(args); - Type finalType = tree.type().erasure(); - array = transform(array); - Symbol symbol = primitives.getArrayLengthSymbol(array.type()); - Tree method = gen.mkRef(tree.pos,primitives.RUNTIME_TYPE,symbol); - args = new Tree[] { array }; - return coerce(gen.Apply(tree.pos, method, args), finalType); - default: - throw Debug.abort("illegal case", tree); - } - } - - /** Transform an array apply */ - Tree transformApply(Tree tree) { - switch (tree) { - case Apply(Select(Tree array, _), Tree[] args): - assert args.length == 1 : Debug.show(args); - Type finalType = tree.type().erasure(); - array = transform(array); - Symbol symbol = primitives.getArrayGetSymbol(array.type()); - Tree method = gen.mkRef(tree.pos,primitives.RUNTIME_TYPE,symbol); - args = new Tree[] { array, transform(args[0]) }; - return coerce(gen.Apply(tree.pos, method, args), finalType); - default: - throw Debug.abort("illegal case", tree); - } - } - - /** Transform an array update */ - Tree transformUpdate(Tree tree) { - switch (tree) { - case Apply(Select(Tree array, _), Tree[] args): - assert args.length == 2 : Debug.show(args); - array = transform(array); - Symbol symbol = primitives.getArraySetSymbol(array.type()); - Tree method = gen.mkRef(tree.pos,primitives.RUNTIME_TYPE,symbol); - args = new Tree[] { array, transform(args[0]),transform(args[1]) }; - return gen.Apply(tree.pos, method, args); - default: - throw Debug.abort("illegal case", tree); - } - } - private Tree getQualifier(Symbol currentClass, Tree tree) { switch (tree) { case Select(Tree qual, _): @@ -740,28 +778,4 @@ public class Erasure extends Transformer implements Modifiers { throw Debug.abort("no qualifier for tree", tree); } } - - private Tree genNewArray(int pos, Tree size, Type elemtp) { - if (global.target == global.TARGET_INT) { - global.nextPhase(); - while (!elemtp.symbol().isJava()) elemtp = elemtp.parents()[0]; - global.prevPhase(); - } - Tree classname = make.Literal(pos, - primitives.getNameForClassForName(elemtp)) - .setType(definitions.JAVA_STRING_TYPE); - Tree array = gen.Apply(pos, - gen.mkRef(pos, primitives.RUNTIME_TYPE, primitives.NEW_OARRAY), - new Tree[] {size, classname}); - Tree cast = gen.TypeApply(pos, gen.Select(pos, array, definitions.AS), - new Tree[] {gen.mkType(pos, Type.UnboxedArrayType(elemtp))}); - return gen.Apply(cast, new Tree[0]); - } - - private Tree genNewArray(int pos, Tree size, int kind) { - return gen.Apply(pos, - gen.mkRef(pos, - primitives.RUNTIME_TYPE, primitives.getNewArraySymbol(kind)), - new Tree[] {size}); - } } |