scala.tools.nsc.interpreter

IMain

class IMain extends Imports

An interpreter for Scala code.

The main public entry points are compile(), interpret(), and bind(). The compile() method loads a complete Scala file. The interpret() method executes one line of Scala code at the request of the user. The bind() method binds an object to a variable that can then be used by later interpreted code.

The overall approach is based on compiling the requested code and then using a Java classloader and Java reflection to run the code and access its results.

In more detail, a single compiler instance is used to accumulate all successfully compiled or interpreted Scala code. To "interpret" a line of code, the compiler generates a fresh object that includes the line of code and which has public member(s) to export all variables defined by that code. To extract the result of an interpreted line to show the user, a second "result object" is created which imports the variables exported by the above object and then exports members called "$eval" and "$print". To accomodate user expressions that read from variables or methods defined in previous statements, "import" statements are used.

This interpreter shares the strengths and weaknesses of using the full compiler-to-Java. The main strength is that interpreted code behaves exactly as does compiled code, including running at full speed. The main weakness is that redefining classes and methods is not handled properly, because rebinding at the Java level is technically difficult.

Self Type
IMain
Source
IMain.scala
Linear Supertypes
Imports, AnyRef, Any
Known Subclasses
ILoopInterpreter, Interpreter
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. Hide All
  2. Show all
  1. IMain
  2. Imports
  3. AnyRef
  4. Any
Visibility
  1. Public
  2. All

Instance Constructors

  1. new IMain()

  2. new IMain(settings: Settings)

    construct an interpreter that reports to Console

  3. new IMain(initialSettings: Settings, out: JPrintWriter)

Type Members

  1. case class ComputedImports(prepend: String, append: String, access: String) extends Product with Serializable

    Compute imports that allow definitions from previous requests to be visible in a new request.

  2. class ReadEvalPrint extends AnyRef

    Here is where we:

  3. class ReplTypeOps extends AnyRef

  4. class Request extends AnyRef

    One line of code submitted by the user for interpretation

