Packages

p

root package

package root

Ordering
  1. Alphabetic
Visibility
  1. Public
  2. All

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

Value Members

  1. object AACKAlloc extends KAllocStrategy with Product with Serializable
  2. object AAMAACP4FBenchmarks extends Benchmarks
  3. object AAMKAlloc extends KAllocStrategy with Product with Serializable
  4. object ANF
  5. object ANFCompiler
  6. object ANFExp
  7. object ActorTimestamp
  8. object Address
  9. object AllInterleavings extends ExplorationType with Product with Serializable
  10. object BenchmarkGenerator
  11. object BenchmarkGeneratorConfig
  12. object BoolLattice
  13. object BottomTaint extends TaintStatus with Product with Serializable
  14. object Cardinality
  15. object CardinalityInf extends Cardinality with Product with Serializable
  16. object CardinalityPrimitiveLikeInf
  17. object CardinalityPrimitiveLikeNumber
  18. object CharLattice
  19. object ClassicalAddress extends AddressWrapper
  20. object Colors
  21. object Concrete

    Some implementations of these abstract domains

  22. object ConcreteBooleanEfficient
  23. object ConcreteTimestamp extends TimestampWrapper
  24. object Config

    This is where we parse the arguments given to the implementation

  25. object ConstantPropagation
  26. object ContextSensitiveTID
  27. object Count
  28. object CountInfinity extends Count with Product with Serializable
  29. object CountOne extends Count with Product with Serializable
  30. object CountingMap extends Serializable
  31. object DPOR extends ExplorationType with Product with Serializable
  32. object Dot
  33. object Effect
  34. object EffectKind
  35. object Environment
  36. object ExplorationTypeParser extends RegexParsers
  37. object Expression
  38. object Graph
  39. object GraphAnnotation
  40. object GraphDOTOutput extends GraphOutput
  41. object GraphJSONOutput extends GraphOutput
  42. object GraphNode
  43. object IdGen
  44. object InsensitiveTID
  45. object IntLattice
  46. object IsASchemeLattice extends Serializable
  47. object IsCSchemeLattice extends Serializable
  48. object IsSchemeLattice extends Serializable
  49. object IsTaintLattice extends Serializable
  50. object JSON
  51. object JoinLattice extends Serializable
  52. object Joined extends ExplorationType with Product with Serializable
  53. object KeyMap
  54. object KontStore
  55. object LamAnalysis

    We want to perform a simple static analysis on lambda-calculus programs.

    We want to perform a simple static analysis on lambda-calculus programs. We compute the possible unbound variables that are evaluated in the execution of a program.

  56. object LamExp

    We have to tell scala-am that LamExp are actually expressions

  57. object LamLattice extends Serializable
  58. object LamLatticeImpl

    Here's an implementation of this lattice

  59. object LatticeElement
  60. object Main

    Fork of Scala-AM (written by Quentin Stiévenart) https://github.com/acieroid/scala-am with the final goal to parallelize it: https://bitbucket.org/OPiMedia/scala-par-am

    Fork of Scala-AM (written by Quentin Stiévenart) https://github.com/acieroid/scala-am with the final goal to parallelize it: https://bitbucket.org/OPiMedia/scala-par-am

    Before looking at this, we recommend seeing how to use this framework. A detailed example is available in examples/LambdaCalculus.scala.

    This is the entry point. It parses the arguments, parses the input file and launches an abstract machine on the parsed expression (or launches a REPL if no input file is given). The pipeline goes as follows:

    1. The input program is parsed. For Scheme programs, it is done by:
      • Parsing the file as a list of s-expressions (exp/SExp.scala, exp/SExpParser.scala)
      • Compiling these s-expressions into Scheme expressions (exp/scheme/Scheme.scala)

    2. To run the program, we need an abstract machine and some semantics. Semantics definitions have to implement the Semantics interface (semantics/Semantics.scala).

    3. Once the abstract machine is created and we have a semantics for the program we want to analyze, the abstract machine can perform its evaluation, relying on methods of the semantics class to know how to evaluate expressions. The abstract machine only deals with which states to evaluate in which order, where to store values, where to store continuations, how to push and pop continuations, etc. The semantics encode what to do when encountering a program construct. For example, the semantics can tell what to evaluate next, that a continuation needs to be pushed, or that a variable needs to be updated. The abstract machine will then respectively evaluate the expression needed, push the continuation, or update the variable.

    Multiple abstract machine implementations are available, defined in the machine/ directory. Every abstract machine implementation has to implement the AbstractMachine interface (machine/AbstractMachine.scala).

    The abstract machine also uses a lattice to represent values. Lattices should implement the JoinLattice trait that can be found in lattice/JoinLattice.scala, which provides the basic features of a lattice.

    If you want to:

    • Support a new language: you will need:
      • A parser, you can look into exp/SExpParser.scala as an inspiration. If your language is s-expression based, you can use this parser and compile s-expressions into your abstract grammar. To do so, look at exp/scheme/Scheme.scala.
      • An abstract grammar, look at exp/SExp.scala or the SchemeExp class in exp/scheme/Scheme.scala.
      • A semantics, look at semantics/anf/ANFSemantics.scala for a simple example.
      • Support for your language operations at the lattice level. For this, you'll probably need to extend the lattices (see lattice/scheme/SchemeLattice.scala, lattice/scheme/ModularLattice.scala)
    • Play with abstract machines, you can look into AAM.scala.
    • Implement some kind of analysis, look at examples/LambdaCalculus.scala and examples/TaintAnalysis.scala.
  61. object MainAsScalaParAM

    Execute some abstract machines on some Scheme programs depending of some parameters.

    Execute some abstract machines on some Scheme programs depending of some parameters.

    Run with --help command line parameter to show all options: $ java -cp scala-am.jar MainAsScalaParAM --help

    This main program is used to interact with Scala-Par-AM https://bitbucket.org/OPiMedia/scala-par-am/ a parallel version of this Scala-AM.

  62. object MayFail
  63. object MboxSizeUnbounded extends MboxSize with Product with Serializable
  64. object MonoBenchmarks extends Benchmarks
  65. object OneInterleaving extends ExplorationType with Product with Serializable
  66. object P4FKAlloc extends KAllocStrategy with Product with Serializable
  67. object Position
  68. object Profiler
  69. object RandomInterleaving extends ExplorationType with Product with Serializable
  70. object ReadEffect extends EffectKind with Product with Serializable
  71. object RealLattice
  72. object SExpList
  73. object SExpParser extends TokenParsers
  74. object ScalaAM
  75. object Scheme
  76. object SchemeCompiler

    Object that provides a method to compile an s-expression into a Scheme expression

  77. object SchemeExp
  78. object SchemeLattices
  79. object SchemeOps
  80. object SchemeRenamer

    Object that provides a method to rename variables in a Scheme program in order to have only unique names.

    Object that provides a method to rename variables in a Scheme program in order to have only unique names. For example, (let ((x 1)) (let ((x 2)) x)) will be converted to (let ((_x0 1)) (let ((_x1 2)) _x1)). This is useful to perform ANF conversion.

  81. object SchemeUndefiner

    Remove defines from a Scheme expression, replacing them by let bindings.

    Remove defines from a Scheme expression, replacing them by let bindings. For example: (define foo 1) (define (f x) x) (f foo) Will be converted to: (letrec ((foo 1) (f (lambda (x) x))) (f foo)) Which is semantically equivalent with respect to the end result

  82. object SimpleBenchmarks extends Benchmarks
  83. object Store
  84. object StringLattice
  85. object SymbolLattice
  86. object TaintAnalysis extends Serializable
  87. object ThreadIdentifier
  88. object Timeout
  89. object Timestamp
  90. object Type
  91. object Untainted extends TaintStatus with Product with Serializable
  92. object Util
  93. object ValueNil extends Value
  94. object ValueSensitiveAddress extends AddressWrapper
  95. object VisitedSet
  96. object WithKey
  97. object WorkList
  98. object WriteEffect extends EffectKind with Product with Serializable
  99. object ZeroCFA extends TimestampWrapper

Ungrouped