Merge branch 'scoot-generalized' into scoot-abstract

Author: octalsrc

src/main/scala/edu/colorado/plv/cuanto/scoot/interpreter/control/package.scala

@@ -6,8 +6,10 @@ import soot.toolkits.graph.UnitGraph
 
 import expression.Env
 
+/** Interpret soot Units that affect control-flow */
 package object control {
 
+  /** Find the next Unit, given an environment */
   def succ(graph: UnitGraph)(env: Env, unit: SootUnit):
       Option[SootUnit] = ???
 

src/main/scala/edu/colorado/plv/cuanto/scoot/interpreter/expression/Arithmetic.scala

@@ -7,12 +7,14 @@ import soot.jimple._
 import domains._
 import domains.IntDom
 
+/** Sub-interpreter for arithmetic nodes */
 object Arithmetic {
 
-  def omerge[A,B](t: (Option[A],Option[B])): Option[(A,B)] =
+  private def omerge[A,B](t: (Option[A],Option[B])): Option[(A,B)] =
     for (a <- t._1; b <- t._2) yield (a,b)
 
 
+  /** Interpret an arithmetic operator node */
   def interpNode(v: Value)(r: Value => Option[RFun]):
       Option[RFun] = v match {
     // case v: Local => env get v

src/main/scala/edu/colorado/plv/cuanto/scoot/interpreter/expression/package.scala

@@ -6,24 +6,34 @@ import soot._
 
 import scoot.domains._
 
+/** Interpreter for expressions (soot Values).  This depends on
+  * expression evaluation not having side-effects.
+  */
 package object expression {
+  /** A sum type of possible types that an expression can evaluate to */
   type R = Result[IntDom]
+
+  /** Evaluation environment */
   type Env = Map[String,R]
   type RFun = Env => Option[R]
 
+  /** The empty environment */
   val emptyEnv: Env = new HashMap[String,R]()
 
+  /** Interpret a value under a particular environment */
   def interpret(v: Value, env: Env = emptyEnv): Option[R] = (for {
     rfun <- interpR(v)
   } yield rfun(env)).flatten
 
-  def interpR(v: Value): Option[RFun] =
+  private def interpR(v: Value): Option[RFun] =
     anyOf(Seq(Arithmetic.interpNode(v)(interpR), Locals.interpNode(v)(interpR)))
 
-  def anyOf(is: Traversable[Option[RFun]]): Option[RFun] =
+  private def anyOf(is: Traversable[Option[RFun]]): Option[RFun] =
     is.flatten.headOption
 
+  /** Sub-interpreter for looking up Local values in the environment */
   object Locals {
+    /** Interpret a Local node */
     def interpNode(v: Value)(r: Value => Option[RFun]):
         Option[RFun] = v match {
       case v: Local => Some(_ get v.getName())

src/main/scala/edu/colorado/plv/cuanto/scoot/interpreter/mutation/package.scala

@@ -6,6 +6,8 @@ import soot.jimple._
 
 import expression._
 
+/** Interpreter for soot Units that modify the evaluation
+  * environment */
 package object mutation {
 
   private def some[A](a: A): Option[A] = Some(a)