org.kiama.example.til.TIL1

Type Members

type Elem = Char

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

Definition Classes
Parsers
type Root = Program

Definition Classes
TIL1_1

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
final def asInstanceOf[T0]: T0

Definition Classes
Any
lazy val assignment_statement: Parser[Assign]

Definition Classes
TIL1_1
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()
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
lazy val declaration: Parser[Decl]

Definition Classes
TIL1_1
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
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 expression: PackratParser[Exp]

Definition Classes
TIL1_1
lazy val factor: PackratParser[Exp]

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

Definition Classes
ParserUtilities → Parsers
def finalize(): Unit

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws()
lazy val for_statement: Parser[For]

Definition Classes
TIL1_1
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
ParserUtilities
def handleWhiteSpace(source: CharSequence, offset: Int): Int

Attributes
protected
Definition Classes
RegexParsers
def hashCode(): Int

Definition Classes
AnyRef → Any
lazy val identifier: Parser[Id]

Definition Classes
TIL1_1
lazy val if_statement: Parser[Product with Stat with Serializable]

Definition Classes
TIL1_1
lazy val integer: Parser[Num]

Definition Classes
TIL1_1
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
lazy val keyword: Parser[String]

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

Definition Classes
ParserUtilities
var lastNoSuccess: NoSuccess

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

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

Definition Classes
Parsers
def main(args: Array[String]): Unit

Accept file name arguments and process them one-by-one by passing a reader on the file to process.
Accept file name arguments and process them one-by-one by passing a reader on the file to process. The resulting value is printed.

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

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

Definition Classes
Parsers
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 opt[T](p: ⇒ Parser[T]): Parser[Option[T]]

Definition Classes
Parsers
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
lazy val parser: Parser[Program]

Definition Classes
TIL1_1
implicit def parser2packrat[T](p: ⇒ Parser[T]): PackratParser[T]

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

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

Definition Classes
RegexParsers → Parsers
lazy val primary: PackratParser[Exp]

Definition Classes
TIL1_1
def process(reader: Reader): Any

Process the file given by the argument reader and return some useful result.
Process the file given by the argument reader and return some useful result. This default implementation parses the input and returns the parser result.

Definition Classes
ParsingMain → Main
lazy val program: Parser[Program]

Definition Classes
TIL1_1
lazy val read_statement: Parser[Read]

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

Definition Classes
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
def result[T](v: ⇒ T): Parser[T]

Definition Classes
ParserUtilities
def skipWhitespace: Boolean

Definition Classes
RegexParsers
lazy val statement: PackratParser[Stat]

Definition Classes
TIL1_1
lazy val string: Parser[Str]

Definition Classes
TIL1_1
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 term: PackratParser[Exp]

Definition Classes
TIL1_1
def toString(): String

Definition Classes
AnyRef → Any
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 while_statement: Parser[While]

Definition Classes
TIL1_1
val whiteSpace: Regex

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

Definition Classes
ParserUtilities
lazy val write_statement: Parser[Write]

Definition Classes
TIL1_1

TIL1_1Main

object TIL1_1Main extends ParsingMain with TIL1_1

Type Members

type Elem = Char

type Input = Reader[Elem]

type Root = Program

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]

final def asInstanceOf[T0]: T0

lazy val assignment_statement: Parser[Assign]

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

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]

lazy val declaration: Parser[Decl]

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

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

val emitter: Emitter

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

lazy val expression: PackratParser[Exp]

lazy val factor: PackratParser[Exp]

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

def finalize(): Unit

lazy val for_statement: Parser[For]

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

lazy val identifier: Parser[Id]

lazy val if_statement: Parser[Product with Stat with Serializable]

lazy val integer: Parser[Num]

final def isInstanceOf[T0]: Boolean

lazy val keyword: Parser[String]

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

var lastNoSuccess: NoSuccess

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

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

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

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

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

final def ne(arg0: AnyRef): Boolean

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

final def notify(): Unit

final def notifyAll(): Unit

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

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

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

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

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

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

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

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

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

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

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

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

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