Driver

def artefact : String

The name of this artefact.

def parser : Parser[ModuleDecl]

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

def angles (d: Doc): Doc

implicit def anyToPrettyPrintable (a: Any): PrettyPrintable

val argparser : ArgotParser

def asInstanceOf [T0] : T0

def backslash : Doc

def braces (d: Doc): Doc

def brackets (d: Doc): Doc

def cat (ds: Seq[Doc]): Doc

val challenge : FlagOption[Boolean]

implicit def char (c: Char): Doc

def checkargs (args: Array[String], emitter: Emitter): Array[String]

Process the command-line arguments and return Some(filename) of the input file if processing should continue, None otherwise.

def clone (): AnyRef

def colon : Doc

def comma : Doc

def compile (args: Array[String], console: Console): String

def consumeast (ast: ModuleDecl, console: Console, emitter: Emitter): Unit

Process the AST, returning the new one.

val defaultIndent : Int

val defaultWidth : Int

def dot : Doc

def dquote : Doc

def dquotes (d: Doc): Doc

def driver (args: Array[String], console: Console, emitter: Emitter): Unit

Custom driver for section tagging and challenge mode for errors.

def empty : Doc

def enclose (l: Doc, d: Doc, r: Doc): Doc

def eq (arg0: AnyRef): Boolean

def equal : Doc

def equals (arg0: Any): Boolean

def fillcat (ds: Seq[Doc]): Doc

def fillsep (ds: Seq[Doc], sep: Doc): Doc

def fillsep (ds: Seq[Doc]): Doc

def finalize (): Unit

def forwslash : Doc

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

def group (d: Doc): Doc

def hashCode (): Int

def hcat (ds: Seq[Doc]): Doc

val help : FlagOption[Boolean]

def hsep (ds: Seq[Doc], sep: Doc): Doc

def hsep (ds: Seq[Doc]): Doc

def initialiseSemanticAnalysis : Unit

Perform initialisation of semantic analysis that is necessary before processing an AST.

val input : SingleValueParameter[String]

def isInstanceOf [T0] : Boolean

def langle : Doc

def lbrace : Doc

def lbracket : Doc

def line : Doc

def linebreak : Doc

def list [T] (l: List[T], prefix: String, elemToDoc: (T) ⇒ Doc, sep: Doc, sepfn: (Seq[Doc], Doc) ⇒ Doc): Doc

def lparen : Doc

def lsep (ds: Seq[Doc], sep: Doc): Doc

def lsep2 (ds: Seq[Doc], sep: Doc): Doc

def lterm (ds: Seq[Doc], term: Doc): Doc

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

def makeast (reader: Reader, filename: String, emitter: Emitter): Either[ModuleDecl, String]

def ne (arg0: AnyRef): Boolean

def nest (d: Doc, j: Indent): Doc

def notify (): Unit

def notifyAll (): Unit

def parens (d: Doc): Doc

def plist (l: List[PrettyPrintable], prefix: String, elemToDoc: (PrettyPrintable) ⇒ Doc, sep: Doc, sepfn: (Seq[Doc], Doc) ⇒ Doc): Doc

val pprintast : FlagOption[Boolean]

def pretty (d: Doc, w: Width): Layout

def pretty (p: PrettyPrintable): Layout

val printast : FlagOption[Boolean]

def process (ast: ModuleDecl, console: Console, emitter: Emitter): Boolean

Process the given abstract syntax tree.

def processast (ast: ModuleDecl, console: Console, emitter: Emitter): ModuleDecl

Process the AST, returning the new one.

def product (p: Any): Doc

def rangle : Doc

def rbrace : Doc

def rbracket : Doc

def rparen : Doc

def section (emitter: Emitter, name: String): Unit

Output a section heading so that the output can be split later.

def semi : Doc

def sep (ds: Seq[Doc]): Doc

def softbreak : Doc

def softline : Doc

def space : Doc

def spaces (n: Int): Doc

def squote : Doc

def squotes (d: Doc): Doc

def ssep (ds: Seq[Doc], sep: Doc): Doc

def sterm (ds: Seq[Doc], term: Doc): Doc

def string (s: String): Doc

def surround (d: Doc, b: Doc): Doc

def synchronized [T0] (arg0: ⇒ T0): T0

implicit def text (t: String): Doc

def toString (): String

def value (v: Any): Doc

def vcat (ds: Seq[Doc]): Doc

def vsep (ds: Seq[Doc], sep: Doc): Doc

def vsep (ds: Seq[Doc]): Doc

def wait (): Unit

def wait (arg0: Long, arg1: Int): Unit

def wait (arg0: Long): Unit