pli

Type Members

1. trait ASTNode extends AnyRef

   

   Nodes of the abstract syntax tree.

   Nodes of the abstract syntax tree.

   The abstract syntax tree is one of the main data structures of the language implementation. It is produced by the parser and consumed by many of the other components (see overview).

   The concrete nodes of the abstract syntax tree are implemented by case classes extending this trait, see “Known Subclasses” below for a list. They are further classified by nonterminal by intermediate traits in the inheritance hierarchy.

2. case class Addition(lhs: Expression, rhs: Expression) extends Expression with Product with Serializable

   

   Nodes of the abstract syntax tree for expressions of the form “lhs + rhs”.

3. case class Assignment(name: String, value: Expression) extends Statement with Product with Serializable

   

   Nodes of the abstract syntax tree for statements of the form “name = value”.

4. case class Block(body: Seq[Statement]) extends Statement with Product with Serializable

   

   Nodes of the abstract syntax tree for statements.

5. class Bytecode extends AnyRef

   

   Builder for bytecode arrays.

6. class CodeGenerator extends AnyRef

   

   Code generator.

7. class DebugVM extends VM

   

   A variant of the virtual machine that prints one line of debugging output for every instruction executed.

   A variant of the virtual machine that prints one line of debugging output for every instruction executed.

   To create a debug virtual machine, use the companion object’s apply methods.

8. trait Expression extends ASTNode

   

   Nodes of the abstract syntax tree for expressions.

   Nodes of the abstract syntax tree for expressions.

   The concrete nodes for expressions of the abstract syntax tree are implemented by case classes extending this trait, see “Known Subclasses” below for a list.

9. case class If(condition: Expression, thenBranch: Seq[Statement], elseBranch: Seq[Statement]) extends Statement with Product with Serializable

   

   Nodes of the abstract syntax tree for statements of the form “if ( condition ) thenBranch” or “if ( condition ) thenBranch else elseBranch”.

   Nodes of the abstract syntax tree for statements of the form “if ( condition ) thenBranch” or “if ( condition ) thenBranch else elseBranch”.

   If there is no else clause in the source code, the elseBranch will be an empty Block as if “else {}” would have been in the source code.

10. class Interpreter extends AnyRef

    

    Interpreter.

11. class Lexer extends AnyRef

    

    Turns a stream of characters into a stream of tokens.

    Turns a stream of characters into a stream of tokens.

    To create a lexer, use the companion object’s forFile or forString methods.

    The lexer is the first main componenent in the language implementation. It reads a stream of characters from a file, or for testing, from a string. It produces a stream of tokens which is further processed by the parser.

    The lexer classifies tokens according to their token type. The token type of the next token in the token stream is available from nextTokenType.

    The lexer keeps track of line and column positions inside the source code. The first character of the source code is line 1 and column 1. The location of the beginning of the next token is available from startLine and startColumn. The location of the first character after the next token is available from currentLine and currentColumn.

    Most token types classify a fixed string such as an operator or keyword. The following token types are special:

    • EndOfFile ─ Used for every position after the last token in the stream
    • Identifier ─ The name of the identifier is available from nextTokenText
    • IntegerLiteral ─ The value of the integer literal is available from nextTokenIntegerValue

12. case class Literal(value: Int) extends Expression with Product with Serializable

    

    Nodes of the abstract syntax tree for expressions of the form “value”.

13. case class Multiplication(lhs: Expression, rhs: Expression) extends Expression with Product with Serializable

    

    Nodes of the abstract syntax tree for expressions of the form “lhs * rhs”.

14. case class NumericValue(toInt: Int) extends Value with Product with Serializable

    

    Numbers at runtime.

15. class Parser extends AnyRef

    

    Turns a stream of tokens into an abstract syntax tree.

    Turns a stream of tokens into an abstract syntax tree.

    To create a parser, use the companion object’s forLexer, forFile, or forString methods.

    The parser is the second main component in the language implementation. It reads a stream of tokens from the lexer. It produces an abstract syntax tree which is further processed by the other components (see overview).

    The parser has one method parseN for each nonterminal symbol N in the grammar´:

    • parseProgram
    • parseStatement
    • parseExpression
    • parseName
    • parseInteger

    Additional parseN methods are necessary for helper nonterminal symbols to implement operator precedence:

    • parseSummand
    • parseFactor

16. class Pretty extends AnyRef

    

    Turns an abstract syntax tree back into a string.

    Turns an abstract syntax tree back into a string.

    To create a pretty printer, use the companion object’s toPrintWriter method.

    The pretty printer is a helper component in the language implementation. It can be used during debugging to print out abstract syntax trees for manual inspection.

17. case class Print(value: Expression) extends Statement with Product with Serializable

    

    Nodes of the abstract syntax tree for statements of the form “print ( value )”.

18. case class Program(name: String, superclass: String, body: Seq[Statement]) extends ASTNode with Product with Serializable

    

    Nodes of the abstract syntax tree for programs of the form “object name extends superclass { body }”.

19. trait Statement extends ASTNode

    

    Nodes of the abstract syntax tree for statements.

    Nodes of the abstract syntax tree for statements.

    The concrete nodes for statements of the abstract syntax tree are implemented by case classes extending this trait, see “Known Subclasses” below for a list.

20. case class Subtraction(lhs: Expression, rhs: Expression) extends Expression with Product with Serializable

    

    Nodes of the abstract syntax tree for expressions of the form “lhs - rhs”.

21. class Table[A, B] extends AnyRef

    

    Mutable symbol table with support for nested scopes.

22. trait TokenType extends AnyRef

    

    Used by the lexer to classify tokens in the token stream.

    Used by the lexer to classify tokens in the token stream.

    Each token type is implemented as a case object, see “Known Subclasses” below for a list.

23. class VM extends AnyRef

    

    Simple virtual machine, that is, bytecode interpreter.

    Simple virtual machine, that is, bytecode interpreter.

    To create a virtual machine, use the companion object’s apply methods.

    For debugging, consider to use a debug virtual machine instead.

24. trait Value extends AnyRef

    

    Values at runtime.

    Values at runtime.

    The representation of values of various dynamic types is implemented by case classes extending this trait, see “Known Subclasses” below for a list.

25. case class Var(name: String, value: Expression) extends Statement with Product with Serializable

    

    Nodes of the abstract syntax tree for statements of the form “var name = value”.

26. case class Variable(name: String) extends Expression with Product with Serializable

    

    Nodes of the abstract syntax tree for expressions of the form “name”.

27. case class While(condition: Expression, body: Seq[Statement]) extends Statement with Product with Serializable

    

    Nodes of the abstract syntax tree for statements of the form “while ( condition ) body”.