Added a 'cldc' target for J2ME CLDC 1.0

7 files changed, 106 insertions, 75 deletions

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 = {