org.kiama.example.iswim.driver.Main

Type Members

type Elem = Char

Definition Classes
RegexParsers → Parsers
type Input = Reader[Elem]

Definition Classes
Parsers
case class Pos(s: String) extends Positioned with Product with Serializable

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
def OnceParser[T](f: (Input) ⇒ ParseResult[T]): Parser[T] with OnceParser[T]

Definition Classes
PositionedParserUtilities → Parsers
def Parser[T](f: (Input) ⇒ ParseResult[T]): Parser[T]

Definition Classes
PositionedParserUtilities → Parsers
def accept[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

Definition Classes
Parsers
def accept[ES](es: ES)(implicit arg0: (ES) ⇒ List[Elem]): Parser[List[Elem]]

Definition Classes
Parsers
implicit def accept(e: Elem): Parser[Elem]

Definition Classes
Parsers
def acceptIf(p: (Elem) ⇒ Boolean)(err: (Elem) ⇒ String): Parser[Elem]

Definition Classes
Parsers
def acceptMatch[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

Definition Classes
Parsers
def acceptSeq[ES](es: ES)(implicit arg0: (ES) ⇒ Iterable[Elem]): Parser[List[Elem]]

Definition Classes
Parsers
def any: PackratParser[Char]

Definition Classes
ParserUtilities
lazy val applic: PackratParser[Expr]

Definition Classes
Parser
final def asInstanceOf[T0]: T0

Definition Classes
Any
def bindexpr(rhsexpr: PackratParser[Expr]): PackratParser[Binding]

Parse let and letrec expressions
Parse let and letrec expressions

Definition Classes
Parser
lazy val blockexpr: PackratParser[Expr]

Parse code blocks
Parse code blocks

Definition Classes
Parser
lazy val callccexpr: PackratParser[Expr]

Continuation handling.
Continuation handling.

Definition Classes
Parser
def chainl1[T, U](first: ⇒ Parser[T], p: ⇒ Parser[U], q: ⇒ Parser[(T, U) ⇒ T]): Parser[T]

Definition Classes
Parsers
def chainl1[T](p: ⇒ Parser[T], q: ⇒ Parser[(T, T) ⇒ T]): Parser[T]

Definition Classes
Parsers
def chainr1[T, U](p: ⇒ Parser[T], q: ⇒ Parser[(T, U) ⇒ U], combine: (T, U) ⇒ U, first: U): Parser[U]

Definition Classes
Parsers
def clone(): AnyRef

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws()
val code: (Iswim) ⇒ CodeTree

The following attribute contains the SECD bytecode generated from the ISWIM syntax node it is attached to.
The following attribute contains the SECD bytecode generated from the ISWIM syntax node it is attached to.

Definition Classes
CodeGenerator
lazy val comment: PackratParser[Any]

Definition Classes
Parser
def commit[T](p: ⇒ Parser[T]): Parser[T]

Definition Classes
Parsers
implicit def constToTupleFunction2[A, B, R](r: (A, B) ⇒ R): (~[A, B]) ⇒ R

Definition Classes
ParserUtilities
implicit def constToTupleFunction3[A, B, C, R](r: (A, B, C) ⇒ R): (~[~[A, B], C]) ⇒ R

Definition Classes
ParserUtilities
implicit def constToTupleFunction4[A, B, C, D, R](r: (A, B, C, D) ⇒ R): (~[~[~[A, B], C], D]) ⇒ R

Definition Classes
ParserUtilities
implicit def constToTupleFunction5[A, B, C, D, E, R](r: (A, B, C, D, E) ⇒ R): (~[~[~[~[A, B], C], D], E]) ⇒ R

Definition Classes
ParserUtilities
implicit def constToTupleFunction6[A, B, C, D, E, F, R](r: (A, B, C, D, E, F) ⇒ R): (~[~[~[~[~[A, B], C], D], E], F]) ⇒ R

Definition Classes
ParserUtilities
lazy val constrainedInt: PackratParser[Int]

Definition Classes
ParserUtilities
def decimalNumber: Parser[String]

Definition Classes
JavaTokenParsers
def elem(e: Elem): Parser[Elem]

Definition Classes
Parsers
def elem(kind: String, p: (Elem) ⇒ Boolean): Parser[Elem]

Definition Classes
Parsers
val emitter: Emitter

Definition Classes
StdoutEmitter
lazy val emptyexpr: PackratParser[Expr]

Parse tuple / record expressions
Parse tuple / record expressions

Definition Classes
Parser
val envir: (Iswim) ⇒ Map[Variable, Iswim]

Simple name analysis - using an environment All we need to do here is check that at use sites all variables have been bound by an enclosing let, letrec or function parameter.
Simple name analysis - using an environment All we need to do here is check that at use sites all variables have been bound by an enclosing let, letrec or function parameter.

Definition Classes
SemanticAnalysis
val envirOut: (Iswim) ⇒ Map[Variable, Iswim]

Definition Classes
SemanticAnalysis
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def err(msg: String): Parser[Nothing]

Definition Classes
ParserUtilities → Parsers
lazy val expr: PackratParser[Expr]

Definition Classes
Parser
lazy val exprstmt: PackratParser[Stmt]

Definition Classes
Parser
lazy val factor: PackratParser[Expr]

Definition Classes
Parser
def failure(msg: String): Parser[Nothing]

Definition Classes
ParserUtilities → Parsers
def finalize(): Unit

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws()
def floatingPointNumber: Parser[String]

Definition Classes
JavaTokenParsers
final def getClass(): java.lang.Class[_]

Definition Classes
AnyRef → Any
def guard[T](p: ⇒ Parser[T]): Parser[T]

Definition Classes
Parsers
def handleWhiteSpace(in: Input): Int

Definition Classes
WhitespacePositionedParserUtilities → ParserUtilities
def handleWhiteSpace(source: CharSequence, offset: Int): Int

Attributes
protected
Definition Classes
RegexParsers
def hashCode(): Int

Definition Classes
AnyRef → Any
def ident: Parser[String]

Definition Classes
JavaTokenParsers
lazy val identRegex: Regex

Definition Classes
Parser
lazy val ifelseexpr: PackratParser[Expr]

Parse if .
Parse if ... then ... else ...

Definition Classes
Parser
lazy val importstmt: PackratParser[Stmt]

Definition Classes
Parser
lazy val intRegex: Regex

Definition Classes
Parser
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
val isSemanticallyCorrect: (Iswim) ⇒ Boolean

Definition Classes
SemanticAnalysis
def keyword(k: String): Parser[Pos]

Definition Classes
Parser
def keywords(ext: Regex, kws: List[String]): Parser[String]

Definition Classes
ParserUtilities
lazy val lambdaexpr: PackratParser[Expr]

Parse lambda (fun) expressions
Parse lambda (fun) expressions

Definition Classes
Parser
var lastNoSuccess: NoSuccess

Definition Classes
Parsers
lazy val letexpr: PackratParser[Expr]

Definition Classes
Parser
lazy val letrecexpr: PackratParser[Expr]

Definition Classes
Parser
lazy val letrecstmt: PackratParser[Stmt]

Definition Classes
Parser
lazy val letstmt: PackratParser[Stmt]

Parse toplevel statements
Parse toplevel statements

Definition Classes
Parser
lazy val liter: Parser[Expr]

Literals, identifiers, keywords and other atomic phrases
Literals, identifiers, keywords and other atomic phrases

Definition Classes
Parser
implicit def literal(s: String): Parser[String]

Definition Classes
WhitespaceParser → RegexParsers
def log[T](p: ⇒ Parser[T])(name: String): Parser[T]

Definition Classes
Parsers
def main(args: Array[String]): Unit
lazy val matchclause: PackratParser[MatchClause]

Definition Classes
Parser
lazy val matchexpr: PackratParser[Expr]

Definition Classes
Parser
def memo[T](p: Parser[T]): PackratParser[T]

Definition Classes
PackratParsers
def mkList[T]: (~[T, List[T]]) ⇒ List[T]

Definition Classes
Parsers
lazy val mkrefexpr: PackratParser[Expr]

Definition Classes
Parser
def name(msg: String): Parser[Variable]

Definition Classes
Parser
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def not[T](p: ⇒ Parser[T]): Parser[Unit]

Definition Classes
Parsers
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def operator(op: String): Parser[Pos]

Definition Classes
Parser
def opt[T](p: ⇒ Parser[T]): Parser[Option[T]]

Definition Classes
Parsers
lazy val parenexpr: PackratParser[Expr]

Precedence based infix expression parsers.
Precedence based infix expression parsers. Ordered from highest to lowest precedence.

Definition Classes
Parser
def parse[T](p: Parser[T], in: Reader): ParseResult[T]

Definition Classes
RegexParsers
def parse[T](p: Parser[T], in: CharSequence): ParseResult[T]

Definition Classes
RegexParsers
def parse[T](p: Parser[T], in: Reader[Char]): ParseResult[T]

Definition Classes
RegexParsers
def parseAll[T](p: Parser[T], in: CharSequence): ParseResult[T]

Definition Classes
RegexParsers
def parseAll[T](p: Parser[T], in: Reader): ParseResult[T]

Definition Classes
RegexParsers
def parseAll[T](p: Parser[T], in: Reader[Char]): ParseResult[T]

Definition Classes
RegexParsers
def parseAndPosition[T](f: (Input) ⇒ ParseResult[T], in: Input): ParseResult[T]

Definition Classes
PositionedParserUtilities
implicit def parseResultToTuple2[A, B](p: Parser[~[A, B]]): PackratParser[(A, B)]

Definition Classes
ParserUtilities
implicit def parseResultToTuple3[A, B, C](p: Parser[~[~[A, B], C]]): PackratParser[(A, B, C)]

Definition Classes
ParserUtilities
implicit def parseResultToTuple4[A, B, C, D](p: Parser[~[~[~[A, B], C], D]]): PackratParser[(A, B, C, D)]

Definition Classes
ParserUtilities
implicit def parseResultToTuple5[A, B, C, D, E](p: Parser[~[~[~[~[A, B], C], D], E]]): PackratParser[(A, B, C, D, E)]

Definition Classes
ParserUtilities
implicit def parseResultToTuple6[A, B, C, D, E, F](p: Parser[~[~[~[~[~[A, B], C], D], E], F]]): PackratParser[(A, B, C, D, E, F)]

Definition Classes
ParserUtilities
def parseString[T](parser: Parser[T], str: String): Either[T, String]

Definition Classes
ParserUtilities
def parseWhitespace(in: Input): ParseResult[Any]

Attributes
protected
Definition Classes
WhitespaceParser
implicit def parser2packrat[T](p: ⇒ Parser[T]): PackratParser[T]

Definition Classes
PackratParsers
var parsingWhitespace: Boolean

Attributes
protected
Definition Classes
WhitespaceParser
lazy val pattern: PackratParser[(Pos, List[Variable])]

Definition Classes
Parser
def phrase[T](p: Parser[T]): PackratParser[T]

Definition Classes
PackratParsers → Parsers
def positioned[T <: Positional](p: ⇒ Parser[T]): Parser[T]

Definition Classes
WhitespaceParser → RegexParsers → Parsers
lazy val primstmt: PackratParser[Stmt]

Primitives
Primitives

Definition Classes
Parser
implicit def regex(r: Regex): Parser[String]

Definition Classes
WhitespaceParser → RegexParsers
def regexnows(r: Regex): Parser[String]

Definition Classes
ParserUtilities
def rep[T](p: ⇒ Parser[T]): Parser[List[T]]

Definition Classes
Parsers
def rep1[T](first: ⇒ Parser[T], p0: ⇒ Parser[T]): Parser[List[T]]

Definition Classes
Parsers
Annotations
@migration
Migration
(Changed in version 2.9.0) The p0 call-by-name arguments is evaluated at most once per constructed Parser object, instead of on every need that arises during parsing.
def rep1[T](p: ⇒ Parser[T]): Parser[List[T]]

Definition Classes
Parsers
def rep1sep[T](p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]

Definition Classes
Parsers
def repN[T](num: Int, p: ⇒ Parser[T]): Parser[List[T]]

Definition Classes
Parsers
def repsep[T](p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]

Definition Classes
Parsers
val reserved: HashSet[String]

Identifiers - keywords and names.
Identifiers - keywords and names.

Definition Classes
Parser
def result[T](v: ⇒ T): Parser[T]

Definition Classes
ParserUtilities
lazy val returnexpr: PackratParser[Expr]

Parse return expressions
Parse return expressions

Definition Classes
Parser
def skipWhitespace: Boolean

Definition Classes
WhitespaceParser → RegexParsers
lazy val start: PackratParser[IswimProg]

Top level parsers
Top level parsers

Definition Classes
Parser
def stringLiteral: Parser[String]

Definition Classes
JavaTokenParsers
def stringToInt(s: String): Either[Int, String]

Definition Classes
ParserUtilities
def success[T](v: T): Parser[T]

Definition Classes
Parsers
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
lazy val term1: PackratParser[Expr]

Definition Classes
Parser
lazy val term2: PackratParser[Expr]

Definition Classes
Parser
lazy val term3: PackratParser[Expr]

Definition Classes
Parser
lazy val term4: PackratParser[Expr]

Definition Classes
Parser
lazy val throwtoexpr: PackratParser[Expr]

Definition Classes
Parser
def toString(): String

Definition Classes
AnyRef → Any
lazy val tupleexpr: PackratParser[Expr]

Definition Classes
Parser
val unreachable: (MatchClause) ⇒ Boolean

Check for match clauses which are unreachable because they are preceeded by a clauses which match any value.
Check for match clauses which are unreachable because they are preceeded by a clauses which match any value.

Definition Classes
SemanticAnalysis
lazy val valexpr: PackratParser[Expr]

References.
References.

Definition Classes
Parser
lazy val variable: Parser[Variable]

Definition Classes
Parser
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws()
lazy val whileexpr: PackratParser[Expr]

Parse while expression
Parse while expression

Definition Classes
Parser
val whiteSpace: Regex

Attributes
protected
Definition Classes
RegexParsers
lazy val whitespaceParser: PackratParser[Any]

Definition Classes
Parser → WhitespaceParser
def wholeNumber: Parser[String]

Definition Classes
JavaTokenParsers
def wrap[T, U](p: ⇒ Parser[T], f: (T) ⇒ Either[U, String]): Parser[U]

Definition Classes
ParserUtilities

Main

object Main extends Parser with SemanticAnalysis with CodeGenerator with StdoutEmitter

Type Members

type Elem = Char

type Input = Reader[Elem]

case class Pos(s: String) extends Positioned with Product with Serializable

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def OnceParser[T](f: (Input) ⇒ ParseResult[T]): Parser[T] with OnceParser[T]

def Parser[T](f: (Input) ⇒ ParseResult[T]): Parser[T]

def accept[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

def accept[ES](es: ES)(implicit arg0: (ES) ⇒ List[Elem]): Parser[List[Elem]]

implicit def accept(e: Elem): Parser[Elem]

def acceptIf(p: (Elem) ⇒ Boolean)(err: (Elem) ⇒ String): Parser[Elem]

def acceptMatch[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

def acceptSeq[ES](es: ES)(implicit arg0: (ES) ⇒ Iterable[Elem]): Parser[List[Elem]]

def any: PackratParser[Char]

lazy val applic: PackratParser[Expr]

final def asInstanceOf[T0]: T0

def bindexpr(rhsexpr: PackratParser[Expr]): PackratParser[Binding]

lazy val blockexpr: PackratParser[Expr]

lazy val callccexpr: PackratParser[Expr]

def chainl1[T, U](first: ⇒ Parser[T], p: ⇒ Parser[U], q: ⇒ Parser[(T, U) ⇒ T]): Parser[T]

def chainl1[T](p: ⇒ Parser[T], q: ⇒ Parser[(T, T) ⇒ T]): Parser[T]

def chainr1[T, U](p: ⇒ Parser[T], q: ⇒ Parser[(T, U) ⇒ U], combine: (T, U) ⇒ U, first: U): Parser[U]

def clone(): AnyRef

val code: (Iswim) ⇒ CodeTree

lazy val comment: PackratParser[Any]

def commit[T](p: ⇒ Parser[T]): Parser[T]

implicit def constToTupleFunction2[A, B, R](r: (A, B) ⇒ R): (~[A, B]) ⇒ R

implicit def constToTupleFunction3[A, B, C, R](r: (A, B, C) ⇒ R): (~[~[A, B], C]) ⇒ R

implicit def constToTupleFunction4[A, B, C, D, R](r: (A, B, C, D) ⇒ R): (~[~[~[A, B], C], D]) ⇒ R

implicit def constToTupleFunction5[A, B, C, D, E, R](r: (A, B, C, D, E) ⇒ R): (~[~[~[~[A, B], C], D], E]) ⇒ R

implicit def constToTupleFunction6[A, B, C, D, E, F, R](r: (A, B, C, D, E, F) ⇒ R): (~[~[~[~[~[A, B], C], D], E], F]) ⇒ R

lazy val constrainedInt: PackratParser[Int]

def decimalNumber: Parser[String]

def elem(e: Elem): Parser[Elem]

def elem(kind: String, p: (Elem) ⇒ Boolean): Parser[Elem]

val emitter: Emitter

lazy val emptyexpr: PackratParser[Expr]

val envir: (Iswim) ⇒ Map[Variable, Iswim]

val envirOut: (Iswim) ⇒ Map[Variable, Iswim]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def err(msg: String): Parser[Nothing]

lazy val expr: PackratParser[Expr]

lazy val exprstmt: PackratParser[Stmt]

lazy val factor: PackratParser[Expr]

def failure(msg: String): Parser[Nothing]

def finalize(): Unit

def floatingPointNumber: Parser[String]

final def getClass(): java.lang.Class[_]

def guard[T](p: ⇒ Parser[T]): Parser[T]

def handleWhiteSpace(in: Input): Int

def handleWhiteSpace(source: CharSequence, offset: Int): Int

def hashCode(): Int

def ident: Parser[String]

lazy val identRegex: Regex

lazy val ifelseexpr: PackratParser[Expr]

lazy val importstmt: PackratParser[Stmt]

lazy val intRegex: Regex

final def isInstanceOf[T0]: Boolean

val isSemanticallyCorrect: (Iswim) ⇒ Boolean

def keyword(k: String): Parser[Pos]

def keywords(ext: Regex, kws: List[String]): Parser[String]

lazy val lambdaexpr: PackratParser[Expr]

var lastNoSuccess: NoSuccess

lazy val letexpr: PackratParser[Expr]

lazy val letrecexpr: PackratParser[Expr]

lazy val letrecstmt: PackratParser[Stmt]

lazy val letstmt: PackratParser[Stmt]

lazy val liter: Parser[Expr]

implicit def literal(s: String): Parser[String]

def log[T](p: ⇒ Parser[T])(name: String): Parser[T]

def main(args: Array[String]): Unit

lazy val matchclause: PackratParser[MatchClause]