From ecf482f69ebb0b324322806b744d6e151618030e Mon Sep 17 00:00:00 2001 From: mihaylov Date: Wed, 3 May 2006 08:00:21 +0000 Subject: Added a 'cldc' target for J2ME CLDC 1.0 --- src/compiler/scala/tools/nsc/Global.scala | 2 + src/compiler/scala/tools/nsc/Settings.scala | 2 +- .../scala/tools/nsc/backend/ScalaPrimitives.scala | 113 +++++++++++---------- .../scala/tools/nsc/backend/icode/TypeKinds.scala | 6 +- .../scala/tools/nsc/backend/jvm/GenJVM.scala | 12 +-- .../scala/tools/nsc/symtab/Definitions.scala | 41 +++++--- .../scala/tools/nsc/symtab/SymbolTable.scala | 5 +- 7 files changed, 106 insertions(+), 75 deletions(-) (limited to 'src/compiler') diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala index 05cc3d15a4..9e94572c40 100644 --- a/src/compiler/scala/tools/nsc/Global.scala +++ b/src/compiler/scala/tools/nsc/Global.scala @@ -334,6 +334,8 @@ class Global(val settings: Settings, val reporter: Reporter) extends SymbolTable def onlyPresentation = settings.doc.value; + def forCLDC: Boolean = settings.target.value == "cldc" + class Run extends CompilerRun { var currentUnit: CompilationUnit = _; curRun = this; diff --git a/src/compiler/scala/tools/nsc/Settings.scala b/src/compiler/scala/tools/nsc/Settings.scala index 2ada1e9fca..6fc46319fd 100644 --- a/src/compiler/scala/tools/nsc/Settings.scala +++ b/src/compiler/scala/tools/nsc/Settings.scala @@ -82,7 +82,7 @@ class Settings(error: String => unit) { val encoding = StringSetting ("-encoding", "encoding", "Specify character encoding used by source files", encodingDefault) val windowtitle = StringSetting ("-windowtitle", "windowtitle", "Specify window title of generated HTML documentation", windowtitleDefault) val documenttitle = StringSetting ("-documenttitle", "documenttitle", "Specify document title of generated HTML documentation", documenttitleDefault) - val target = ChoiceSetting ("-target", "Specify which backend to use", List("jvm", "msil"), "jvm") + val target = ChoiceSetting ("-target", "Specify which backend to use", List("jvm", "msil", "cldc"), "jvm") val migrate = BooleanSetting("-migrate", "Assist in migrating from Scala version 1.0") val debug = BooleanSetting("-debug", "Output debugging messages") val statistics = BooleanSetting("-statistics", "Print compiler statistics") diff --git a/src/compiler/scala/tools/nsc/backend/ScalaPrimitives.scala b/src/compiler/scala/tools/nsc/backend/ScalaPrimitives.scala index 92078dda2c..0f57c17a1e 100644 --- a/src/compiler/scala/tools/nsc/backend/ScalaPrimitives.scala +++ b/src/compiler/scala/tools/nsc/backend/ScalaPrimitives.scala @@ -261,8 +261,10 @@ abstract class ScalaPrimitives { addPrimitives(ByteClass, nme.toChar, B2C); addPrimitives(ByteClass, nme.toInt, B2I); addPrimitives(ByteClass, nme.toLong, B2L); - addPrimitives(ByteClass, nme.toFloat, B2F); - addPrimitives(ByteClass, nme.toDouble, B2D); + if (!forCLDC) { + addPrimitives(ByteClass, nme.toFloat, B2F); + addPrimitives(ByteClass, nme.toDouble, B2D); + } // scala.Short addPrimitives(ShortClass, nme.EQ, EQ); @@ -289,8 +291,10 @@ abstract class ScalaPrimitives { addPrimitives(ShortClass, nme.toChar, S2C); addPrimitives(ShortClass, nme.toInt, S2I); addPrimitives(ShortClass, nme.toLong, S2L); - addPrimitives(ShortClass, nme.toFloat, S2F); - addPrimitives(ShortClass, nme.toDouble, S2D); + if (!forCLDC) { + addPrimitives(ShortClass, nme.toFloat, S2F); + addPrimitives(ShortClass, nme.toDouble, S2D); + } // scala.Char addPrimitives(CharClass, nme.EQ, EQ); @@ -317,8 +321,10 @@ abstract class ScalaPrimitives { addPrimitives(CharClass, nme.toChar, C2C); addPrimitives(CharClass, nme.toInt, C2I); addPrimitives(CharClass, nme.toLong, C2L); - addPrimitives(CharClass, nme.toFloat, C2F); - addPrimitives(CharClass, nme.toDouble, C2D); + if (!forCLDC) { + addPrimitives(CharClass, nme.toFloat, C2F); + addPrimitives(CharClass, nme.toDouble, C2D); + } // scala.Int addPrimitives(IntClass, nme.EQ, EQ); @@ -345,8 +351,10 @@ abstract class ScalaPrimitives { addPrimitives(IntClass, nme.toChar, I2C); addPrimitives(IntClass, nme.toInt, I2I); addPrimitives(IntClass, nme.toLong, I2L); - addPrimitives(IntClass, nme.toFloat, I2F); - addPrimitives(IntClass, nme.toDouble, I2D); + if (!forCLDC) { + addPrimitives(IntClass, nme.toFloat, I2F); + addPrimitives(IntClass, nme.toDouble, I2D); + } // scala.Long addPrimitives(LongClass, nme.EQ, EQ); @@ -373,51 +381,54 @@ abstract class ScalaPrimitives { addPrimitives(LongClass, nme.toChar, L2C); addPrimitives(LongClass, nme.toInt, L2I); addPrimitives(LongClass, nme.toLong, L2L); - addPrimitives(LongClass, nme.toFloat, L2F); - addPrimitives(LongClass, nme.toDouble, L2D); - - // scala.Float - addPrimitives(FloatClass, nme.EQ, EQ); - addPrimitives(FloatClass, nme.NE, NE); - addPrimitives(FloatClass, nme.ADD, ADD); - addPrimitives(FloatClass, nme.SUB, SUB); - addPrimitives(FloatClass, nme.MUL, MUL); - addPrimitives(FloatClass, nme.DIV, DIV); - addPrimitives(FloatClass, nme.MOD, MOD); - addPrimitives(FloatClass, nme.LT, LT); - addPrimitives(FloatClass, nme.LE, LE); - addPrimitives(FloatClass, nme.GT, GT); - addPrimitives(FloatClass, nme.GE, GE); + if (!forCLDC) { + addPrimitives(LongClass, nme.toFloat, L2F); + addPrimitives(LongClass, nme.toDouble, L2D); + } + + if (!forCLDC) { + // scala.Float + addPrimitives(FloatClass, nme.EQ, EQ); + addPrimitives(FloatClass, nme.NE, NE); + addPrimitives(FloatClass, nme.ADD, ADD); + addPrimitives(FloatClass, nme.SUB, SUB); + addPrimitives(FloatClass, nme.MUL, MUL); + addPrimitives(FloatClass, nme.DIV, DIV); + addPrimitives(FloatClass, nme.MOD, MOD); + addPrimitives(FloatClass, nme.LT, LT); + addPrimitives(FloatClass, nme.LE, LE); + addPrimitives(FloatClass, nme.GT, GT); + addPrimitives(FloatClass, nme.GE, GE); // conversions - addPrimitives(FloatClass, nme.toByte, F2B); - addPrimitives(FloatClass, nme.toShort, F2S); - addPrimitives(FloatClass, nme.toChar, F2C); - addPrimitives(FloatClass, nme.toInt, F2I); - addPrimitives(FloatClass, nme.toLong, F2L); - addPrimitives(FloatClass, nme.toFloat, F2F); - addPrimitives(FloatClass, nme.toDouble, F2D); - - // scala.Double - addPrimitives(DoubleClass, nme.EQ, EQ); - addPrimitives(DoubleClass, nme.NE, NE); - addPrimitives(DoubleClass, nme.ADD, ADD); - addPrimitives(DoubleClass, nme.SUB, SUB); - addPrimitives(DoubleClass, nme.MUL, MUL); - addPrimitives(DoubleClass, nme.DIV, DIV); - addPrimitives(DoubleClass, nme.MOD, MOD); - addPrimitives(DoubleClass, nme.LT, LT); - addPrimitives(DoubleClass, nme.LE, LE); - addPrimitives(DoubleClass, nme.GT, GT); - addPrimitives(DoubleClass, nme.GE, GE); + addPrimitives(FloatClass, nme.toByte, F2B); + addPrimitives(FloatClass, nme.toShort, F2S); + addPrimitives(FloatClass, nme.toChar, F2C); + addPrimitives(FloatClass, nme.toInt, F2I); + addPrimitives(FloatClass, nme.toLong, F2L); + addPrimitives(FloatClass, nme.toFloat, F2F); + addPrimitives(FloatClass, nme.toDouble, F2D); + + // scala.Double + addPrimitives(DoubleClass, nme.EQ, EQ); + addPrimitives(DoubleClass, nme.NE, NE); + addPrimitives(DoubleClass, nme.ADD, ADD); + addPrimitives(DoubleClass, nme.SUB, SUB); + addPrimitives(DoubleClass, nme.MUL, MUL); + addPrimitives(DoubleClass, nme.DIV, DIV); + addPrimitives(DoubleClass, nme.MOD, MOD); + addPrimitives(DoubleClass, nme.LT, LT); + addPrimitives(DoubleClass, nme.LE, LE); + addPrimitives(DoubleClass, nme.GT, GT); + addPrimitives(DoubleClass, nme.GE, GE); // conversions - addPrimitives(DoubleClass, nme.toByte, D2B); - addPrimitives(DoubleClass, nme.toShort, D2S); - addPrimitives(DoubleClass, nme.toChar, D2C); - addPrimitives(DoubleClass, nme.toInt, D2I); - addPrimitives(DoubleClass, nme.toLong, D2L); - addPrimitives(DoubleClass, nme.toFloat, D2F); - addPrimitives(DoubleClass, nme.toDouble, D2D); - + addPrimitives(DoubleClass, nme.toByte, D2B); + addPrimitives(DoubleClass, nme.toShort, D2S); + addPrimitives(DoubleClass, nme.toChar, D2C); + addPrimitives(DoubleClass, nme.toInt, D2I); + addPrimitives(DoubleClass, nme.toLong, D2L); + addPrimitives(DoubleClass, nme.toFloat, D2F); + addPrimitives(DoubleClass, nme.toDouble, D2D); + } // and the type map! initPrimitiveTypeMap; } diff --git a/src/compiler/scala/tools/nsc/backend/icode/TypeKinds.scala b/src/compiler/scala/tools/nsc/backend/icode/TypeKinds.scala index fc1048699b..c814fcc865 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/TypeKinds.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/TypeKinds.scala @@ -371,8 +371,10 @@ trait TypeKinds requires ICodes { primitiveTypeMap += definitions.CharClass -> CHAR; primitiveTypeMap += definitions.IntClass -> INT; primitiveTypeMap += definitions.LongClass -> LONG; - primitiveTypeMap += definitions.FloatClass -> FLOAT; - primitiveTypeMap += definitions.DoubleClass -> DOUBLE; + if (!forCLDC) { + primitiveTypeMap += definitions.FloatClass -> FLOAT; + primitiveTypeMap += definitions.DoubleClass -> DOUBLE; + } // primitiveTypeMap += definitions.StringClass -> STRING; } diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala index 3bc87c728b..979f94f75c 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala @@ -68,8 +68,8 @@ abstract class GenJVM extends SubComponent { val VolatileAttr = definitions.getClass("scala.volatile").tpe; val RemoteAttr = definitions.getClass("scala.remote").tpe; - val CloneableClass = definitions.getClass("java.lang.Cloneable"); - val RemoteInterface = definitions.getClass("java.rmi.Remote"); + val CloneableClass = if (forCLDC) null else definitions.getClass("java.lang.Cloneable"); + val RemoteInterface = if (forCLDC) null else definitions.getClass("java.rmi.Remote"); var clasz: IClass = _; var method: IMethod = _; @@ -123,13 +123,13 @@ abstract class GenJVM extends SubComponent { parents = definitions.ObjectClass.tpe :: parents; c.symbol.attributes foreach { a => a match { - case Pair(SerializableAttr, _) => + case Pair(SerializableAttr, _) if (!forCLDC) => parents = parents ::: List(definitions.SerializableClass.tpe); - case Pair(CloneableAttr, _) => + case Pair(CloneableAttr, _) if (!forCLDC) => parents = parents ::: List(CloneableClass.tpe); - case Pair(SerialVersionUID, value :: _) => + case Pair(SerialVersionUID, value :: _) if (!forCLDC) => serialVUID = Some(value.longValue); - case Pair(RemoteAttr, _) => + case Pair(RemoteAttr, _) if (!forCLDC) => parents = parents ::: List(RemoteInterface.tpe); remoteClass = true; case _ => (); diff --git a/src/compiler/scala/tools/nsc/symtab/Definitions.scala b/src/compiler/scala/tools/nsc/symtab/Definitions.scala index 8002abc431..443ccc509f 100644 --- a/src/compiler/scala/tools/nsc/symtab/Definitions.scala +++ b/src/compiler/scala/tools/nsc/symtab/Definitions.scala @@ -274,10 +274,12 @@ trait Definitions requires SymbolTable { val intparam = List(inttype) val longtype = LongClass.typeConstructor val longparam = List(longtype) - val floattype = FloatClass.typeConstructor - val floatparam = List(floattype) - val doubletype = DoubleClass.typeConstructor - val doubleparam = List(doubletype) + + val floattype = if (forCLDC) null else FloatClass.typeConstructor + val floatparam =if (forCLDC) null else List(floattype) + val doubletype = if (forCLDC) null else DoubleClass.typeConstructor + val doubleparam = if (forCLDC) null else List(doubletype) + val stringtype = StringClass.typeConstructor // init scala.Boolean @@ -291,6 +293,8 @@ trait Definitions requires SymbolTable { newMethod(BooleanClass, nme.XOR, boolparam, booltype); def initValueClass(clazz: Symbol, isCardinal: Boolean): Unit = { + assert (clazz != null) + def addBinops(params: List[Type], restype: Type, isCardinal: Boolean) = { newMethod(clazz, nme.EQ, params, booltype) newMethod(clazz, nme.NE, params, booltype) @@ -316,8 +320,11 @@ trait Definitions requires SymbolTable { newParameterlessMethod(clazz, nme.toChar, chartype) newParameterlessMethod(clazz, nme.toInt, inttype) newParameterlessMethod(clazz, nme.toLong, longtype) - newParameterlessMethod(clazz, nme.toFloat, floattype) - newParameterlessMethod(clazz, nme.toDouble, doubletype) + + if (!forCLDC) { + newParameterlessMethod(clazz, nme.toFloat, floattype) + newParameterlessMethod(clazz, nme.toDouble, doubletype) + } // def +(s: String): String newMethod(clazz, nme.ADD, List(stringtype), stringtype) @@ -347,14 +354,16 @@ trait Definitions requires SymbolTable { // binary operations val restype2 = if (isCardinal) longtype else restype - val restype3 = if (clazz eq DoubleClass) doubletype else floattype addBinops(byteparam, restype, isCardinal) addBinops(shortparam, restype, isCardinal) addBinops(charparam, restype, isCardinal) addBinops(intparam, restype, isCardinal) addBinops(longparam, restype2, isCardinal) - addBinops(floatparam, restype3, false) - addBinops(doubleparam, doubletype, false) + if (!forCLDC) { + val restype3 = if (clazz eq DoubleClass) doubletype else floattype + addBinops(floatparam, restype3, false) + addBinops(doubleparam, doubletype, false) + } } initValueClass(ByteClass, true) @@ -362,8 +371,10 @@ trait Definitions requires SymbolTable { initValueClass(CharClass, true) initValueClass(IntClass, true) initValueClass(LongClass, true) - initValueClass(FloatClass, false) - initValueClass(DoubleClass, false) + if (!forCLDC) { + initValueClass(FloatClass, false) + initValueClass(DoubleClass, false) + } } /** Is symbol a value class? */ @@ -448,8 +459,10 @@ trait Definitions requires SymbolTable { CharClass = newValueClass(nme.Char, 'C'); IntClass = newValueClass(nme.Int, 'I'); LongClass = newValueClass(nme.Long, 'L'); - FloatClass = newValueClass(nme.Float, 'F'); - DoubleClass = newValueClass(nme.Double, 'D'); + if (!forCLDC) { + FloatClass = newValueClass(nme.Float, 'F'); + DoubleClass = newValueClass(nme.Double, 'D'); + } // the scala reference classes ScalaObjectClass = getClass("scala.ScalaObject"); @@ -463,7 +476,7 @@ trait Definitions requires SymbolTable { SeqClass = getClass("scala.Seq"); ListClass = getClass("scala.List"); ArrayClass = getClass("scala.Array"); - SerializableClass = getClass("java.io.Serializable"); + SerializableClass = if (forCLDC) null else getClass("java.io.Serializable"); PredefModule = getModule("scala.Predef"); ConsoleModule = getModule("scala.Console"); MatchErrorClass = getClass("scala.MatchError"); diff --git a/src/compiler/scala/tools/nsc/symtab/SymbolTable.scala b/src/compiler/scala/tools/nsc/symtab/SymbolTable.scala index 85daf7b0b1..7481431e96 100644 --- a/src/compiler/scala/tools/nsc/symtab/SymbolTable.scala +++ b/src/compiler/scala/tools/nsc/symtab/SymbolTable.scala @@ -14,11 +14,14 @@ abstract class SymbolTable extends Names with Definitions with Constants with InfoTransformers - with StdNames { + with StdNames +{ def settings: Settings; def rootLoader: LazyType; def log(msg: Object): unit; + def forCLDC: Boolean; + private var ph: Phase = NoPhase; def phase: Phase = ph; def phase_=(p: Phase): unit = { -- cgit v1.2.3