Value Members

  1. final def !=(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  2. final def !=(arg0: Any): Boolean

    Definition Classes
    Any

  3. final def ##(): Int

    Definition Classes
    AnyRef → Any

  4. final def ==(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  5. final def ==(arg0: Any): Boolean

    Definition Classes
    Any

  6. def addImports(ids: String*): Result

  7. def afterTyper[T](op: ⇒ T): T

  8. def aliasForType(path: String): Option[String]

    Parse the ScalaSig to find type aliases

  9. def allDefinedNames: List[Name]

  10. def allImplicits: List[Name { ... /* 5 definitions in type refinement */ }]

  11. def allImportedNames: List[Name]

    Definition Classes
    Imports

  12. def allSeenTypes: List[String]

  13. def apply[T](implicit arg0: ClassManifest[T]): Symbol

  14. def apply(name: String): Symbol

    Translate a repl-defined identifier into a Symbol.

  15. final def asInstanceOf[T0]: T0

    Definition Classes
    Any

  16. def atPickler[T](op: ⇒ T): T

  17. def beQuietDuring[T](body: ⇒ T): T

    Temporarily be quiet

  18. def beSilentDuring[T](operation: ⇒ T): T

  19. def bind[T](name: String, value: T)(implicit arg0: Manifest[T]): Result

  20. def bind(p: NamedParam): Result

  21. def bind(name: String, boundType: String, value: Any): Result

    Bind a specified name to a specified value.

    Bind a specified name to a specified value. The name may later be used by expressions passed to interpret.

    name

    the variable name to bind

    boundType

    the type of the variable, as a string

    value

    the object value to bind to it

    returns

    an indication of whether the binding succeeded

  22. def bindValue(name: String, x: Any): Result

  23. def bindValue(x: Any): Result

  24. def classLoader: AbstractFileClassLoader

  25. def classOfTerm(id: String): Option[JClass]

  26. def clearExecutionWrapper(): Unit

  27. def clone(): AnyRef

    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws()

  28. def close(): Unit

    This instance is no longer needed, so release any resources it is using.

    This instance is no longer needed, so release any resources it is using. The reporter's output gets flushed.

  29. def compileSources(sources: SourceFile*): Boolean

    Compile an nsc SourceFile.

    Compile an nsc SourceFile. Returns true if there are no compilation errors, or false otherwise.

  30. def compileSourcesKeepingRun(sources: SourceFile*): (Boolean, Run)

  31. def compileString(code: String): Boolean

    Compile a string.

    Compile a string. Returns true if there are no compilation errors, or false otherwise.

  32. lazy val compiler: IMain.this.global.type

  33. def compilerClasspath: Seq[URL]

  34. def createLineManager(classLoader: ClassLoader): Manager

    Attributes
    protected

  35. def debugging[T](msg: String)(res: T): T

  36. def definedSymbols: Set[Symbol]

  37. def definedTerms: List[TermName]

  38. def definedTypes: List[TypeName]

  39. def definitionForName(name: Name): Option[MemberHandler]

  40. def directBind[T](name: String, value: T)(implicit arg0: Manifest[T]): Result

  41. def directBind(p: NamedParam): Result

  42. def directBind(name: String, boundType: String, value: Any): Result

  43. final def ensureClassLoader(): Unit

  44. final def eq(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  45. def equals(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any

  46. def executionWrapper: String

  47. def finalize(): Unit

    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws()

  48. def flatName(id: String): String

  49. lazy val formatting: Formatting

  50. def generatedName(simpleName: String): Option[String]

    Given a simple repl-defined name, returns the real name of the class representing it, e.

    Given a simple repl-defined name, returns the real name of the class representing it, e.g. for "Bippy" it may return

       $line19.$read$$iw$$iw$$iw$$iw$$iw$$iw$$iw$$iw$Bippy

  51. final def getClass(): Class[_]

    Definition Classes
    AnyRef → Any

  52. def getInterpreterClassLoader(): AbstractFileClassLoader

  53. lazy val global: Global

    the public, go through the future compiler

  54. def handleTermRedefinition(name: TermName, old: Request, req: Request): Unit

  55. def handleTypeRedefinition(name: TypeName, old: Request, req: Request): Unit

    Stubs for work in progress.

  56. def hashCode(): Int

    Definition Classes
    AnyRef → Any

  57. def implicitSymbols: List[Symbol]

    Definition Classes
    Imports

  58. def implicitSymbolsBySource: List[(Symbol, List[Symbol])]

    Definition Classes
    Imports

  59. def importHandlers: List[ImportHandler]

  60. def importedSymbols: List[Symbol]

    Definition Classes
    Imports

  61. def importedSymbolsBySource: List[(Symbol, List[Symbol])]

    Tuples of (source, imported symbols) in the order they were imported.

    Tuples of (source, imported symbols) in the order they were imported.

    Definition Classes
    Imports

  62. def importedTermNamed(name: String): Symbol

    Definition Classes
    Imports

  63. def importedTermSymbols: List[TermSymbol]

    Definition Classes
    Imports

  64. def importedTerms: List[TermName]

    Definition Classes
    Imports

  65. def importedTypeSymbols: List[TypeSymbol]

    Definition Classes
    Imports

  66. def importedTypes: List[TypeName]

    Definition Classes
    Imports

  67. def importsCode(wanted: Set[Name]): ComputedImports

    Attributes
    protected
    Definition Classes
    Imports

  68. def initialize(postInitSignal: ⇒ Unit): Unit

  69. def initializeSynchronous(): Unit

  70. implicit def installReplTypeOps(tp: Type): ReplTypeOps

  71. def interpret(line: String, synthetic: Boolean): Result

  72. def interpret(line: String): Result

    Interpret one line of input.

    Interpret one line of input. All feedback, including parse errors and evaluation results, are printed via the supplied compiler's reporter. Values defined are available for future interpreted strings.

    The return value is whether the line was interpreter successfully, e.g. that there were no parse errors.

  73. def isInitializeComplete: Boolean

  74. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any

  75. def isNoImports: Boolean

    Definition Classes
    Imports

  76. def isNoPredef: Boolean

    Definition Classes
    Imports

  77. def isParseable(line: String): Boolean

  78. lazy val isettings: ISettings

    interpreter settings

  79. def languageSymbols: List[Symbol]

    Definition Classes
    Imports

  80. def languageWildcardHandlers: List[ImportHandler]

    Definition Classes
    Imports

  81. def languageWildcardSyms: List[Symbol]

    Symbols whose contents are language-defined to be imported.

    Symbols whose contents are language-defined to be imported.

    Definition Classes
    Imports

  82. def languageWildcards: List[Type]

    Definition Classes
    Imports

  83. def lastWarnings: List[(Position, String)]

  84. def lineManager: Manager

  85. lazy val memberHandlers: MemberHandlers { val intp: IMain.this.type }

  86. def mostRecentLine: String

  87. def mostRecentVar: String

    Returns the name of the most recent interpreter result.

    Returns the name of the most recent interpreter result. Mostly this exists so you can conveniently invoke methods on the previous result.

  88. def namedDefinedTerms: List[TermName]

  89. object naming extends Naming

  90. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  91. def newCompiler(settings: Settings, reporter: Reporter): Global

    Instantiate a compiler.

    Instantiate a compiler. Overridable.

    Attributes
    protected

  92. def noLineManager: Boolean

    Create a line manager.

    Create a line manager. Overridable.

    Attributes
    protected

  93. final def notify(): Unit

    Definition Classes
    AnyRef

  94. final def notifyAll(): Unit

    Definition Classes
    AnyRef

  95. def onlyTerms(xs: List[Name]): List[TermName]

    Attributes
    protected

  96. def onlyTypes(xs: List[Name]): List[TypeName]

    Attributes
    protected

  97. def optFlatName(id: String): Option[String]

  98. val out: JPrintWriter

    Attributes
    protected

  99. def parentClassLoader: ClassLoader

    Parent classloader.

    Parent classloader. Overridable.

    Attributes
    protected

  100. def parse(line: String): Option[List[Tree]]

  101. def pathToName(name: Name): String

  102. def pathToTerm(id: String): String

  103. def pathToType(id: String): String

  104. def prettyPrint(code: String): Unit

  105. def prevRequestList: List[Request]

    Attributes
    protected

  106. def quietBind(p: NamedParam): Result

  107. def quietImport(ids: String*): Result

  108. def quietRun[T](code: String): Result

  109. def rebind(p: NamedParam): Result

  110. def recordRequest(req: Request): Unit

  111. object replTokens extends ReplTokens

  112. lazy val repllog: Logger

  113. lazy val reporter: ConsoleReporter

  114. def requestForIdent(line: String): Option[Request]

  115. def requestForName(name: Name): Option[Request]

  116. def requestHistoryForName(name: Name): List[Request]

  117. def rerunForWarnings: Result

  118. def rerunWith(names: String*): Result

  119. def reset(): Unit

    Reset this interpreter, forgetting all user-specified requests.

  120. def resetClassLoader(): Unit

  121. def runtimeClassAndTypeOfTerm(id: String): Option[(JClass, Type)]

  122. def runtimeTypeOfTerm(id: String): Type

  123. def savingSettings[T](fn: (Settings) ⇒ Unit)(body: ⇒ T): T

  124. def sessionImportedSymbols: List[Symbol]

    Definition Classes
    Imports

  125. def sessionWildcards: List[Type]

    Types which have been wildcard imported, such as: val x = "abc" ; import x.

    Types which have been wildcard imported, such as: val x = "abc" ; import x._ // type java.lang.String import java.lang.String._ // object java.lang.String

    Used by tab completion.

    XXX right now this gets import x._ and import java.lang.String._, but doesn't figure out import String._. There's a lot of ad hoc scope twiddling which should be swept away in favor of digging into the compiler scopes.

    Definition Classes
    Imports

  126. def setContextClassLoader(): Unit

  127. def setExecutionWrapper(code: String): Unit

  128. def settings: Settings

  129. def showCodeIfDebugging(code: String): Unit

  130. def symbolDefString(sym: Symbol): String

  131. def symbolOfTerm(id: String): Symbol

  132. final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes
    AnyRef

  133. def terms[T](implicit arg0: ClassManifest[T]): Symbol

  134. def terms(name: String): Symbol

  135. def toString(): String

    Definition Classes
    AnyRef → Any

  136. def typeCleanser(sym: Symbol, memberName: Name): Type

  137. def typeOfExpression(expr: String, silent: Boolean = true): Type

  138. def typeOfTerm(id: String): Type

  139. def types[T](implicit arg0: ClassManifest[T]): Symbol

  140. def types(name: String): Symbol

  141. def unqualifiedIds: List[String]

    Another entry point for tab-completion, ids in scope

  142. def valueOfTerm(id: String): Option[AnyRef]

  143. val virtualDirectory: VirtualDirectory

    Leading with the eagerly evaluated.

  144. def visibleTermNames: List[Name]

  145. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws()

  146. final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws()

  147. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws()

  148. def wildcardTypes: List[Type]

    Definition Classes
    Imports

  149. def withoutUnwrapping(op: ⇒ Unit): Unit

Inherited from Imports

Inherited from AnyRef

Inherited from Any