Flags and Pickler related code, no review.

4 files changed, 1041 insertions, 0 deletions

diff --git a/src/compiler/scala/reflect/common/Flags.scala b/src/compiler/scala/reflect/common/Flags.scala
new file mode 100644
index 0000000000..756ea3077b
--- /dev/null
+++ b/src/compiler/scala/reflect/common/Flags.scala
@@ -0,0 +1,404 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2011 LAMP/EPFL
+ * @author  Martin Odersky
+ */
+
+package scala.reflect
+package common
+
+// Flags at each index of a flags Long.  Those marked with /M are used in
+// Parsers/JavaParsers and therefore definitely appear on Modifiers; but the
+// absence of /M on the other flags does not imply they aren't.
+//
+// Generated by mkFlagsTable() at Mon Oct 11 10:01:09 PDT 2010
+//
+//  0:     PROTECTED/M
+//  1:      OVERRIDE/M
+//  2:       PRIVATE/M
+//  3:      ABSTRACT/M
+//  4:      DEFERRED/M
+//  5:         FINAL/M
+//  6:          METHOD
+//  7:     INTERFACE/M
+//  8:          MODULE
+//  9:      IMPLICIT/M
+// 10:        SEALED/M
+// 11:          CASE/M
+// 12:       MUTABLE/M
+// 13:         PARAM/M
+// 14:         PACKAGE
+// 15:
+// 16:   BYNAMEPARAM/M      CAPTURED COVARIANT/M
+// 17: CONTRAVARIANT/M INCONSTRUCTOR       LABEL
+// 18:   ABSOVERRIDE/M
+// 19:         LOCAL/M
+// 20:          JAVA/M
+// 21:       SYNTHETIC
+// 22:          STABLE
+// 23:        STATIC/M
+// 24:  CASEACCESSOR/M
+// 25:  DEFAULTPARAM/M       TRAIT/M
+// 26:          BRIDGE
+// 27:        ACCESSOR
+// 28:   SUPERACCESSOR
+// 29: PARAMACCESSOR/M
+// 30:       MODULEVAR
+// 31:          LAZY/M
+// 32:        IS_ERROR
+// 33:      OVERLOADED
+// 34:          LIFTED
+// 35:     EXISTENTIAL       MIXEDIN
+// 36:    EXPANDEDNAME
+// 37:       IMPLCLASS    PRESUPER/M
+// 38:      TRANS_FLAG
+// 39:          LOCKED
+// 40:     SPECIALIZED
+// 41:   DEFAULTINIT/M
+// 42:         VBRIDGE
+// 43:         VARARGS
+// 44:
+// 45:
+// 46:
+// 47:
+// 48:
+// 49:     latePRIVATE
+// 50:    lateABSTRACT
+// 51:    lateDEFERRED
+// 52:       lateFINAL
+// 53:      lateMETHOD
+// 54:   lateINTERFACE
+// 55:      lateMODULE
+// 56:    notPROTECTED
+// 57:     notOVERRIDE
+// 58:      notPRIVATE
+// 59:     notABSTRACT
+// 60:     notDEFERRED
+// 61:        notFINAL
+// 62:       notMETHOD
+// 63:
+
+/** Flags set on Modifiers instances in the parsing stage.
+ */
+class ModifierFlags {
+  final val IMPLICIT      = 0x00000200
+  final val FINAL         = 0x00000020
+  final val PRIVATE       = 0x00000004
+  final val PROTECTED     = 0x00000001
+
+  final val SEALED        = 0x00000400
+  final val OVERRIDE      = 0x00000002
+  final val CASE          = 0x00000800
+  final val ABSTRACT      = 0x00000008    // abstract class, or used in conjunction with abstract override.
+                                          // Note difference to DEFERRED!
+  final val DEFERRED      = 0x00000010    // was `abstract' for members | trait is virtual
+  final val INTERFACE     = 0x00000080    // symbol is an interface (i.e. a trait which defines only abstract methods)
+  final val MUTABLE       = 0x00001000    // symbol is a mutable variable.
+  final val PARAM         = 0x00002000    // symbol is a (value or type) parameter to a method
+
+  final val COVARIANT     = 0x00010000    // symbol is a covariant type variable
+  final val BYNAMEPARAM   = 0x00010000    // parameter is by name
+  final val CONTRAVARIANT = 0x00020000    // symbol is a contravariant type variable
+  final val ABSOVERRIDE   = 0x00040000    // combination of abstract & override
+  final val LOCAL         = 0x00080000    // symbol is local to current class (i.e. private[this] or protected[this]
+                                          // pre: PRIVATE or PROTECTED are also set
+  final val JAVA          = 0x00100000    // symbol was defined by a Java class
+  final val STATIC        = 0x00800000    // static field, method or class
+  final val CASEACCESSOR  = 0x01000000    // symbol is a case parameter (or its accessor)
+  final val TRAIT         = 0x02000000    // symbol is a trait
+  final val DEFAULTPARAM  = 0x02000000    // the parameter has a default value
+  final val PARAMACCESSOR = 0x20000000    // for field definitions generated for primary constructor
+                                          //   parameters (no matter if it's a 'val' parameter or not)
+                                          // for parameters of a primary constructor ('val' or not)
+                                          // for the accessor methods generated for 'val' or 'var' parameters
+  final val LAZY          = 0x80000000L   // symbol is a lazy val. can't have MUTABLE unless transformed by typer
+  final val PRESUPER      = 0x2000000000L // value is evaluated before super call
+  final val DEFAULTINIT   = 0x20000000000L// symbol is initialized to the default value: used by -Xcheckinit
+
+  // Overridden.
+  def flagToString(flag: Long): String = ""
+}
+object ModifierFlags extends ModifierFlags
+
+/** All flags and associated operatins */
+class Flags extends ModifierFlags {
+  final val METHOD        = 0x00000040    // a method
+  final val MODULE        = 0x00000100    // symbol is module or class implementing a module
+  final val PACKAGE       = 0x00004000    // symbol is a java package
+
+  final val CAPTURED      = 0x00010000    // variable is accessed from nested function.  Set by LambdaLift.
+  final val LABEL         = 0x00020000    // method symbol is a label. Set by TailCall
+  final val INCONSTRUCTOR = 0x00020000    // class symbol is defined in this/superclass constructor.
+  final val SYNTHETIC     = 0x00200000    // symbol is compiler-generated
+  final val STABLE        = 0x00400000    // functions that are assumed to be stable
+                                          // (typically, access methods for valdefs)
+                                          // or classes that do not contain abstract types.
+  final val BRIDGE        = 0x04000000    // function is a bridge method. Set by Erasure
+  final val ACCESSOR      = 0x08000000    // a value or variable accessor (getter or setter)
+
+  final val SUPERACCESSOR = 0x10000000    // a super accessor
+  final val MODULEVAR     = 0x40000000    // for variables: is the variable caching a module value
+
+  final val IS_ERROR      = 0x100000000L  // symbol is an error symbol
+  final val OVERLOADED    = 0x200000000L  // symbol is overloaded
+  final val LIFTED        = 0x400000000L  // class has been lifted out to package level
+                                          // local value has been lifted out to class level
+                                          // todo: make LIFTED = latePRIVATE?
+  final val MIXEDIN       = 0x800000000L  // term member has been mixed in
+  final val EXISTENTIAL   = 0x800000000L  // type is an existential parameter or skolem
+  final val EXPANDEDNAME  = 0x1000000000L // name has been expanded with class suffix
+  final val IMPLCLASS     = 0x2000000000L // symbol is an implementation class
+  final val TRANS_FLAG    = 0x4000000000L // transient flag guaranteed to be reset after each phase.
+
+  final val LOCKED        = 0x8000000000L // temporary flag to catch cyclic dependencies
+  final val SPECIALIZED   = 0x10000000000L// symbol is a generated specialized member
+  final val VBRIDGE       = 0x40000000000L// symbol is a varargs bridge
+
+  final val VARARGS       = 0x80000000000L// symbol is a Java-style varargs method
+  final val TRIEDCOOKING  = 0x100000000000L // ``Cooking'' has been tried on this symbol
+                                            // A Java method's type is ``cooked'' by transforming raw types to existentials
+
+  // ------- shift definitions -------------------------------------------------------
+
+  final val InitialFlags  = 0x0001FFFFFFFFFFFFL // flags that are enabled from phase 1.
+  final val LateFlags     = 0x00FE000000000000L // flags that override flags in 0x1FC.
+  final val AntiFlags     = 0x7F00000000000000L // flags that cancel flags in 0x07F
+  final val LateShift     = 47L
+  final val AntiShift     = 56L
+
+  // ------- late flags (set by a transformer phase) ---------------------------------
+
+  final val latePRIVATE   = (PRIVATE: Long) << LateShift
+  final val lateABSTRACT  = (ABSTRACT: Long) << LateShift
+  final val lateDEFERRED  = (DEFERRED: Long) << LateShift
+  final val lateINTERFACE = (INTERFACE: Long) << LateShift
+  final val lateMODULE    = (MODULE: Long) << LateShift
+  final val lateFINAL     = (FINAL: Long) << LateShift
+  final val lateMETHOD    = (METHOD: Long) << LateShift
+
+  final val notFINAL      = (FINAL: Long) << AntiShift
+  final val notPRIVATE    = (PRIVATE: Long) << AntiShift
+  final val notDEFERRED   = (DEFERRED: Long) << AntiShift
+  final val notPROTECTED  = (PROTECTED: Long) << AntiShift
+  final val notABSTRACT   = (ABSTRACT: Long) << AntiShift
+  final val notOVERRIDE   = (OVERRIDE: Long) << AntiShift
+  final val notMETHOD     = (METHOD: Long) << AntiShift
+
+  final val notFlagMap = Map[Int, Long](
+    FINAL -> notFINAL,
+    PRIVATE -> notPRIVATE,
+    DEFERRED -> notDEFERRED,
+    PROTECTED -> notPROTECTED,
+    ABSTRACT -> notABSTRACT,
+    OVERRIDE -> notOVERRIDE,
+    METHOD -> notMETHOD
+  )
+
+  // ------- masks -----------------------------------------------------------------------
+
+  /** These flags can be set when class or module symbol is first created. */
+  final val TopLevelCreationFlags: Long =
+    MODULE | PACKAGE | FINAL | JAVA
+
+  /** These modifiers can be set explicitly in source programs. */
+  final val ExplicitFlags: Long =
+    PRIVATE | PROTECTED | ABSTRACT | FINAL | SEALED |
+    OVERRIDE | CASE | IMPLICIT | ABSOVERRIDE | LAZY
+
+  /** These modifiers appear in TreePrinter output. */
+  final val PrintableFlags: Long =
+    ExplicitFlags | LOCAL | SYNTHETIC | STABLE | CASEACCESSOR |
+    ACCESSOR | SUPERACCESSOR | PARAMACCESSOR | BRIDGE | STATIC | VBRIDGE | SPECIALIZED
+
+  /** The two bridge flags */
+  final val BRIDGES = BRIDGE | VBRIDGE
+
+  final val FieldFlags: Long =
+    MUTABLE | CASEACCESSOR | PARAMACCESSOR | STATIC | FINAL | PRESUPER | LAZY
+
+  final val AccessFlags: Long   = PRIVATE | PROTECTED | LOCAL
+  final val VarianceFlags       = COVARIANT | CONTRAVARIANT
+  final val ConstrFlags: Long   = JAVA
+
+  /** Module flags inherited by their module-class */
+  final val ModuleToClassFlags: Long = AccessFlags | MODULE | PACKAGE | CASE | SYNTHETIC | JAVA
+
+  def getterFlags(fieldFlags: Long): Long = ACCESSOR + (
+    if ((fieldFlags & MUTABLE) != 0) fieldFlags & ~MUTABLE & ~PRESUPER
+    else fieldFlags & ~PRESUPER | STABLE
+  )
+
+  def setterFlags(fieldFlags: Long): Long =
+    getterFlags(fieldFlags) & ~STABLE & ~CASEACCESSOR
+
+ // ------- pickling and unpickling of flags -----------------------------------------------
+
+  // The flags from 0x001 to 0x800 are different in the raw flags
+  // and in the pickled format.
+
+  private final val IMPLICIT_PKL   = (1 << 0)
+  private final val FINAL_PKL      = (1 << 1)
+  private final val PRIVATE_PKL    = (1 << 2)
+  private final val PROTECTED_PKL  = (1 << 3)
+  private final val SEALED_PKL     = (1 << 4)
+  private final val OVERRIDE_PKL   = (1 << 5)
+  private final val CASE_PKL       = (1 << 6)
+  private final val ABSTRACT_PKL   = (1 << 7)
+  private final val DEFERRED_PKL   = (1 << 8)
+  private final val METHOD_PKL     = (1 << 9)
+  private final val MODULE_PKL     = (1 << 10)
+  private final val INTERFACE_PKL  = (1 << 11)
+
+  private final val PKL_MASK       = 0x00000FFF
+
+  private def rawPickledCorrespondence = Array(
+    (IMPLICIT, IMPLICIT_PKL),
+    (FINAL, FINAL_PKL),
+    (PRIVATE, PRIVATE_PKL),
+    (PROTECTED, PROTECTED_PKL),
+    (SEALED, SEALED_PKL),
+    (OVERRIDE, OVERRIDE_PKL),
+    (CASE, CASE_PKL),
+    (ABSTRACT, ABSTRACT_PKL),
+    (DEFERRED, DEFERRED_PKL),
+    (METHOD, METHOD_PKL),
+    (MODULE, MODULE_PKL),
+    (INTERFACE, INTERFACE_PKL)
+  )
+  private val rawFlags: Array[Int]     = rawPickledCorrespondence map (_._1)
+  private val pickledFlags: Array[Int] = rawPickledCorrespondence map (_._2)
+
+  private def r2p(flags: Int): Int = {
+    var result = 0
+    var i      = 0
+    while (i < rawFlags.length) {
+      if ((flags & rawFlags(i)) != 0)
+        result |= pickledFlags(i)
+
+      i += 1
+    }
+    result
+  }
+  private def p2r(flags: Int): Int = {
+    var result = 0
+    var i      = 0
+    while (i < rawFlags.length) {
+      if ((flags & pickledFlags(i)) != 0)
+        result |= rawFlags(i)
+
+      i += 1
+    }
+    result
+  }
+
+  // ------ displaying flags --------------------------------------------------------
+
+  // Generated by mkFlagToStringMethod() at Mon Oct 11 10:12:36 PDT 2010
+  @annotation.switch override def flagToString(flag: Long): String = flag match {
+    case           PROTECTED => "protected"                           // (1L << 0)
+    case            OVERRIDE => "override"                            // (1L << 1)
+    case             PRIVATE => "private"                             // (1L << 2)
+    case            ABSTRACT => "abstract"                            // (1L << 3)
+    case            DEFERRED => "<deferred>"                          // (1L << 4)
+    case               FINAL => "final"                               // (1L << 5)
+    case              METHOD => "<method>"                            // (1L << 6)
+    case           INTERFACE => "<interface>"                         // (1L << 7)
+    case              MODULE => "<module>"                            // (1L << 8)
+    case            IMPLICIT => "implicit"                            // (1L << 9)
+    case              SEALED => "sealed"                              // (1L << 10)
+    case                CASE => "case"                                // (1L << 11)
+    case             MUTABLE => "<mutable>"                           // (1L << 12)
+    case               PARAM => "<param>"                             // (1L << 13)
+    case             PACKAGE => "<package>"                           // (1L << 14)
+    case             0x8000L => ""                                    // (1L << 15)
+    case         BYNAMEPARAM => "<bynameparam/captured/covariant>"    // (1L << 16)
+    case       CONTRAVARIANT => "<contravariant/inconstructor/label>" // (1L << 17)
+    case         ABSOVERRIDE => "absoverride"                         // (1L << 18)
+    case               LOCAL => "<local>"                             // (1L << 19)
+    case                JAVA => "<java>"                              // (1L << 20)
+    case           SYNTHETIC => "<synthetic>"                         // (1L << 21)
+    case              STABLE => "<stable>"                            // (1L << 22)
+    case              STATIC => "<static>"                            // (1L << 23)
+    case        CASEACCESSOR => "<caseaccessor>"                      // (1L << 24)
+    case        DEFAULTPARAM => "<defaultparam/trait>"                // (1L << 25)
+    case              BRIDGE => "<bridge>"                            // (1L << 26)
+    case            ACCESSOR => "<accessor>"                          // (1L << 27)
+    case       SUPERACCESSOR => "<superaccessor>"                     // (1L << 28)
+    case       PARAMACCESSOR => "<paramaccessor>"                     // (1L << 29)
+    case           MODULEVAR => "<modulevar>"                         // (1L << 30)
+    case                LAZY => "lazy"                                // (1L << 31)
+    case            IS_ERROR => "<is_error>"                          // (1L << 32)
+    case          OVERLOADED => "<overloaded>"                        // (1L << 33)
+    case              LIFTED => "<lifted>"                            // (1L << 34)
+    case         EXISTENTIAL => "<existential/mixedin>"               // (1L << 35)
+    case        EXPANDEDNAME => "<expandedname>"                      // (1L << 36)
+    case           IMPLCLASS => "<implclass/presuper>"                // (1L << 37)
+    case          TRANS_FLAG => "<trans_flag>"                        // (1L << 38)
+    case              LOCKED => "<locked>"                            // (1L << 39)
+    case         SPECIALIZED => "<specialized>"                       // (1L << 40)
+    case         DEFAULTINIT => "<defaultinit>"                       // (1L << 41)
+    case             VBRIDGE => "<vbridge>"                           // (1L << 42)
+    case             VARARGS => "<varargs>"                           // (1L << 43)
+    case     0x100000000000L => ""                                    // (1L << 44)
+    case     0x200000000000L => ""                                    // (1L << 45)
+    case     0x400000000000L => ""                                    // (1L << 46)
+    case     0x800000000000L => ""                                    // (1L << 47)
+    case    0x1000000000000L => ""                                    // (1L << 48)
+    case       `latePRIVATE` => "<lateprivate>"                       // (1L << 49)
+    case      `lateABSTRACT` => "<lateabstract>"                      // (1L << 50)
+    case      `lateDEFERRED` => "<latedeferred>"                      // (1L << 51)
+    case         `lateFINAL` => "<latefinal>"                         // (1L << 52)
+    case        `lateMETHOD` => "<latemethod>"                        // (1L << 53)
+    case     `lateINTERFACE` => "<lateinterface>"                     // (1L << 54)
+    case        `lateMODULE` => "<latemodule>"                        // (1L << 55)
+    case      `notPROTECTED` => "<notprotected>"                      // (1L << 56)
+    case       `notOVERRIDE` => "<notoverride>"                       // (1L << 57)
+    case        `notPRIVATE` => "<notprivate>"                        // (1L << 58)
+    case       `notABSTRACT` => "<notabstract>"                       // (1L << 59)
+    case       `notDEFERRED` => "<notdeferred>"                       // (1L << 60)
+    case          `notFINAL` => "<notfinal>"                          // (1L << 61)
+    case         `notMETHOD` => "<notmethod>"                         // (1L << 62)
+    case 0x8000000000000000L => ""                                    // (1L << 63)
+    case _ => ""
+  }
+
+  def flagsToString(flags: Long, privateWithin: String): String = {
+    var f = flags
+    val pw =
+      if (privateWithin == "") {
+        if ((flags & (PRIVATE | LOCAL)) == (PRIVATE | LOCAL).toLong) {
+          f = f & ~(PRIVATE | LOCAL)
+          "private[this]"
+        } else if ((flags & (PROTECTED | LOCAL)) == (PROTECTED | LOCAL).toLong) {
+          f = f & ~(PROTECTED | LOCAL)
+          "protected[this]"
+        } else {
+          ""
+        }
+      } else if ((f & PROTECTED) != 0L) {
+        f = f & ~PROTECTED
+        "protected[" + privateWithin + "]"
+      } else {
+        "private[" + privateWithin + "]"
+      }
+    List(flagsToString(f), pw) filterNot (_ == "") mkString " "
+  }
+
+  def flagsToString(flags: Long): String =
+    pickledListOrder map (mask => flagToString(flags & mask)) filterNot (_ == "") mkString " "
+
+  def rawFlagsToPickled(flags: Long): Long =
+    (flags & ~PKL_MASK) | r2p(flags.toInt & PKL_MASK)
+
+  def pickledToRawFlags(pflags: Long): Long =
+    (pflags & ~PKL_MASK) | p2r(pflags.toInt & PKL_MASK)
+
+  // List of the raw flags, in pickled order
+  protected val pickledListOrder: List[Long] = {
+    val all   = 0 to 62 map (1L << _)
+    val front = rawFlags map (_.toLong)
+
+    front.toList ++ (all filterNot (front contains _))
+  }
+}
+
+object Flags extends Flags { }
diff --git a/src/compiler/scala/reflect/common/pickling/ByteCodecs.scala b/src/compiler/scala/reflect/common/pickling/ByteCodecs.scala
new file mode 100644
index 0000000000..57d5eb63e8
--- /dev/null
+++ b/src/compiler/scala/reflect/common/pickling/ByteCodecs.scala
@@ -0,0 +1,224 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2007-2011, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+package scala.reflect.common.pickling
+
+object ByteCodecs {
+
+  def avoidZero(src: Array[Byte]): Array[Byte] = {
+    var i = 0
+    val srclen = src.length
+    var count = 0
+    while (i < srclen) {
+      if (src(i) == 0x7f) count += 1
+      i += 1
+    }
+    val dst = new Array[Byte](srclen + count)
+    i = 0
+    var j = 0
+    while (i < srclen) {
+      val in = src(i)
+      if (in == 0x7f) {
+        dst(j) = (0xc0).toByte
+        dst(j + 1) = (0x80).toByte
+        j += 2
+      } else {
+        dst(j) = (in + 1).toByte
+        j += 1
+      }
+      i += 1
+    }
+    dst
+  }
+
+  def regenerateZero(src: Array[Byte]): Int = {
+    var i = 0
+    val srclen = src.length
+    var j = 0
+    while (i < srclen) {
+      val in: Int = src(i) & 0xff
+      if (in == 0xc0 && (src(i + 1) & 0xff) == 0x80) {
+        src(j) = 0x7f
+        i += 2
+      } else {
+        src(j) = (in - 1).toByte
+        i += 1
+      }
+      j += 1
+    }
+    j
+  }
+
+  def encode8to7(src: Array[Byte]): Array[Byte] = {
+    val srclen = src.length
+    val dstlen = (srclen * 8 + 6) / 7
+    val dst = new Array[Byte](dstlen)
+    var i = 0
+    var j = 0
+    while (i + 6 < srclen) {
+      var in: Int = src(i) & 0xff
+      dst(j) = (in & 0x7f).toByte
+      var out: Int = in >>> 7
+      in = src(i + 1) & 0xff
+      dst(j + 1) = (out | (in << 1) & 0x7f).toByte
+      out = in >>> 6
+      in = src(i + 2) & 0xff
+      dst(j + 2) = (out | (in << 2) & 0x7f).toByte
+      out = in >>> 5
+      in = src(i + 3) & 0xff
+      dst(j + 3) = (out | (in << 3) & 0x7f).toByte
+      out = in >>> 4
+      in = src(i + 4) & 0xff
+      dst(j + 4) = (out | (in << 4) & 0x7f).toByte
+      out = in >>> 3
+      in = src(i + 5) & 0xff
+      dst(j + 5) = (out | (in << 5) & 0x7f).toByte
+      out = in >>> 2
+      in = src(i + 6) & 0xff
+      dst(j + 6) = (out | (in << 6) & 0x7f).toByte
+      out = in >>> 1
+      dst(j + 7) = out.toByte
+      i += 7
+      j += 8
+    }
+    if (i < srclen) {
+      var in: Int = src(i) & 0xff
+      dst(j) = (in & 0x7f).toByte; j += 1
+      var out: Int = in >>> 7
+      if (i + 1 < srclen) {
+        in = src(i + 1) & 0xff
+        dst(j) = (out | (in << 1) & 0x7f).toByte; j += 1
+        out = in >>> 6
+        if (i + 2 < srclen) {
+          in = src(i + 2) & 0xff
+          dst(j) = (out | (in << 2) & 0x7f).toByte; j += 1
+          out = in >>> 5
+          if (i + 3 < srclen) {
+            in = src(i + 3) & 0xff
+            dst(j) = (out | (in << 3) & 0x7f).toByte; j += 1
+            out = in >>> 4
+            if (i + 4 < srclen) {
+              in = src(i + 4) & 0xff
+              dst(j) = (out | (in << 4) & 0x7f).toByte; j += 1
+              out = in >>> 3
+              if (i + 5 < srclen) {
+                in = src(i + 5) & 0xff
+                dst(j) = (out | (in << 5) & 0x7f).toByte; j += 1
+                out = in >>> 2
+              }
+            }
+          }
+        }
+      }
+      if (j < dstlen) dst(j) = out.toByte
+    }
+    dst
+  }
+
+  @deprecated("use 2-argument version instead", "2.8.0")
+  def decode7to8(src: Array[Byte], srclen: Int, dstlen: Int) { decode7to8(src, srclen) }
+
+  def decode7to8(src: Array[Byte], srclen: Int): Int = {
+    var i = 0
+    var j = 0
+    val dstlen = (srclen * 7 + 7) / 8
+    while (i + 7 < srclen) {
+      var out: Int = src(i)
+      var in: Byte = src(i + 1)
+      src(j) = (out | (in & 0x01) << 7).toByte
+      out = in >>> 1
+      in = src(i + 2)
+      src(j + 1) = (out | (in & 0x03) << 6).toByte
+      out = in >>> 2
+      in = src(i + 3)
+      src(j + 2) = (out | (in & 0x07) << 5).toByte
+      out = in >>> 3
+      in = src(i + 4)
+      src(j + 3) = (out | (in & 0x0f) << 4).toByte
+      out = in >>> 4
+      in = src(i + 5)
+      src(j + 4) = (out | (in & 0x1f) << 3).toByte
+      out = in >>> 5
+      in = src(i + 6)
+      src(j + 5) = (out | (in & 0x3f) << 2).toByte
+      out = in >>> 6
+      in = src(i + 7)
+      src(j + 6) = (out | in << 1).toByte
+      i += 8
+      j += 7
+    }
+    if (i < srclen) {
+      var out: Int = src(i)
+      if (i + 1 < srclen) {
+        var in: Byte = src(i + 1)
+        src(j) = (out | (in & 0x01) << 7).toByte; j += 1
+        out = in >>> 1
+        if (i + 2 < srclen) {
+          in = src(i + 2)
+          src(j) = (out | (in & 0x03) << 6).toByte; j += 1
+          out = in >>> 2
+          if (i + 3 < srclen) {
+            in = src(i + 3)
+            src(j) = (out | (in & 0x07) << 5).toByte; j += 1
+            out = in >>> 3
+            if (i + 4 < srclen) {
+              in = src(i + 4)
+              src(j) = (out | (in & 0x0f) << 4).toByte; j += 1
+              out = in >>> 4
+              if (i + 5 < srclen) {
+                in = src(i + 5)
+                src(j) = (out | (in & 0x1f) << 3).toByte; j += 1
+                out = in >>> 5
+                if (i + 6 < srclen) {
+                  in = src(i + 6)
+                  src(j) = (out | (in & 0x3f) << 2).toByte; j += 1
+                  out = in >>> 6
+                }
+              }
+            }
+          }
+        }
+      }
+      if (j < dstlen) src(j) = out.toByte
+    }
+    dstlen
+  }
+
+  def encode(xs: Array[Byte]): Array[Byte] = avoidZero(encode8to7(xs))
+
+  @deprecated("use 1-argument version instead", "2.8.0")
+  def decode(xs: Array[Byte], dstlen: Int) { decode(xs) }
+
+  /**
+   * Destructively decodes array xs and returns the length of the decoded array.
+   *
+   * Sometimes returns (length+1) of the decoded array. Example:
+   *
+   *   scala> val enc = reflect.generic.ByteCodecs.encode(Array(1,2,3))
+   *   enc: Array[Byte] = Array(2, 5, 13, 1)
+   *
+   *   scala> reflect.generic.ByteCodecs.decode(enc)
+   *   res43: Int = 4
+   *
+   *   scala> enc
+   *   res44: Array[Byte] = Array(1, 2, 3, 0)
+   *
+   * However, this does not always happen.
+   */
+  def decode(xs: Array[Byte]): Int = {
+    val len = regenerateZero(xs)
+    decode7to8(xs, len)
+  }
+}
+
+
+
+
+
+
+
+
diff --git a/src/compiler/scala/reflect/common/pickling/PickleBuffer.scala b/src/compiler/scala/reflect/common/pickling/PickleBuffer.scala
new file mode 100644
index 0000000000..4ce83bea10
--- /dev/null
+++ b/src/compiler/scala/reflect/common/pickling/PickleBuffer.scala
@@ -0,0 +1,188 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2011 LAMP/EPFL
+ * @author  Martin Odersky
+ */
+
+package scala.reflect
+package common
+package pickling
+
+/** Variable length byte arrays, with methods for basic pickling and unpickling.
+ *
+ *  @param data The initial buffer
+ *  @param from The first index where defined data are found
+ *  @param to   The first index where new data can be written
+ */
+class PickleBuffer(data: Array[Byte], from: Int, to: Int) {
+
+  var bytes = data
+  var readIndex = from
+  var writeIndex = to
+
+  /** Double bytes array */
+  private def dble() {
+    val bytes1 = new Array[Byte](bytes.length * 2)
+    Array.copy(bytes, 0, bytes1, 0, writeIndex)
+    bytes = bytes1
+  }
+
+  def ensureCapacity(capacity: Int) =
+    while (bytes.length < writeIndex + capacity) dble()
+
+  // -- Basic output routines --------------------------------------------
+
+  /** Write a byte of data */
+  def writeByte(b: Int) {
+    if (writeIndex == bytes.length) dble()
+    bytes(writeIndex) = b.toByte
+    writeIndex += 1
+  }
+
+  /** Write a natural number in big endian format, base 128.
+   *  All but the last digits have bit 0x80 set.
+   */
+  def writeNat(x: Int) =
+    writeLongNat(x.toLong & 0x00000000FFFFFFFFL)
+
+  /**
+   * Like writeNat, but for longs. This is not the same as
+   * writeLong, which writes in base 256. Note that the
+   * binary representation of LongNat is identical to Nat
+   * if the long value is in the range Int.MIN_VALUE to
+   * Int.MAX_VALUE.
+   */
+  def writeLongNat(x: Long) {
+    def writeNatPrefix(x: Long) {
+      val y = x >>> 7
+      if (y != 0L) writeNatPrefix(y)
+      writeByte(((x & 0x7f) | 0x80).toInt)
+    }
+    val y = x >>> 7
+    if (y != 0L) writeNatPrefix(y)
+    writeByte((x & 0x7f).toInt)
+  }
+
+  /** Write a natural number <code>x</code> at position <code>pos</code>.
+   *  If number is more than one byte, shift rest of array to make space.
+   *
+   *  @param pos ...
+   *  @param x   ...
+   */
+  def patchNat(pos: Int, x: Int) {
+    def patchNatPrefix(x: Int) {
+      writeByte(0)
+      Array.copy(bytes, pos, bytes, pos+1, writeIndex - (pos+1))
+      bytes(pos) = ((x & 0x7f) | 0x80).toByte
+      val y = x >>> 7
+      if (y != 0) patchNatPrefix(y)
+    }
+    bytes(pos) = (x & 0x7f).toByte
+    val y = x >>> 7
+    if (y != 0) patchNatPrefix(y)
+  }
+
+  /** Write a long number <code>x</code> in signed big endian format, base 256.
+   *
+   *  @param x The long number to be written.
+   */
+  def writeLong(x: Long) {
+    val y = x >> 8
+    val z = x & 0xff
+    if (-y != (z >> 7)) writeLong(y)
+    writeByte(z.toInt)
+  }
+
+  // -- Basic input routines --------------------------------------------
+
+  /** Peek at the current byte without moving the read index */
+  def peekByte(): Int = bytes(readIndex)
+
+  /** Read a byte */
+  def readByte(): Int = {
+    val x = bytes(readIndex); readIndex += 1; x
+  }
+
+  /** Read a natural number in big endian format, base 128.
+   *  All but the last digits have bit 0x80 set.*/
+  def readNat(): Int = readLongNat().toInt
+
+  def readLongNat(): Long = {
+    var b = 0L
+    var x = 0L
+    do {
+      b = readByte()
+      x = (x << 7) + (b & 0x7f)
+    } while ((b & 0x80) != 0L);
+    x
+  }
+
+  /** Read a long number in signed big endian format, base 256. */
+  def readLong(len: Int): Long = {
+    var x = 0L
+    var i = 0
+    while (i < len) {
+      x = (x << 8) + (readByte() & 0xff)
+      i += 1
+    }
+    val leading = 64 - (len << 3)
+    x << leading >> leading
+  }
+
+  /** Returns the buffer as a sequence of (Int, Array[Byte]) representing
+   *  (tag, data) of the individual entries.  Saves and restores buffer state.
+   */
+
+  def toIndexedSeq: IndexedSeq[(Int, Array[Byte])] = {
+    val saved = readIndex
+    readIndex = 0
+    readNat() ; readNat()     // discarding version
+    val result = new Array[(Int, Array[Byte])](readNat())
+
+    result.indices foreach { index =>
+      val tag = readNat()
+      val len = readNat()
+      val bytes = data.slice(readIndex, len + readIndex)
+      readIndex += len
+
+      result(index) = tag -> bytes
+    }
+
+    readIndex = saved
+    result.toIndexedSeq
+  }
+
+  /** Perform operation <code>op</code> until the condition
+   *  <code>readIndex == end</code> is satisfied.
+   *  Concatenate results into a list.
+   *
+   *  @param end ...
+   *  @param op  ...
+   *  @return    ...
+   */
+  def until[T](end: Int, op: () => T): List[T] =
+    if (readIndex == end) List() else op() :: until(end, op);
+
+  /** Perform operation <code>op</code> the number of
+   *  times specified.  Concatenate the results into a list.
+   */
+  def times[T](n: Int, op: ()=>T): List[T] =
+    if (n == 0) List() else op() :: times(n-1, op)
+
+  /** Pickle = majorVersion_Nat minorVersion_Nat nbEntries_Nat {Entry}
+   *  Entry  = type_Nat length_Nat [actual entries]
+   *
+   *  Assumes that the ..Version_Nat are already consumed.
+   *
+   *  @return an array mapping entry numbers to locations in
+   *  the byte array where the entries start.
+   */
+  def createIndex: Array[Int] = {
+    val index = new Array[Int](readNat()) // nbEntries_Nat
+    for (i <- 0 until index.length) {
+      index(i) = readIndex
+      readByte() // skip type_Nat
+      readIndex = readNat() + readIndex // read length_Nat, jump to next entry
+    }
+    index
+  }
+}
diff --git a/src/compiler/scala/reflect/common/pickling/PickleFormat.scala b/src/compiler/scala/reflect/common/pickling/PickleFormat.scala
new file mode 100644
index 0000000000..3f7d9fbb52
--- /dev/null
+++ b/src/compiler/scala/reflect/common/pickling/PickleFormat.scala
@@ -0,0 +1,225 @@
+package scala.reflect
+package common
+package pickling
+
+/** This object provides constants for pickling attributes.
+ *
+ *  If you extend the format, be sure to increase the
+ *  version minor number.
+ *
+ *  @author Martin Odersky
+ *  @version 1.0
+ */
+object PickleFormat {
+
+/***************************************************
+ * Symbol table attribute format:
+ *   Symtab         = nentries_Nat {Entry}
+ *   Entry          = 1 TERMNAME len_Nat NameInfo
+ *                  | 2 TYPENAME len_Nat NameInfo
+ *                  | 3 NONEsym len_Nat
+ *                  | 4 TYPEsym len_Nat SymbolInfo
+ *                  | 5 ALIASsym len_Nat SymbolInfo
+ *                  | 6 CLASSsym len_Nat SymbolInfo [thistype_Ref]
+ *                  | 7 MODULEsym len_Nat SymbolInfo
+ *                  | 8 VALsym len_Nat [defaultGetter_Ref /* no longer needed*/] SymbolInfo [alias_Ref]
+ *                  | 9 EXTref len_Nat name_Ref [owner_Ref]
+ *                  | 10 EXTMODCLASSref len_Nat name_Ref [owner_Ref]
+ *                  | 11 NOtpe len_Nat
+ *                  | 12 NOPREFIXtpe len_Nat
+ *                  | 13 THIStpe len_Nat sym_Ref
+ *                  | 14 SINGLEtpe len_Nat type_Ref sym_Ref
+ *                  | 15 CONSTANTtpe len_Nat constant_Ref
+ *                  | 16 TYPEREFtpe len_Nat type_Ref sym_Ref {targ_Ref}
+ *                  | 17 TYPEBOUNDStpe len_Nat tpe_Ref tpe_Ref
+ *                  | 18 REFINEDtpe len_Nat classsym_Ref {tpe_Ref}
+ *                  | 19 CLASSINFOtpe len_Nat classsym_Ref {tpe_Ref}
+ *                  | 20 METHODtpe len_Nat tpe_Ref {sym_Ref}
+ *                  | 21 POLYTtpe len_Nat tpe_Ref {sym_Ref}
+ *                  | 22 IMPLICITMETHODtpe len_Nat tpe_Ref {sym_Ref} /* no longer needed */
+ *                  | 52 SUPERtpe len_Nat tpe_Ref tpe_Ref
+ *                  | 24 LITERALunit len_Nat
+ *                  | 25 LITERALboolean len_Nat value_Long
+ *                  | 26 LITERALbyte len_Nat value_Long
+ *                  | 27 LITERALshort len_Nat value_Long
+ *                  | 28 LITERALchar len_Nat value_Long
+ *                  | 29 LITERALint len_Nat value_Long
+ *                  | 30 LITERALlong len_Nat value_Long
+ *                  | 31 LITERALfloat len_Nat value_Long
+ *                  | 32 LITERALdouble len_Nat value_Long
+ *                  | 33 LITERALstring len_Nat name_Ref
+ *                  | 34 LITERALnull len_Nat
+ *                  | 35 LITERALclass len_Nat tpe_Ref
+ *                  | 36 LITERALenum len_Nat sym_Ref
+ *                  | 40 SYMANNOT len_Nat sym_Ref AnnotInfoBody
+ *                  | 41 CHILDREN len_Nat sym_Ref {sym_Ref}
+ *                  | 42 ANNOTATEDtpe len_Nat [sym_Ref /* no longer needed */] tpe_Ref {annotinfo_Ref}
+ *                  | 43 ANNOTINFO len_Nat AnnotInfoBody
+ *                  | 44 ANNOTARGARRAY len_Nat {constAnnotArg_Ref}
+ *                  | 47 DEBRUIJNINDEXtpe len_Nat level_Nat index_Nat
+ *                  | 48 EXISTENTIALtpe len_Nat type_Ref {symbol_Ref}
+ *                  | 49 TREE len_Nat 1 EMPTYtree
+ *                  | 49 TREE len_Nat 2 PACKAGEtree type_Ref sym_Ref mods_Ref name_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 3 CLASStree type_Ref sym_Ref mods_Ref name_Ref tree_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 4 MODULEtree type_Ref sym_Ref mods_Ref name_Ref tree_Ref
+ *                  | 49 TREE len_Nat 5 VALDEFtree type_Ref sym_Ref mods_Ref name_Ref tree_Ref tree_Ref
+ *                  | 49 TREE len_Nat 6 DEFDEFtree type_Ref sym_Ref mods_Ref name_Ref numtparams_Nat {tree_Ref} numparamss_Nat {numparams_Nat {tree_Ref}} tree_Ref tree_Ref
+ *                  | 49 TREE len_Nat 7 TYPEDEFtree type_Ref sym_Ref mods_Ref name_Ref tree_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 8 LABELtree type_Ref sym_Ref tree_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 9 IMPORTtree type_Ref sym_Ref tree_Ref {name_Ref name_Ref}
+ *                  | 49 TREE len_Nat 11 DOCDEFtree type_Ref sym_Ref string_Ref tree_Ref
+ *                  | 49 TREE len_Nat 12 TEMPLATEtree type_Ref sym_Ref numparents_Nat {tree_Ref} tree_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 13 BLOCKtree type_Ref tree_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 14 CASEtree type_Ref tree_Ref tree_Ref tree_Ref
+ *                  | 49 TREE len_Nat 15 SEQUENCEtree type_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 16 ALTERNATIVEtree type_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 17 STARtree type_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 18 BINDtree type_Ref sym_Ref name_Ref tree_Ref
+ *                  | 49 TREE len_Nat 19 UNAPPLYtree type_Ref tree_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 20 ARRAYVALUEtree type_Ref tree_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 21 FUNCTIONtree type_Ref sym_Ref tree_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 22 ASSIGNtree type_Ref tree_Ref tree_Ref
+ *                  | 49 TREE len_Nat 23 IFtree type_Ref tree_Ref tree_Ref tree_Ref
+ *                  | 49 TREE len_Nat 24 MATCHtree type_Ref tree_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 25 RETURNtree type_Ref sym_Ref tree_Ref
+ *                  | 49 TREE len_Nat 26 TREtree type_Ref tree_Ref tree_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 27 THROWtree type_Ref tree_Ref
+ *                  | 49 TREE len_Nat 28 NEWtree type_Ref tree_Ref
+ *                  | 49 TREE len_Nat 29 TYPEDtree type_Ref tree_Ref tree_Ref
+ *                  | 49 TREE len_Nat 30 TYPEAPPLYtree type_Ref tree_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 31 APPLYtree type_Ref tree_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 32 APPLYDYNAMICtree type_Ref sym_Ref tree_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 33 SUPERtree type_Ref sym_Ref tree_Ref name_Ref
+ *                  | 49 TREE len_Nat 34 THIStree type_Ref sym_Ref  name_Ref
+ *                  | 49 TREE len_Nat 35 SELECTtree type_Ref sym_Ref tree_Ref name_Ref
+ *                  | 49 TREE len_Nat 36 IDENTtree type_Ref sym_Ref name_Ref
+ *                  | 49 TREE len_Nat 37 LITERALtree type_Ref constant_Ref
+ *                  | 49 TREE len_Nat 38 TYPEtree type_Ref
+ *                  | 49 TREE len_Nat 39 ANNOTATEDtree type_Ref tree_Ref tree_Ref
+ *                  | 49 TREE len_Nat 40 SINGLETONTYPEtree type_Ref tree_Ref
+ *                  | 49 TREE len_Nat 41 SELECTFROMTYPEtree type_Ref tree_Ref name_Ref
+ *                  | 49 TREE len_Nat 42 COMPOUNDTYPEtree type_Ref tree_Ref
+ *                  | 49 TREE len_Nat 43 APPLIEDTYPEtree type_Ref tree_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 44 TYPEBOUNDStree type_Ref tree_Ref tree_Ref
+ *                  | 49 TREE len_Nat 45 EXISTENTIALTYPEtree type_Ref tree_Ref {tree_Ref}
+ *                  | 50 MODIFIERS len_Nat flags_Long privateWithin_Ref
+ *   SymbolInfo     = name_Ref owner_Ref flags_LongNat [privateWithin_Ref] info_Ref
+ *   NameInfo       = <character sequence of length len_Nat in Utf8 format>
+ *   NumInfo        = <len_Nat-byte signed number in big endian format>
+ *   Ref            = Nat
+ *   AnnotInfoBody  = info_Ref {annotArg_Ref} {name_Ref constAnnotArg_Ref}
+ *   AnnotArg       = Tree | Constant
+ *   ConstAnnotArg  = Constant | AnnotInfo | AnnotArgArray
+ *
+ *   len is remaining length after `len'.
+ */
+  val MajorVersion = 5
+  val MinorVersion = 0
+  def VersionString = "V" + MajorVersion + "." + MinorVersion
+
+  final val TERMname = 1
+  final val TYPEname = 2
+  final val NONEsym = 3
+  final val TYPEsym = 4
+  final val ALIASsym = 5
+  final val CLASSsym = 6
+  final val MODULEsym = 7
+  final val VALsym = 8
+  final val EXTref = 9
+  final val EXTMODCLASSref = 10
+  final val NOtpe = 11
+  final val NOPREFIXtpe = 12
+  final val THIStpe = 13
+  final val SINGLEtpe = 14
+  final val CONSTANTtpe = 15
+  final val TYPEREFtpe = 16
+  final val TYPEBOUNDStpe = 17
+  final val REFINEDtpe = 18
+  final val CLASSINFOtpe = 19
+  final val METHODtpe = 20
+  final val POLYtpe = 21
+  final val IMPLICITMETHODtpe = 22    // no longer generated
+
+  final val LITERAL = 23   // base line for literals
+  final val LITERALunit = 24
+  final val LITERALboolean = 25
+  final val LITERALbyte = 26
+  final val LITERALshort = 27
+  final val LITERALchar = 28
+  final val LITERALint = 29
+  final val LITERALlong = 30
+  final val LITERALfloat = 31
+  final val LITERALdouble = 32
+  final val LITERALstring = 33
+  final val LITERALnull = 34
+  final val LITERALclass = 35
+  final val LITERALenum = 36
+  final val SYMANNOT = 40
+  final val CHILDREN = 41
+  final val ANNOTATEDtpe = 42
+  final val ANNOTINFO = 43
+  final val ANNOTARGARRAY = 44
+
+  final val SUPERtpe = 46
+  final val DEBRUIJNINDEXtpe = 47
+  final val EXISTENTIALtpe = 48
+
+  final val TREE = 49      // prefix code that means a tree is coming
+    final val EMPTYtree = 1
+    final val PACKAGEtree = 2
+    final val CLASStree = 3
+    final val MODULEtree = 4
+    final val VALDEFtree = 5
+    final val DEFDEFtree = 6
+    final val TYPEDEFtree = 7
+    final val LABELtree = 8
+    final val IMPORTtree = 9
+    final val DOCDEFtree = 11
+    final val TEMPLATEtree = 12
+    final val BLOCKtree = 13
+    final val CASEtree = 14
+    // This node type has been removed.
+    // final val SEQUENCEtree = 15
+    final val ALTERNATIVEtree = 16
+    final val STARtree = 17
+    final val BINDtree = 18
+    final val UNAPPLYtree = 19
+    final val ARRAYVALUEtree = 20
+    final val FUNCTIONtree = 21
+    final val ASSIGNtree = 22
+    final val IFtree = 23
+    final val MATCHtree = 24
+    final val RETURNtree = 25
+    final val TREtree = 26
+    final val THROWtree = 27
+    final val NEWtree = 28
+    final val TYPEDtree = 29
+    final val TYPEAPPLYtree = 30
+    final val APPLYtree = 31
+    final val APPLYDYNAMICtree = 32
+    final val SUPERtree = 33
+    final val THIStree = 34
+    final val SELECTtree = 35
+    final val IDENTtree = 36
+    final val LITERALtree = 37
+    final val TYPEtree = 38
+    final val ANNOTATEDtree = 39
+    final val SINGLETONTYPEtree = 40
+    final val SELECTFROMTYPEtree = 41
+    final val COMPOUNDTYPEtree = 42
+    final val APPLIEDTYPEtree = 43
+    final val TYPEBOUNDStree = 44
+    final val EXISTENTIALTYPEtree = 45
+
+  final val MODIFIERS = 50
+
+  final val firstSymTag = NONEsym
+  final val lastSymTag = VALsym
+  final val lastExtSymTag = EXTMODCLASSref
+
+
+  //The following two are no longer accurate, because ANNOTATEDtpe,
+  //SUPERtpe, ... are not in the same range as the other types
+  //final val firstTypeTag = NOtpe
+  //final val lastTypeTag = POLYtpe
+}