* adapted scalap to the new pickle format

* introduced -private option
* implemented filter for synthetic definitions

7 files changed, 107 insertions, 28 deletions

diff --git a/sources/scala/tools/scalap/ByteArrayReader.scala b/sources/scala/tools/scalap/ByteArrayReader.scala
index 5eac5a68bf..df9cdf2335 100644
--- a/sources/scala/tools/scalap/ByteArrayReader.scala
+++ b/sources/scala/tools/scalap/ByteArrayReader.scala
@@ -83,6 +83,19 @@ class ByteArrayReader(content: Array[Byte]) {
         x
     }
 
+    /** read the next signed number in big endian format
+     */
+    def nextNum(n: Int): Long = {
+    	var x: Long = 0;
+    	var i: Int = 0;
+    	while (i < n) {
+    	    x = (x << 8) + (nextByte & 0xff);
+    	    i = i + 1;
+    	}
+    	val leading: Int = 64 - (n * 8);
+	    x << leading >> leading;
+    }
+
     /** read an UTF8 encoded string
      */
     def nextUTF8(len: Int): String = {
diff --git a/sources/scala/tools/scalap/Entity.scala b/sources/scala/tools/scalap/Entity.scala
index 382668b75a..ad4960e9d0 100644
--- a/sources/scala/tools/scalap/Entity.scala
+++ b/sources/scala/tools/scalap/Entity.scala
@@ -18,6 +18,7 @@ trait Entity {
     def isText: Boolean = false;
     def isType: Boolean = false;
     def isSymbol: Boolean = false;
+    def isValue: Boolean = false;
     def toSource: String = toString();
 }
 
@@ -28,12 +29,19 @@ case class Text(str: String) extends Entity {
     override def toString(): String = str;
 }
 
+/** Value refers to a constant integer.
+ */
+case class Value(value: Long) extends Entity {
+    override def isValue: Boolean = true;
+    override def toString(): String = value.toString();
+}
+
 /** Types
  */
 trait Type extends Entity {
     override def isType: Boolean = true;
     override def toSource: String = {
-        val writer = new ScalaWriter(new StringWriter());
+        val writer = new ScalaWriter(null, new StringWriter());
         writer.setIndentString(null)*;
         writer.printType(this);
         writer.toString()
@@ -56,6 +64,8 @@ case class PolyType(tpe: Type, tvars: List[Symbol]) extends Type;
 
 case class OverloadedType(members: List[Symbol], tpes: List[Type]) extends Type;
 
+case class ConstantType(base: Type, value: Long) extends Type;
+
 case class TypeFlag(tpe: Type, flags: Int) extends Type;
 
 /** Symbols
diff --git a/sources/scala/tools/scalap/EntityTable.scala b/sources/scala/tools/scalap/EntityTable.scala
index a0fd9d1ad0..8e3b194c00 100644
--- a/sources/scala/tools/scalap/EntityTable.scala
+++ b/sources/scala/tools/scalap/EntityTable.scala
@@ -24,6 +24,7 @@ class EntityTable(attrib: ScalaAttribute) {
             table(i) = attrib.table(i) match {
                 case TermName(str) => Text(Names.decode(str));
                 case TypeName(str) => Text(Names.decode(str));
+                case Number(x) => Value(x);
                 case _ => null;
             }
             i = i + 1;
@@ -93,6 +94,10 @@ class EntityTable(attrib: ScalaAttribute) {
         case Text(str) => str;
     }
 
+    def getValue(i: Int): Long = table(i) match {
+        case Value(x) => x;
+    }
+
     def getSymbol(i: Int): Symbol =
         if (i < 0) NoSymbol else table(i).asInstanceOf[Symbol];
 
@@ -127,6 +132,8 @@ class EntityTable(attrib: ScalaAttribute) {
                         i => (table(i) != null) && table(i).isSymbol
                     }
                     OverloadedType(getSymbols(symIds), getTypes(typeIds))
+                case ConstantTypeRef(baseId, valId) =>
+                    ConstantType(getType(baseId), getValue(valId))
                 case FlaggedType(flags, typeId) =>
                     TypeFlag(getType(typeId), flags)
             }
diff --git a/sources/scala/tools/scalap/Flags.scala b/sources/scala/tools/scalap/Flags.scala
index 551ea23b96..aafd795a67 100644
--- a/sources/scala/tools/scalap/Flags.scala
+++ b/sources/scala/tools/scalap/Flags.scala
@@ -79,6 +79,8 @@ object Flags {
 
     def isCase(flags: Int): Boolean = (flags & CASE) != 0;
 
+	def isAccessor(flags: Int): Boolean = (flags & ACCESSOR) != 0;
+
     def isCaseAccessor(flags: Int): Boolean = (flags & CASEACCESSOR) != 0;
 
     def isInterface(flags: Int): Boolean = (flags & INTERFACE) != 0;
diff --git a/sources/scala/tools/scalap/Main.scala b/sources/scala/tools/scalap/Main.scala
index 9749f30d40..da928d9ebe 100644
--- a/sources/scala/tools/scalap/Main.scala
+++ b/sources/scala/tools/scalap/Main.scala
@@ -21,6 +21,7 @@ object Main {
     def usage: Unit = {
         Console.println("usage: scalap {<option>} <name>");
         Console.println("where <option> is");
+        Console.println("  -private               print private definitions");
         Console.println("  -verbose               print out additional information");
         Console.println("  -version               print out the version number of scalap");
         Console.println("  -help                  display this usage message");
@@ -28,7 +29,7 @@ object Main {
         Console.println("  -cp <pathlist>         specify where to find user class files");
     }
 
-    def process(path: ClassPath)(classname: String): Unit = {
+    def process(args: Arguments, path: ClassPath)(classname: String): Unit = {
 		val file = path.openClass(Names.encode(classname));
 		if (file.exists) {
 			if (verbose)
@@ -45,7 +46,7 @@ object Main {
 					//Console.println("read entities");
 					//symtab.print;
 					val out = new OutputStreamWriter(System.out);
-					val writer = new ScalaWriter(out);
+					val writer = new ScalaWriter(args, out);
 					symtab.root.elements foreach (
 						sym => { writer.printSymbol(sym);
 								 writer.println*; });
@@ -62,6 +63,7 @@ object Main {
             usage;
         else {
         	val arguments = Arguments.Parser('-')
+        	                         .withOption("-private")
         		                     .withOption("-verbose")
         		                     .withOption("-version")
         		                     .withOption("-help")
@@ -83,7 +85,7 @@ object Main {
             if (verbose)
             	Console.println(Console.BOLD + "CLASSPATH" + Console.RESET +
             	                " = " + path);
-           	arguments.getOthers.foreach(process(path));
+           	arguments.getOthers.foreach(process(arguments, path));
         }
     }
 }
diff --git a/sources/scala/tools/scalap/ScalaAttribute.scala b/sources/scala/tools/scalap/ScalaAttribute.scala
index 2e614b9cd5..faad3cc00f 100644
--- a/sources/scala/tools/scalap/ScalaAttribute.scala
+++ b/sources/scala/tools/scalap/ScalaAttribute.scala
@@ -13,6 +13,28 @@ import scala.collection.mutable._;
 
 class ScalaAttribute(in: ByteArrayReader) {
 
+    final val TERM_NAME = 1;
+    final val TYPE_NAME = 2;
+    final val NUMBER = 3;
+    final val NONE_SYM = 4;
+    final val TYPE_SYM = 5;
+    final val ALIAS_SYM = 6;
+    final val CLASS_SYM = 7;
+    final val VAL_SYM = 8;
+    final val EXT_REF = 9;
+    final val EXTMODCLASS_REF = 10;
+    final val NO_TYPE = 11;
+    final val THIS_TYPE = 12;
+    final val SINGLE_TYPE = 13;
+    final val CONSTANT_TYPE = 14;
+    final val REF_TYPE = 15;
+    final val COMPOUND_TYPE = 16;
+    final val METHOD_TYPE = 17;
+    final val POLY_TYPE = 18;
+    final val OVERLOADED_TYPE = 19;
+    final val FLAGGED_TYPE = 20;
+
+
     val table = readTable;
 
     def readTable: Array[AttribEntry] = {
@@ -31,41 +53,45 @@ class ScalaAttribute(in: ByteArrayReader) {
         //Console.println("" + tag + ": " + len);
         val end = in.bp + len;
         tag match {
-            case 1 /* TERMname */ =>
+            case TERM_NAME =>
                 TermName(in.nextUTF8(len))
-            case 2 /* TYPEname */ =>
+            case TYPE_NAME =>
                 TypeName(in.nextUTF8(len))
-            case 3 /* NONEsym */ =>
+            case NUMBER =>
+                Number(in.nextNum(len))
+            case NONE_SYM =>
                 NoneSym()
-            case 4 /* TYPEsym */ =>
+            case TYPE_SYM =>
                 TypeSym(readSymInfo, in.nextNat)
-            case 5 /* ALIASsym */ =>
+            case ALIAS_SYM =>
                 AliasSym(readSymInfo, in.nextNat)
-            case 6 /* CLASSsym */ =>
+            case CLASS_SYM =>
                 ClassSym(readSymInfo, in.nextNat, in.nextNat)
-            case 7 /* VALsym */ =>
+            case VAL_SYM =>
                 ValSym(readSymInfo, if (in.bp < end) in.nextNat else -1)
-            case 8 /* EXTref */ =>
+            case EXT_REF =>
                 ExtRef(false, in.nextNat, if (in.bp < end) in.nextNat else -1)
-            case 9 /* EXTMODCLASSref */ =>
+            case EXTMODCLASS_REF =>
                 ExtRef(true, in.nextNat, if (in.bp < end) in.nextNat else -1)
-            case 10 /* NOtpe */ =>
+            case NO_TYPE =>
                 NoneType()
-            case 11 /* THIStpe */ =>
+            case THIS_TYPE =>
                 SelfType(in.nextNat)
-            case 12 /* SINGLEtpe */ =>
+            case SINGLE_TYPE =>
                 SingleType(in.nextNat, in.nextNat)
-            case 13 /* TYPEREFtpe */ =>
+            case CONSTANT_TYPE =>
+                ConstantTypeRef(in.nextNat, in.nextNat)
+            case REF_TYPE =>
                 TypeReference(in.nextNat, in.nextNat, readRefs(end))
-            case 14 /* COMPOUNDtpe */ =>
+            case COMPOUND_TYPE =>
                 CompoundTypeRef(in.nextNat, readRefs(end))
-            case 15 /* METHODtpe */ =>
+            case METHOD_TYPE =>
                 MethodTypeRef(in.nextNat, readRefs(end))
-            case 16 /* POLYtpe */ =>
+            case POLY_TYPE =>
                 PolyTypeRef(in.nextNat, readRefs(end))
-            case 17 /* OVERLOADEDtpe */ =>
+            case OVERLOADED_TYPE =>
                 OverloadedTypeRef(readRefs(end))
-            case 20 /* FLAGGEDtpe */ =>
+            case FLAGGED_TYPE =>
                 FlaggedType(in.nextNat, in.nextNat)
         }
     }
@@ -83,6 +109,7 @@ class ScalaAttribute(in: ByteArrayReader) {
     class AttribEntry;
     case class TermName(name: String) extends AttribEntry;
     case class TypeName(name: String) extends AttribEntry;
+    case class Number(value: Long) extends AttribEntry;
     case class NoneSym() extends AttribEntry;
     case class TypeSym(info: SymbolInfo, lobound: Int) extends AttribEntry;
     case class AliasSym(info: SymbolInfo, constr: Int) extends AttribEntry;
@@ -97,6 +124,7 @@ class ScalaAttribute(in: ByteArrayReader) {
     case class MethodTypeRef(res: Int, args: List[Int]) extends AttribEntry;
     case class PolyTypeRef(tpe: Int, sym: List[Int]) extends AttribEntry;
     case class OverloadedTypeRef(symandtpe: List[Int]) extends AttribEntry;
+    case class ConstantTypeRef(baseref: Int, numref: Int) extends AttribEntry;
     case class FlaggedType(flags: Int, tpe: Int) extends AttribEntry;
 
     case class SymbolInfo(name: Int, owner: Int, flags: Int, info: Int);
diff --git a/sources/scala/tools/scalap/ScalaWriter.scala b/sources/scala/tools/scalap/ScalaWriter.scala
index fea7ac1245..58009682e9 100644
--- a/sources/scala/tools/scalap/ScalaWriter.scala
+++ b/sources/scala/tools/scalap/ScalaWriter.scala
@@ -12,7 +12,7 @@ import java.io._;
 import scala.collection.mutable._;
 
 
-class ScalaWriter(writer: Writer) extends CodeWriter(writer) {
+class ScalaWriter(args: Arguments, writer: Writer) extends CodeWriter(writer) {
 
     def printFlags(flags: Int): Unit = {
         val buffer = new StringBuffer();
@@ -98,6 +98,9 @@ class ScalaWriter(writer: Writer) extends CodeWriter(writer) {
             printType(tpe);
         case OverloadedType(_, tpes) =>
             printTypes(tpes, "", " <and> ", "");
+        case ConstantType(base, num) =>
+            printType(base);
+            print("(" + num + ")");
         case TypeFlag(TypeRef(_, _, List(tpe0)), flags) =>
             if ((flags & 8) != 0)
                 print("def ")*;
@@ -115,7 +118,8 @@ class ScalaWriter(writer: Writer) extends CodeWriter(writer) {
         case NoType =>
         case ThisType(NoSymbol) =>
         case ThisType(sym) =>
-            if (sym.name.length() != 0) {
+            if ((sym.name.length() != 0) &&
+                ("<root>" != sym.name)) {
                 printType0(tpe);
                 print(".")*
             }
@@ -174,15 +178,19 @@ class ScalaWriter(writer: Writer) extends CodeWriter(writer) {
         case s: ValSymbol =>
             s.tpe match {
                 case PolyType(tpe, Nil) =>
+                    print(Flags.toString(s.flags))*;
                     print("def " + s.name + ": ")*;
                     printType(tpe);
                 case PolyType(_, _) =>
+                    print(Flags.toString(s.flags))*;
                     print("def " + s.name)*;
                     printType(s.tpe);
                 case MethodType(_, _) =>
+                    print(Flags.toString(s.flags))*;
                     print("def " + s.name)*;
                     printType(s.tpe);
                 case _ =>
+                    print(Flags.toString(s.flags))*;
                     print("val " + s.name + ": ")*;
                     printType(s.tpe);
             }
@@ -207,6 +215,13 @@ class ScalaWriter(writer: Writer) extends CodeWriter(writer) {
             }
     }
 
+    def ignoreDef(s: Symbol) = {
+        (Flags.isPrivate(s.flags) &&
+         !((args != null) && (args contains "-private"))) ||
+        (s.name == "<init>") ||
+        Flags.isCaseAccessor(s.flags)
+    }
+
     def printScope(scope: Buffer[Symbol]): Unit = {
         var first = true;
         scope.elements foreach (
@@ -216,10 +231,12 @@ class ScalaWriter(writer: Writer) extends CodeWriter(writer) {
                              (Flags.isCaseAccessor(s.flags) &&
                               !s.tpe.isInstanceOf[PolyType])) =>
                          case _ =>
-                            if (first) print(" {").indent* else print(";")*;
-                            first = false;
-                            newline*;
-                            printSymbol(sym);
+                         	if (!ignoreDef(sym)) {
+								if (first) print(" {").indent* else print(";")*;
+								first = false;
+								newline*;
+								printSymbol(sym);
+							}
                      }});
         if (!first)
             newline.undent.print("}")*