Type Members

1.  class AAM[Exp, Abs, Addr, Time] extends EvalKontMachine[Exp, Abs, Addr, Time]

   Implementation of a CESK machine following the AAM approach (Van Horn, David, and Matthew Might.

   Implementation of a CESK machine following the AAM approach (Van Horn, David, and Matthew Might. "Abstracting abstract machines." ACM Sigplan Notices. Vol. 45. No. 9. ACM, 2010).

   A difference with the paper is that we separate the continuation store (KontStore) from the value store (Store). That simplifies the implementation of both stores, and the only change it induces is that we are not able to support first-class continuation as easily (we don't support them at all, but they could be added).

   Also, in the paper, a CESK state is made of 4 components: Control, Environment, Store, and Kontinuation. Here, we include the environment in the control component, and we distinguish "eval" states from "continuation" states. An eval state has an attached environment, as an expression needs to be evaluated within this environment, whereas a continuation state only contains the value reached.

2.  class AAMAACP4F[Exp, Abs, Addr, Time] extends EvalKontMachine[Exp, Abs, Addr, Time]

   AAM/AAC/P4F techniques combined in a single machine abstraction

3.  class AAMNS[Exp, Abs, Addr, Time] extends EvalKontMachine[Exp, Abs, Addr, Time]

   Copy of AAM machine but without the subsumption part (AAMNS - AAM No Subsumption).

   Copy of AAM machine but without the subsumption part (AAMNS - AAM No Subsumption). Use as comparison to Scala-Par-AM https://bitbucket.org/OPiMedia/scala-par-am (a parallel version of Scala-AM).

4.  trait ANFAtomicExp extends ANFExp
5.  trait ANFExp extends AnyRef

   Abstract syntax of ANF programs

6.  case class ANFFuncall(f: ANFAtomicExp, args: List[ANFAtomicExp], pos: Position) extends ANFExp with Product with Serializable
7.  case class ANFIf(cond: ANFAtomicExp, cons: ANFExp, alt: ANFExp, pos: Position) extends ANFExp with Product with Serializable
8.  case class ANFLambda(args: List[Identifier], body: ANFExp, pos: Position) extends ANFAtomicExp with Product with Serializable
9.  case class ANFLet(variable: Identifier, value: ANFExp, body: ANFExp, pos: Position) extends ANFExp with Product with Serializable
10.  case class ANFLetrec(variable: Identifier, value: ANFExp, body: ANFExp, pos: Position) extends ANFExp with Product with Serializable
11.  case class ANFQuoted(quoted: SExp, pos: Position) extends ANFExp with Product with Serializable
12.  class ANFSemantics[Abs, Addr, Time] extends Semantics[ANFExp, Abs, Addr, Time]

    Semantics for ANF Scheme (abstract grammar defined in ANF.scala)

13.  case class ANFSet(variable: Identifier, value: ANFAtomicExp, pos: Position) extends ANFExp with Product with Serializable
14.  case class ANFValue(value: Value, pos: Position) extends ANFAtomicExp with Product with Serializable
15.  case class ANFVar(v: Identifier) extends ANFAtomicExp with Product with Serializable
16.  trait ASchemeLattice extends SchemeLattice
17.  class ASchemeSemantics[Abs, Addr, Time, PID] extends SchemeSemantics[Abs, Addr, Time]
18.  class ASchemeSemanticsWithVisitorAndOptimization[Abs, Addr, Time, PID] extends ASchemeSemantics[Abs, Addr, Time, PID]
19.  abstract class AbstractMachine[Exp, Abs, Addr, Time] extends AnyRef

    The interface of the abstract machine itself.

    The interface of the abstract machine itself. The abstract machine is parameterized by abstract values, addresses and expressions. Look into AAM.scala for an example of how to define these parameters

20.  abstract class Action[Exp, Abs, Addr] extends AnyRef

    The different kinds of actions that can be taken by the abstract machine

21.  case class ActionError[Exp, Abs, Addr](error: SemanticError)(implicit evidence$43: Expression[Exp], evidence$44: JoinLattice[Abs], evidence$45: Address[Addr]) extends Action[Exp, Abs, Addr] with Product with Serializable

    An error has been reached

22.  case class ActionEval[Exp, Abs, Addr](e: Exp, env: Environment[Addr], store: Store[Addr, Abs], effects: Set[Effect[Addr]] = Set[Effect[Addr]]())(implicit evidence$37: Expression[Exp], evidence$38: JoinLattice[Abs], evidence$39: Address[Addr]) extends Action[Exp, Abs, Addr] with Product with Serializable

    Evaluation continues with expression e in environment env

23.  class ActionHelpers[Exp, Abs, Addr] extends AnyRef
24.  case class ActionJoin[TID, Exp, Abs, Addr](t: TID, store: Store[Addr, Abs], effects: Set[Effect[Addr]] = Set[Effect[Addr]]())(implicit evidence$50: ThreadIdentifier[TID], evidence$51: Expression[Exp], evidence$52: JoinLattice[Abs], evidence$53: Address[Addr]) extends Action[Exp, Abs, Addr] with Product with Serializable

    Waits for the execution of a thread, with tid as its identifier.

25.  case class ActionPush[Exp, Abs, Addr](frame: Frame, e: Exp, env: Environment[Addr], store: Store[Addr, Abs], effects: Set[Effect[Addr]] = Set[Effect[Addr]]())(implicit evidence$34: Expression[Exp], evidence$35: JoinLattice[Abs], evidence$36: Address[Addr]) extends Action[Exp, Abs, Addr] with Product with Serializable

    A frame needs to be pushed on the stack, and the interpretation continues by evaluating expression e in environment env

26.  case class ActionReachedValue[Exp, Abs, Addr](v: Abs, store: Store[Addr, Abs], effects: Set[Effect[Addr]] = Set[Effect[Addr]]())(implicit evidence$31: Expression[Exp], evidence$32: JoinLattice[Abs], evidence$33: Address[Addr]) extends Action[Exp, Abs, Addr] with Product with Serializable

    A value is reached by the interpreter.

    A value is reached by the interpreter. As a result, a continuation will be popped with the given reached value.

27.  case class ActionSpawn[TID, Exp, Abs, Addr](t: TID, e: Exp, env: Environment[Addr], store: Store[Addr, Abs], act: Action[Exp, Abs, Addr], effects: Set[Effect[Addr]] = Set[Effect[Addr]]())(implicit evidence$46: ThreadIdentifier[TID], evidence$47: Expression[Exp], evidence$48: JoinLattice[Abs], evidence$49: Address[Addr]) extends Action[Exp, Abs, Addr] with Product with Serializable

    Spawns a new thread that evaluates expression e in environment ρ.

    Spawns a new thread that evaluates expression e in environment ρ. The current thread continues its execution by performing action act.

28.  case class ActionStepIn[Exp, Abs, Addr](fexp: Exp, clo: (Exp, Environment[Addr]), e: Exp, env: Environment[Addr], store: Store[Addr, Abs], argsv: List[(Exp, Abs)], effects: Set[Effect[Addr]] = Set[Effect[Addr]]())(implicit evidence$40: Expression[Exp], evidence$41: JoinLattice[Abs], evidence$42: Address[Addr]) extends Action[Exp, Abs, Addr] with Product with Serializable

    Similar to ActionEval, but only used when stepping inside a function's body (clo is therefore the function stepped into).

    Similar to ActionEval, but only used when stepping inside a function's body (clo is therefore the function stepped into). The expressions and values of the arguments should also be provided, as they can be needed by the abstract machine.

29.  case class ActorActionBecome[Exp, Abs, Addr, Time, PID](name: String, actd: Exp, env: Environment[Addr], store: Store[Addr, Abs], vres: Abs, effects: Set[Effect[Addr]] = Set[Effect[Addr]]())(implicit evidence$68: Expression[Exp], evidence$69: JoinLattice[Abs], evidence$70: Address[Addr], evidence$71: Timestamp[Time], evidence$72: ThreadIdentifier[PID]) extends Action[Exp, Abs, Addr] with Product with Serializable
30.  case class ActorActionCreate[Exp, Abs, Addr, Time, PID](name: String, actd: Exp, e: Exp, env: Environment[Addr], store: Store[Addr, Abs], fres: (PID) ⇒ Abs, effects: Set[Effect[Addr]] = Set[Effect[Addr]]())(implicit evidence$63: Expression[Exp], evidence$64: JoinLattice[Abs], evidence$65: Address[Addr], evidence$66: Timestamp[Time], evidence$67: ThreadIdentifier[PID]) extends Action[Exp, Abs, Addr] with Product with Serializable
31.  class ActorActionHelpers[Exp, Abs, Addr, Time, PID] extends AnyRef
32.  case class ActorActionSend[PID, Exp, Abs, Addr](p: PID, name: String, msg: List[Abs], vres: Abs, effects: Set[Effect[Addr]] = Set[Effect[Addr]]())(implicit evidence$59: ThreadIdentifier[PID], evidence$60: Expression[Exp], evidence$61: JoinLattice[Abs], evidence$62: Address[Addr]) extends Action[Exp, Abs, Addr] with Product with Serializable
33.  case class ActorActionTerminate[Exp, Abs, Addr](effects: Set[Effect[Addr]] = Set[Effect[Addr]]())(implicit evidence$73: Expression[Exp], evidence$74: JoinLattice[Abs], evidence$75: Address[Addr]) extends Action[Exp, Abs, Addr] with Product with Serializable
34.  trait ActorTimestamp[T] extends Timestamp[T]
35.  trait ActorTimestampWrapper extends TimestampWrapper
36.  abstract class ActorVisitor[Exp, Abs, Addr] extends AnyRef
37.  class ActorsAAM[Exp, Abs, Addr, Time, PID] extends AbstractMachine[Exp, Abs, Addr, Time]
38.  class ActorsAAMGlobalStore[Exp, Abs, Addr, Time, PID] extends AbstractMachine[Exp, Abs, Addr, Time]
39.  trait Address[A] extends AnyRef
40.  trait AddressWrapper extends AnyRef
41.  abstract class Analysis[L, Exp, Abs, Addr, Time] extends AnyRef
42.  case class App(e1: LamExp, e2: LamExp, pos: Position) extends LamExp with Product with Serializable

    An application: (e1 e2)

43.  case class ArityError(name: String, expected: Int, got: Int) extends SemanticError with Product with Serializable
44.  class BaseSchemeSemantics[V, Addr, Time] extends Semantics[SchemeExp, V, Addr, Time]

    Basic Scheme semantics, without any optimization

45.  case class BasicEnvironment[Addr](content: Map[String, Addr])(implicit evidence$2: Address[Addr]) extends Environment[Addr] with Product with Serializable

    Basic mapping from names to addresses

46.  case class BasicKontStore[KontAddr](content: Map[KontAddr, Set[Kont[KontAddr]]])(implicit evidence$3: KontAddress[KontAddr]) extends KontStore[KontAddr] with Product with Serializable
47.  case class BasicStore[Addr, Abs](content: Map[Addr, Abs])(implicit evidence$3: Address[Addr], evidence$4: JoinLattice[Abs]) extends Store[Addr, Abs] with Product with Serializable

    Basic store with no fancy feature, just a map from addresses to values

48.  abstract class Benchmarks extends AnyRef
49.  trait BoolLattice[B] extends LatticeElement[B]

    A lattice for booleans

50.  class BoundedInteger extends AnyRef
51.  case class BoundedListMboxImpl[PID, Abs](bound: Int) extends MboxImpl[PID, Abs] with Product with Serializable
52.  case class BoundedMultisetMboxImpl[PID, Abs](bound: Int) extends MboxImpl[PID, Abs] with Product with Serializable
53.  trait CSchemeLattice extends SchemeLattice
54.  class CSchemePrimitives[Addr, Abs] extends SchemePrimitives[Addr, Abs]
55.  class CSchemeSemantics[Abs, Addr, Time, TID] extends SchemeSemantics[Abs, Addr, Time]
56.  case class CannotAccessCar(v: String) extends SemanticError with Product with Serializable
57.  case class CannotAccessCdr(v: String) extends SemanticError with Product with Serializable
58.  case class CannotAccessVector(vector: String) extends SemanticError with Product with Serializable
59.  sealed trait Cardinality extends AnyRef

    Cardinality represents how much information a lattice value represents

60.  case class CardinalityNumber(n: Int) extends Cardinality with Product with Serializable
61.  trait CharLattice[C] extends LatticeElement[C]

    A lattice for characters

62.  case class Color(hex: String) extends Product with Serializable
63.  case class CombinedEnvironment[Addr](ro: Environment[Addr], w: Environment[Addr])(implicit evidence$3: Address[Addr]) extends Environment[Addr] with Product with Serializable

    Environment that combines a default read-only environment with a writable environment

64.  case class CombinedStore[Addr, Abs](ro: Store[Addr, Abs], w: Store[Addr, Abs])(implicit evidence$5: Address[Addr], evidence$6: JoinLattice[Abs]) extends Store[Addr, Abs] with Product with Serializable

    Store that combines a default read-only store with a writable store

65.  class ConcreteMachine[Exp, Abs, Addr, Time] extends EvalKontMachine[Exp, Abs, Addr, Time]

    Implementation of a concrete CESK machine.

    Implementation of a concrete CESK machine. It should be faster than other implementations in this framework because it doesn't store the set of visited states.

66.  class ConcurrentAAM[Exp, Abs, Addr, Time, TID] extends AbstractMachine[Exp, Abs, Addr, Time]
67.  trait ContextSensitiveTID extends AnyRef
68.  trait Count extends AnyRef
69.  case class CountingMap[A, B](content: Map[A, (Count, Set[B])]) extends Product with Serializable
70.  case class CountingStore[Addr, Abs](content: Map[Addr, (Count, Abs)])(implicit evidence$11: Address[Addr], evidence$12: JoinLattice[Abs]) extends Store[Addr, Abs] with Product with Serializable
71.  case class DeltaStore[Addr, Abs](content: Map[Addr, Abs], d: Map[Addr, Abs])(implicit evidence$7: Address[Addr], evidence$8: JoinLattice[Abs]) extends Store[Addr, Abs] with Product with Serializable

    A store that supports store deltas.

    A store that supports store deltas. Many operations are not implemented because they are not needed.

72.  class DotLanguage[Addr] extends AnyRef
73.  abstract class Effect[Addr] extends AnyRef
74.  case class EffectAcquire[Addr](target: Addr)(implicit evidence$21: Address[Addr]) extends Effect[Addr] with Product with Serializable
75.  trait EffectKind extends AnyRef

    The different kinds of effects that can be generated by the semantics

76.  case class EffectReadConsCar[Addr](target: Addr)(implicit evidence$14: Address[Addr]) extends Effect[Addr] with Product with Serializable
77.  case class EffectReadConsCdr[Addr](target: Addr)(implicit evidence$15: Address[Addr]) extends Effect[Addr] with Product with Serializable
78.  case class EffectReadVariable[Addr](target: Addr)(implicit evidence$13: Address[Addr]) extends Effect[Addr] with Product with Serializable
79.  case class EffectReadVector[Addr](target: Addr)(implicit evidence$16: Address[Addr]) extends Effect[Addr] with Product with Serializable
80.  case class EffectRelease[Addr](target: Addr)(implicit evidence$22: Address[Addr]) extends Effect[Addr] with Product with Serializable
81.  case class EffectWriteConsCar[Addr](target: Addr)(implicit evidence$18: Address[Addr]) extends Effect[Addr] with Product with Serializable
82.  case class EffectWriteConsCdr[Addr](target: Addr)(implicit evidence$19: Address[Addr]) extends Effect[Addr] with Product with Serializable
83.  case class EffectWriteVariable[Addr](target: Addr)(implicit evidence$17: Address[Addr]) extends Effect[Addr] with Product with Serializable
84.  case class EffectWriteVector[Addr](target: Addr)(implicit evidence$20: Address[Addr]) extends Effect[Addr] with Product with Serializable
85.  class EmptyActorVisitor[Exp, Abs, Addr] extends ActorVisitor[Exp, Abs, Addr]
86.  abstract class Environment[Addr] extends AnyRef
87.  abstract class EvalKontMachine[Exp, Abs, Addr, Time] extends AbstractMachine[Exp, Abs, Addr, Time]

    Abstract machine with a control component that works in an eval-kont way: it can either be evaluating something, or have reached a value and will pop a continuation.

88.  trait ExplorationType extends AnyRef
89.  trait Expression[E] extends AnyRef
90.  trait Frame extends AnyRef
91.  class Graph[N, A, C] extends AnyRef

    Represents a graph where nodes are elements of N, and edges are annotated with elements of type-class GraphAnnotation

92.  trait GraphAnnotation[A, C] extends AnyRef
93.  case class GraphMboxImpl[PID, Abs]() extends MboxImpl[PID, Abs] with Product with Serializable
94.  trait GraphNode[N, C] extends AnyRef
95.  trait GraphOutput extends AnyRef
96.  case class Identifier(name: String, pos: Position) extends Product with Serializable

    An identifier has a name and a position

97.  trait InsensitiveTID extends AnyRef
98.  trait IntLattice[I] extends LatticeElement[I]

    A lattice for integers

99.  trait IsASchemeLattice[L] extends IsSchemeLattice[L]

    A lattice for Actor Scheme

100.  trait IsCSchemeLattice[L] extends IsSchemeLattice[L]

     A lattice for Concurrent Scheme

101.  trait IsSchemeLattice[L] extends JoinLattice[L]

     A lattice for Scheme should support the following operations

102.  trait IsTaintLattice[L] extends IsSchemeLattice[L]
103.  trait JoinLattice[L] extends Monoid[L] with PartialOrdering[L]

     A (join semi-)lattice L should support the following operations

104.  trait KAllocStrategy extends AnyRef
105.  case class KCFA(k: Int) extends TimestampWrapper with Product with Serializable
106.  case class KMessageTagSensitivity(k: Int) extends ActorTimestampWrapper with Product with Serializable
107.  class KeyMap[A] extends AnyRef
108.  case class Kont[KontAddr](frame: Frame, next: KontAddr)(implicit evidence$1: KontAddress[KontAddr]) extends Product with Serializable
109.  trait KontAddress[A] extends AnyRef
110.  abstract class KontStore[KontAddr] extends AnyRef
111.  case class Lam(x: Identifier, e: LamExp, pos: Position) extends LamExp with Product with Serializable

     An abstraction: lambda x.

     An abstraction: lambda x. e

112.  trait LamExp extends AnyRef

     A lambda calculus expression is represented by a LamExp.

     A lambda calculus expression is represented by a LamExp. It needs to have a position to identify its location in the input file.

113.  trait LamLattice[L] extends JoinLattice[L]

     Our value domain should form a lattice, but we need support for a bit more than just join operations

114.  class LamSemantics[Abs, Addr, Time] extends Semantics[LamExp, Abs, Addr, Time]

     This defines the semantics of call-by-value lambda expressions

115.  trait LatticeElement[L] extends Order[L] with Monoid[L] with Show[L]

     We define here some domains that can will be useful to build a lattice for most languages.

116.  case class ListMboxImpl[PID, Abs]() extends MboxImpl[PID, Abs] with Product with Serializable
117.  case class MachineConfig(program: String, machine: Config.Machine.Value = Config.Machine.AAM, address: Config.Address.Value = Config.Address.Classical, lattice: Config.Lattice.Value = Config.Lattice.TypeSet, concrete: Boolean = false) extends Product with Serializable
118.  class MakeASchemeLattice[LSeq] extends ASchemeLattice
119.  class MakeCSchemeLattice[LSeq] extends CSchemeLattice
120.  class MakeSchemeLattice[S, B, I, F, C, Sym] extends SchemeLattice
121.  sealed trait MayFail[L] extends AnyRef
122.  case class MayFailBoth[L](l: L, errs: List[SemanticError]) extends MayFail[L] with Product with Serializable
123.  case class MayFailError[L](errs: List[SemanticError]) extends MayFail[L] with Product with Serializable
124.  case class MayFailSuccess[L](l: L) extends MayFail[L] with Product with Serializable
125.  case class MaybeTainted(sources: Set[Position]) extends TaintStatus with Product with Serializable
126.  trait MboxImpl[PID, Abs] extends AnyRef
127.  trait MboxSize extends AnyRef
128.  case class MboxSizeN(n: Int) extends MboxSize with Product with Serializable
129.  case class MessageNotSupported(actor: String, message: String, supported: List[String]) extends SemanticError with Product with Serializable
130.  case class MultisetMboxImpl[PID, Abs]() extends MboxImpl[PID, Abs] with Product with Serializable
131.  case class NotSupported(reason: String) extends SemanticError with Product with Serializable
132.  case class OperatorNotApplicable(name: String, arguments: List[String]) extends SemanticError with Product with Serializable
133.  sealed trait Position extends AnyRef

     This trait represents a position in a source file.

     This trait represents a position in a source file. It's currently a wrapper around scala.util.parsing.input.Position, but will probably be updated in the future.

134.  case class PowersetMboxImpl[PID, Abs]() extends MboxImpl[PID, Abs] with Product with Serializable
135.  trait Primitive[Addr, Abs] extends AnyRef

     Each primitive has to implement this trait.

136.  abstract class Primitives[Addr, Abs] extends AnyRef
137.  case class ProductAnalysis[L1, L2, Exp, Abs, Addr, Time](analysis1: Analysis[L1, Exp, Abs, Addr, Time], analysis2: Analysis[L2, Exp, Abs, Addr, Time])(implicit evidence$5: Expression[Exp], evidence$6: JoinLattice[Abs], evidence$7: Address[Addr], evidence$8: Timestamp[Time]) extends Analysis[(L1, L2), Exp, Abs, Addr, Time] with Product with Serializable
138.  trait RealLattice[F] extends LatticeElement[F]

     A lattice for floats

139.  class RecordActorVisitor[Exp, Abs, Addr] extends ActorVisitor[Exp, Abs, Addr]
140.  trait SExp extends AnyRef

     Abstract grammar elements for S-expressions include some positional information.

     Abstract grammar elements for S-expressions include some positional information. This serves two purposes: identify where the s-expression resides in the input file, and as tagging information for the abstract machine.

141.  case class SExpId(id: Identifier) extends SExp with Product with Serializable

     An identifier, such as foo, bar, etc.

142.  class SExpLexer extends Lexical with SExpTokens
143.  case class SExpPair(car: SExp, cdr: SExp, pos: Position) extends SExp with Product with Serializable

     An s-expression is made of pairs, e.g., (foo bar) is represented as the pair with identifier foo as car and another pair -- with identifier bar as car and value nil as cdr -- as cdr.

     An s-expression is made of pairs, e.g., (foo bar) is represented as the pair with identifier foo as car and another pair -- with identifier bar as car and value nil as cdr -- as cdr. Pairs are pretty-printed when converted to string. i.e., (foo bar) is stringified as (foo bar) and not (foo . (bar . ()))

144.  case class SExpQuoted(content: SExp, pos: Position) extends SExp with Product with Serializable

     A quoted element, such as 'foo, '(foo (bar)), etc.

145.  trait SExpTokens extends Tokens
146.  case class SExpValue(value: Value, pos: Position) extends SExp with Product with Serializable

     A literal value, such as 1, "foo", 'foo, etc.

147.  case class SchemeAcquire(exp: SchemeExp, pos: Position) extends SchemeExp with Product with Serializable

     Acquire a lock

148.  case class SchemeActor(name: String, xs: List[Identifier], defs: Map[String, (List[Identifier], List[SchemeExp])], pos: Position) extends SchemeExp with Product with Serializable

     Define a behavior

149.  case class SchemeAnd(exps: List[SchemeExp], pos: Position) extends SchemeExp with Product with Serializable

     An and expression: (and exps...)

150.  case class SchemeBecome(actor: SchemeExp, args: List[SchemeExp], pos: Position) extends SchemeExp with Product with Serializable

     Change the behavior of the current actor

151.  case class SchemeBegin(exps: List[SchemeExp], pos: Position) extends SchemeExp with Product with Serializable

     A begin clause: (begin body...)

152.  case class SchemeCas(variable: Identifier, eold: SchemeExp, enew: SchemeExp, pos: Position) extends SchemeExp with Product with Serializable

     Compare-and-swap, concurrency synchronization primitive.

153.  case class SchemeCasVector(variable: Identifier, index: SchemeExp, eold: SchemeExp, enew: SchemeExp, pos: Position) extends SchemeExp with Product with Serializable

     Compare-and-swap on a vector

154.  case class SchemeCase(key: SchemeExp, clauses: List[(List[SchemeValue], List[SchemeExp])], default: List[SchemeExp], pos: Position) extends SchemeExp with Product with Serializable

     A case expression: (case key ((vals1...) body1...) ...

     A case expression: (case key ((vals1...) body1...) ... (else default...))

155.  case class SchemeCond(clauses: List[(SchemeExp, List[SchemeExp])], pos: Position) extends SchemeExp with Product with Serializable

     A cond expression: (cond (test1 body1...) ...)

156.  case class SchemeCreate(actor: SchemeExp, args: List[SchemeExp], pos: Position) extends SchemeExp with Product with Serializable

     Create an actor from a behavior

157.  case class SchemeDefineFunction(name: Identifier, args: List[Identifier], body: List[SchemeExp], pos: Position) extends SchemeExp with Product with Serializable

     A function definition: (define (name args...) body...)

158.  case class SchemeDefineVariable(name: Identifier, value: SchemeExp, pos: Position) extends SchemeExp with Product with Serializable

     A variable definition: (define name value)

159.  case class SchemeDo(vars: List[(Identifier, SchemeExp, Option[SchemeExp])], test: SchemeExp, finals: List[SchemeExp], commands: List[SchemeExp], pos: Position) extends SchemeExp with Product with Serializable

     Do notation: (do ((<variable1> <init1> <step1>) ...) (<test> <expression> ...) <command> ...)

160.  trait SchemeExp extends AnyRef

     Abstract syntax of Scheme programs (probably far from complete)

161.  case class SchemeFuncall(f: SchemeExp, args: List[SchemeExp], pos: Position) extends SchemeExp with Product with Serializable

     A function call: (f args...)

162.  case class SchemeIf(cond: SchemeExp, cons: SchemeExp, alt: SchemeExp, pos: Position) extends SchemeExp with Product with Serializable

     An if statement: (if cond cons alt) If without alt clauses need to be encoded with an empty begin as alt clause

163.  case class SchemeJoin(exp: SchemeExp, pos: Position) extends SchemeExp with Product with Serializable

     Wait for a thread (whose identifier is the value of exp) to terminate

164.  case class SchemeLambda(args: List[Identifier], body: List[SchemeExp], pos: Position) extends SchemeExp with Product with Serializable

     A lambda expression: (lambda (args...) body...) Not supported: "rest"-arguments, of the form (lambda arg body), or (lambda (arg1 .

     A lambda expression: (lambda (args...) body...) Not supported: "rest"-arguments, of the form (lambda arg body), or (lambda (arg1 . args) body...)

165.  trait SchemeLattice extends AnyRef
166.  case class SchemeLet(bindings: List[(Identifier, SchemeExp)], body: List[SchemeExp], pos: Position) extends SchemeExp with Product with Serializable

     Let-bindings: (let ((v1 e1) ...) body...)

167.  case class SchemeLetStar(bindings: List[(Identifier, SchemeExp)], body: List[SchemeExp], pos: Position) extends SchemeExp with Product with Serializable

     Let*-bindings: (let* ((v1 e1) ...) body...)

168.  case class SchemeLetrec(bindings: List[(Identifier, SchemeExp)], body: List[SchemeExp], pos: Position) extends SchemeExp with Product with Serializable

     Letrec-bindings: (letrec ((v1 e1) ...) body...)

169.  case class SchemeNamedLet(name: Identifier, bindings: List[(Identifier, SchemeExp)], body: List[SchemeExp], pos: Position) extends SchemeExp with Product with Serializable

     Named-let: (let name ((v1 e1) ...) body...)

170.  case class SchemeOr(exps: List[SchemeExp], pos: Position) extends SchemeExp with Product with Serializable

     An or expression: (or exps...)

171.  class SchemePrimitives[Addr, Abs] extends Primitives[Addr, Abs]

     This is where we define Scheme primitives

172.  case class SchemeQuoted(quoted: SExp, pos: Position) extends SchemeExp with Product with Serializable

     A quoted expression: '(foo (bar baz)) The quoted expression is *not* converted to a Scheme expression, and remains a simple s-expression, because that's exactly what it should be.

173.  case class SchemeRelease(exp: SchemeExp, pos: Position) extends SchemeExp with Product with Serializable

     Release a lock

174.  class SchemeSemantics[V, Addr, Time] extends BaseSchemeSemantics[V, Addr, Time]

     Extend base Scheme semantics with:

     Extend base Scheme semantics with:

     • atomic evaluation: parts of some constructs can be evaluated atomically without needing to introduce more states in the state graph. For example, (+ 1 1) can directly be evaluated to 2 without modifying the store. Also, to evaluate (+ 1 (f)), we can directly push the continuation and jump to the evaluation of (f), instead of evaluating +, and 1 in separate states.
175.  case class SchemeSend(target: SchemeExp, message: Identifier, args: List[SchemeExp], pos: Position) extends SchemeExp with Product with Serializable

     Send a message to an actor

176.  case class SchemeSet(variable: Identifier, value: SchemeExp, pos: Position) extends SchemeExp with Product with Serializable

     A set! expression: (set! variable value)

177.  case class SchemeSpawn(exp: SchemeExp, pos: Position) extends SchemeExp with Product with Serializable

     Spawn a new thread to compute an expression

178.  case class SchemeTerminate(pos: Position) extends SchemeExp with Product with Serializable

     Terminate the execution of an actor

179.  case class SchemeValue(value: Value, pos: Position) extends SchemeExp with Product with Serializable

     A literal value (number, symbol, string, ...)

180.  case class SchemeVar(id: Identifier) extends SchemeExp with Product with Serializable

     An identifier: name

181.  trait SemanticError extends AnyRef
182.  abstract class Semantics[Exp, Abs, Addr, Time] extends AnyRef

     This is where the interface of a language's semantics is defined.

     This is where the interface of a language's semantics is defined. By defining the semantics of a language, you get an abstract abstract machine for free (but you might need to adapt existing lattices to support values from your language).

     Semantics should be defined as small-step operational semantics. To define a semantics, you have to implement the Semantics trait. You'll need to specialize it on the type of expression of your language (e.g., for ANF, ANFSemantics specializes on ANFExp). To do so, you need to define what actions should be taken when:

     1. Evaluating an expression e (stepEval) 2. Continuing evaluation when a value v has been reached (stepKont)

     To have a simple overview of how semantics should be defined, look at the ANFSemantics.scala, as it defines semantics of ANF Scheme, a very lightweight language. A more complex definition resides in SchemeSemantics.scala.

183.  class SemanticsWithAnalysis[L, Exp, Abs, Addr, Time] extends Semantics[Exp, Abs, Addr, Time]
184.  case class SomePosition(p: scala.util.parsing.input.Position) extends Position with Product with Serializable

     The actual wrapper

185.  abstract class Store[Addr, Abs] extends AnyRef
186.  trait StringLattice[S] extends LatticeElement[S]

     A lattice for strings

187.  trait SymbolLattice[Sym] extends LatticeElement[Sym]

     A lattice for symbols

188.  class TSchemePrimitives[Addr, Abs] extends SchemePrimitives[Addr, Abs]
189.  case class TaintAnalysis[Abs, Addr, Time]()(implicit evidence$26: JoinLattice[Abs], evidence$27: Address[Addr], evidence$28: Timestamp[Time]) extends Analysis[Set[(Position, Position)], SchemeExp, Abs, Addr, Time] with Product with Serializable
190.  case class TaintError(sources: Set[Position], sink: Position) extends SemanticError with Product with Serializable
191.  class TaintLattice[Abs] extends SchemeLattice
192.  sealed trait TaintStatus extends AnyRef
193.  case class Tainted(sources: Set[Position]) extends TaintStatus with Product with Serializable
194.  trait ThreadIdentifier[TID] extends AnyRef
195.  class Timeout extends AnyRef
196.  trait Timestamp[T] extends AnyRef
197.  trait TimestampWrapper extends AnyRef
198.  case class TimestampedKontStore[KontAddr](content: Map[KontAddr, Set[Kont[KontAddr]]], timestamp: Int)(implicit evidence$4: KontAddress[KontAddr]) extends KontStore[KontAddr] with Product with Serializable
199.  case class TypeError(name: String, operand: String, expected: String, got: String) extends SemanticError with Product with Serializable
200.  case class UnboundAddress(addr: String) extends SemanticError with Product with Serializable
201.  case class UnboundVariable(name: Identifier) extends SemanticError with Product with Serializable
202.  case class UnboundVariablesAnalysis[Abs, Addr, Time]()(implicit evidence$15: JoinLattice[Abs], evidence$16: Address[Addr], evidence$17: Timestamp[Time]) extends Analysis[Set[LamExp], LamExp, Abs, Addr, Time] with Product with Serializable

     This is our unbound variables analysis.

     This is our unbound variables analysis. We want to detect, for a lambda-calculus program, which evaluated variables may be unbound. We represent this by a set of lambda expressions, which is the lattice computed by this analysis: Set[LamExp]. This class defines how to update the current state of the analysis.

203.  case class UserError(reason: String, pos: Position) extends SemanticError with Product with Serializable
204.  sealed abstract class Value extends AnyRef

     S-expressions and related values

205.  case class ValueBoolean(value: Boolean) extends Value with Product with Serializable
206.  case class ValueCharacter(value: Char) extends Value with Product with Serializable
207.  case class ValueInteger(value: Int) extends Value with Product with Serializable
208.  case class ValueReal(value: Double) extends Value with Product with Serializable
209.  case class ValueString(value: String) extends Value with Product with Serializable
210.  case class ValueSymbol(sym: String) extends Value with Product with Serializable
211.  case class Var(x: Identifier, pos: Position) extends LamExp with Product with Serializable

     A variable reference: x

212.  case class VariadicArityError(name: String, min: Int, got: Int) extends SemanticError with Product with Serializable
213.  trait VisitedSet[L[_]] extends AnyRef
214.  trait WithKey[A] extends AnyRef
215.  trait WorkList[L[_]] extends AnyRef