@@ -1,14 +1,15 @@ /* __ *\** ________ ___ / / ___ Scala API ** ** / __/ __// _ | / / / _ | (c) 2002-2011 , LAMP/EPFL ** ** / __/ __// _ | / / / _ | (c) 2002-2013 , LAMP/EPFL ** ** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ /* INSTRUMENTED VERSION */ package scala .runtime package scala package runtime import scala .collection .{ Seq , IndexedSeq , TraversableView , AbstractIterator }import scala .collection .mutable .WrappedArray @@ -17,6 +18,7 @@ import scala.collection.generic.{ Sorted } import scala .reflect .{ ClassTag , classTag }import scala .util .control .ControlThrowable import scala .xml .{ Node , MetaData }import java .lang .{ Class => jClass }import java .lang .Double .doubleToLongBits import java .lang .reflect .{ Modifier , Method => JMethod }@@ -30,48 +32,41 @@ object ScalaRunTime { def isArray (x : Any , atLevel : Int ): Boolean = x != null && isArrayClass(x.getClass, atLevel) private def isArrayClass (clazz : Class [_], atLevel : Int ): Boolean = private def isArrayClass (clazz : jClass [_], atLevel : Int ): Boolean = clazz.isArray && (atLevel == 1 || isArrayClass(clazz.getComponentType, atLevel - 1 )) def isValueClass (clazz : Class [_]) = clazz.isPrimitive()def isTuple (x : Any ) = x != null && tupleNames(x.getClass.getName)def isValueClass (clazz : jClass[_]) = clazz.isPrimitive()// includes specialized subclasses and future proofed against hypothetical TupleN (for N > 22)def isTuple (x : Any ) = x != null && x.getClass.getName.startsWith(" scala.Tuple" def isAnyVal (x : Any ) = x match {case _ : Byte | _ : Short | _ : Char | _ : Int | _ : Long | _ : Float | _ : Double | _ : Boolean | _ : Unit => true case _ => false } // Avoiding boxing which messes up the specialized tests. Don't ask.private val tupleNames = {var i = 22 var names : List [String ] = Nil while (i >= 1 ) {names :: = (" scala.Tuple" + String .valueOf(i)) i - = 1 } names.toSet } /** Return the class object representing an array with element class `clazz`.*/ def arrayClass (clazz : Class [_]): Class [_] = {def arrayClass (clazz : jClass [_]): jClass [_] = {// newInstance throws an exception if the erasure is Void.TYPE. see SI-5680if (clazz == java.lang.Void .TYPE ) classOf [Array [Unit ]]else java.lang.reflect.Array .newInstance(clazz, 0 ).getClass} /** Return the class object representing elements in arrays described by a given schematic.*/ def arrayElementClass (schematic : Any ): Class [_] = schematic match {case cls : Class [_] => cls.getComponentTypedef arrayElementClass (schematic : Any ): jClass [_] = schematic match {case cls : jClass [_] => cls.getComponentTypecase tag : ClassTag [_] => tag.runtimeClasscase _ => throw new UnsupportedOperationException (" unsupported schematic %s (%s)" if (schematic == null ) " null" else schematic.getClass))case _ => throw new UnsupportedOperationException (s" unsupported schematic $schematic (${schematic.getClass})" } /** Return the class object representing an unboxed value type,* e.g. classOf[int], not classOf[java.lang.Integer]. The compiler * rewrites expressions like 5.getClass to come here. */ def anyValClass [T < : AnyVal : ClassTag ](value : T ): Class [T ] = classTag[T ].runtimeClass.asInstanceOf [Class [T ]] def anyValClass [T < : AnyVal : ClassTag ](value : T ): jClass [T ] = classTag[T ].runtimeClass.asInstanceOf [jClass [T ]] var arrayApplyCount = 0 @@ -93,11 +88,9 @@ object ScalaRunTime { } } var arrayUpdateCount = 0 /** update generic array element */ def array_update (xs : AnyRef , idx : Int , value : Any ): Unit = {arrayUpdateCount + = 1 arrayApplyCount + = 1 xs match { case x : Array [AnyRef ] => x(idx) = value.asInstanceOf [AnyRef ]case x : Array [Int ] => x(idx) = value.asInstanceOf [Int ]@@ -156,7 +149,7 @@ object ScalaRunTime { dest } def toArray [T ](xs : collection.Seq [T ]) = {def toArray [T ](xs : scala. collection.Seq [T ]) = {val arr = new Array [AnyRef ](xs.length)var i = 0 for (x < - xs) {@@ -179,39 +172,10 @@ object ScalaRunTime { def checkInitialized [T < : AnyRef ](x : T ): T = if (x == null ) throw new UninitializedError else xabstract class Try [+ A ] {def Catch [B > : A ](handler : PartialFunction [Throwable , B ]): B def Finally (fin : => Unit ): A } def Try [A ](block : => A ): Try [A ] = new Try [A ] with Runnable {private var result : A = _private var exception : Throwable = try { run() ; null }catch {case e : ControlThrowable => throw e // don't catch non-local returns etccase e : Throwable => e} def run () { result = block }def Catch [B > : A ](handler : PartialFunction [Throwable , B ]): B = if (exception == null ) resultelse if (handler isDefinedAt exception) handler(exception)else throw exceptiondef Finally (fin : => Unit ): A = {fin if (exception == null ) resultelse throw exception} } def _toString (x : Product ): String = x.productIterator.mkString(x.productPrefix + " (" " ," " )" def _hashCode (x : Product ): Int = scala.util.MurmurHash3 .productHash(x)def _hashCode (x : Product ): Int = scala.util.hashing. MurmurHash3 .productHash(x)/** A helper for case classes. */ def typedProductIterator [T ](x : Product ): Iterator [T ] = {@@ -246,12 +210,12 @@ object ScalaRunTime { // Note that these are the implementations called by ##, so they// must not call ## themselves.@ inline def hash (x : Any ): Int = def hash (x : Any ): Int = if (x == null ) 0 else if (x.isInstanceOf [java.lang.Number ]) BoxesRunTime .hashFromNumber(x.asInstanceOf [java.lang.Number ])else x.hashCode@ inline def hash (dv : Double ): Int = {def hash (dv : Double ): Int = {val iv = dv.toIntif (iv == dv) return iv@@ -261,37 +225,37 @@ object ScalaRunTime { val fv = dv.toFloatif (fv == dv) fv.hashCode else dv.hashCode} @ inline def hash (fv : Float ): Int = {def hash (fv : Float ): Int = {val iv = fv.toIntif (iv == fv) return ivval lv = fv.toLongif (lv == fv) return hash(lv)else fv.hashCode} @ inline def hash (lv : Long ): Int = {def hash (lv : Long ): Int = {val low = lv.toIntval lowSign = low >>> 31 val high = (lv >>> 32 ).toIntlow ^ (high + lowSign) } @ inline def hash (x : Number ): Int = runtime.BoxesRunTime .hashFromNumber(x)def hash (x : Number ): Int = runtime.BoxesRunTime .hashFromNumber(x)// The remaining overloads are here for completeness, but the compiler// inlines these definitions directly so they're not generally used.@ inline def hash (x : Int ): Int = x@ inline def hash (x : Short ): Int = x.toInt@ inline def hash (x : Byte ): Int = x.toInt@ inline def hash (x : Char ): Int = x.toInt@ inline def hash (x : Boolean ): Int = if (x) true .hashCode else false .hashCode@ inline def hash (x : Unit ): Int = 0 def hash (x : Int ): Int = xdef hash (x : Short ): Int = x.toIntdef hash (x : Byte ): Int = x.toIntdef hash (x : Char ): Int = x.toIntdef hash (x : Boolean ): Int = if (x) true .hashCode else false .hashCodedef hash (x : Unit ): Int = 0 /** A helper method for constructing case class equality methods,* because existential types get in the way of a clean outcome and * it's performing a series of Any/Any equals comparisons anyway. * See ticket #2867 for specifics. */ def sameElements (xs1 : collection.Seq [Any ], xs2 : collection.Seq [Any ]) = xs1 sameElements xs2def sameElements (xs1 : scala. collection.Seq [Any ], xs2 : scala. collection.Seq [Any ]) = xs1 sameElements xs2/** Given any Scala value, convert it to a String.* @@ -358,7 +322,7 @@ object ScalaRunTime { case x : String => if (x.head.isWhitespace || x.last.isWhitespace) " \" " + x + " \" " else xcase x if useOwnToString(x) => x.toStringcase x : AnyRef if isArray(x) => arrayToString(x)case x : collection.Map [_, _] => x.iterator take maxElements map mapInner mkString (x.stringPrefix + " (" " , " " )" case x : scala. collection.Map [_, _] => x.iterator take maxElements map mapInner mkString (x.stringPrefix + " (" " , " " )" case x : Iterable [_] => x.iterator take maxElements map inner mkString (x.stringPrefix + " (" " , " " )" case x : Traversable [_] => x take maxElements map inner mkString (x.stringPrefix + " (" " , " " )" case x : Product1 [_] if isTuple(x) => " (" + inner(x._1) + " ,)" // that special trailing comma
0 comments on commit
a19babc