Value Members

1.  final def !=(arg0: Any): Boolean

   Definition Classes

   AnyRef → Any

2.  def !==[T](right: Spread[T]): TripleEqualsInvocationOnSpread[T]

   Definition Classes

   TripleEqualsSupport

3.  def !==(right: Null): TripleEqualsInvocation[Null]

   Definition Classes

   TripleEqualsSupport

4.  def !==[T](right: T): TripleEqualsInvocation[T]

   Definition Classes

   TripleEqualsSupport

5.  final def ##(): Int

   Definition Classes

   AnyRef → Any

6.  final def ==(arg0: Any): Boolean

   Definition Classes

   AnyRef → Any

7.  def ===[T](right: Spread[T]): TripleEqualsInvocationOnSpread[T]

   Definition Classes

   TripleEqualsSupport

8.  def ===(right: Null): TripleEqualsInvocation[Null]

   Definition Classes

   TripleEqualsSupport

9.  def ===[T](right: T): TripleEqualsInvocation[T]

   Definition Classes

   TripleEqualsSupport

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

    Definition Classes

    PositionedParserUtilities → Parsers

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

    Definition Classes

    PositionedParserUtilities → Parsers

12.  implicit def PropertyCheckConfig2PropertyCheckConfiguration(p: PropertyCheckConfig): PropertyCheckConfiguration

    Definition Classes

    Configuration

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

    Definition Classes

    Parsers

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

    Definition Classes

    Parsers

15.  implicit def accept(e: Elem): Parser[Elem]

    Definition Classes

    Parsers

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

    Definition Classes

    Parsers

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

    Definition Classes

    Parsers

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

    Definition Classes

    Parsers

19.  def after(fun: ⇒ Any)(implicit pos: Position): Unit

    Attributes

    protected

    Definition Classes

    BeforeAndAfter

20.  def afterAll(): Unit

    Attributes

    protected

    Definition Classes

    BeforeAndAfterAll

21.  def alert: Alerter

    Attributes

    protected

    Definition Classes

    FunSuiteLike → Alerting

22.  def align(d: Doc): Doc

    Definition Classes

    PrettyPrinterBase

23.  def ampersand: Doc

    Definition Classes

    PrettyPrinterBase

24.  def angles(d: Doc): Doc

    Definition Classes

    PrettyPrinterBase

25.  def any(a: Any): Doc

    Definition Classes

    PrettyPrinterBase

26.  def any: PackratParser[Char]

    Definition Classes

    ParserUtilities

27.  implicit def anyToPrettyPrintable(a: Any): PrettyPrintable

    Definition Classes

    PrettyPrinterBase

28.  def arraydimensToDoc(t1: CArrayType): Doc

    Definition Classes

    CPrettyPrinter

29.  def artefact: String

    The name of this artefact.

    The name of this artefact.

    Definition Classes

    A4Phases → Driver

30.  final def asInstanceOf[T0]: T0

    Definition Classes

    Any

31.  macro def assert(condition: Boolean, clue: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

    Definition Classes

    Assertions

32.  macro def assert(condition: Boolean)(implicit prettifier: Prettifier, pos: Position): Assertion

    Definition Classes

    Assertions

33.  macro def assertCompiles(code: String)(implicit pos: Position): Assertion

    Definition Classes

    Assertions

34.  macro def assertDoesNotCompile(code: String)(implicit pos: Position): Assertion

    Definition Classes

    Assertions

35.  def assertMessage(received: Message, index: Int, expected: Message): Unit

    Assert that a received message at the given zero-based index conforms to an expected one in that it reports the same message label at the same position.

    Assert that a received message at the given zero-based index conforms to an expected one in that it reports the same message label at the same position.

    Definition Classes

    Tests

36.  def assertMessages(received: Messages, expected: Message*): Unit

    Assert that the received list of messsages has recorded the expected messages in the same order.

    Assert that the received list of messsages has recorded the expected messages in the same order.

    Definition Classes

    Tests

37.  def assertNotOptSame(expected: Any)(actual: Any): Unit

    Analogous to ScalaTest's assertResult but it uses optsame to compare the two values instead of equality.

    Analogous to ScalaTest's assertResult but it uses optsame to compare the two values instead of equality.

    Definition Classes

    Tests

38.  def assertNotSame(expected: Any)(actual: Any): Unit

    Analogous to ScalaTest's assertResult but it uses same to compare the two values instead of equality.

    Analogous to ScalaTest's assertResult but it uses same to compare the two values instead of equality.

    Definition Classes

    Tests

39.  def assertOptSame(expected: Any)(actual: Any): Unit

    Analogous to ScalaTest's assertResult but it uses optsame to compare the two values instead of equality.

    Analogous to ScalaTest's assertResult but it uses optsame to compare the two values instead of equality.

    Definition Classes

    Tests

40.  def assertResult(expected: Any)(actual: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

    Definition Classes

    Assertions

41.  def assertResult(expected: Any, clue: Any)(actual: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

    Definition Classes

    Assertions

42.  def assertSame(expected: Any)(actual: Any): Unit

    Analogous to ScalaTest's assertResult but it uses same to compare the two values instead of equality.

    Analogous to ScalaTest's assertResult but it uses same to compare the two values instead of equality.

    Definition Classes

    Tests

43.  def assertThrows[T <: AnyRef](f: ⇒ Any)(implicit classTag: ClassTag[T], pos: Position): Assertion

    Definition Classes

    Assertions

44.  macro def assertTypeError(code: String)(implicit pos: Position): Assertion

    Definition Classes

    Assertions

45.  val assertionsHelper: AssertionsHelper

    Definition Classes

    Assertions

46.  lazy val assignment: Parser[Assignment]

    Definition Classes

    SyntaxAnalyser

47.  macro def assume(condition: Boolean, clue: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

    Definition Classes

    Assertions

48.  macro def assume(condition: Boolean)(implicit prettifier: Prettifier, pos: Position): Assertion

    Definition Classes

    Assertions

49.  def asterisk: Doc

    Definition Classes

    PrettyPrinterBase

50.  def atsign: Doc

    Definition Classes

    PrettyPrinterBase

51.  def backquote: Doc

    Definition Classes

    PrettyPrinterBase

52.  def backslash: Doc

    Definition Classes

    PrettyPrinterBase

53.  lazy val basetype: (Expression) ⇒ Type

    The actual type of an expression following type aliases.

    The actual type of an expression following type aliases.

    Definition Classes

    TypeAnalyser

54.  def basetypeToDoc(t: CType): Doc

    Definition Classes

    CPrettyPrinter → CPrettyPrinter → CPrettyPrinter → CPrettyPrinter

55.  def before(fun: ⇒ Any)(implicit pos: Position): Unit

    Attributes

    protected

    Definition Classes

    BeforeAndAfter

56.  def beforeAll(): Unit

    Attributes

    protected

    Definition Classes

    BeforeAndAfterAll

57.  lazy val block: Parser[Block]

    Definition Classes

    SyntaxAnalyser

58.  def blockToDoc(b: Block, beginend: Boolean = false): Doc

    Pretty-print a block, omitting the BEGIN if there are no statements.

    Pretty-print a block, omitting the BEGIN if there are no statements. Add the possibility of declarations to the previous level.

    Definition Classes

    SourcePrettyPrinter → SourcePrettyPrinter

59.  lazy val booleanType: BuiltinType

    Built-in Boolean type.

    Built-in Boolean type.

    Definition Classes

    SymbolTable

60.  def braces(d: Doc): Doc

    Definition Classes

    PrettyPrinterBase

61.  def bracket(inner: PrettyOperatorExpression, outer: PrettyOperatorExpression, side: Side): Doc

    Definition Classes

    ParenPrettyPrinter

62.  def brackets(d: Doc): Doc

    Definition Classes

    PrettyPrinterBase

63.  def cancel(cause: Throwable)(implicit pos: Position): Nothing

    Definition Classes

    Assertions

64.  def cancel(message: String, cause: Throwable)(implicit pos: Position): Nothing

    Definition Classes

    Assertions

65.  def cancel(message: String)(implicit pos: Position): Nothing

    Definition Classes

    Assertions

66.  def cancel()(implicit pos: Position): Nothing

    Definition Classes

    Assertions

67.  def caret: Doc

    Definition Classes

    PrettyPrinterBase

68.  lazy val caseStatement: Parser[CaseStatement]

    Definition Classes

    SyntaxAnalyser

69.  def caseToDoc(s: CaseStatement): Doc

    Definition Classes

    SourcePrettyPrinter

70.  lazy val cases: Parser[List[Case]]

    Definition Classes

    SyntaxAnalyser

71.  def casesToDoc(l: Seq[Case]): Doc

    Definition Classes

    SourcePrettyPrinter

72.  def casesToIf(ce: IdnExp, cases: Seq[Case], optelse: Option[Block]): IfStatement

    Return an IF cascade equivaleant to the given cases and optional else block.

    Return an IF cascade equivaleant to the given cases and optional else block. The variable ce holds the selection value. Specifically, these cases on ce CASE e1 : s1 CASE e2 .. e3 : s2 ELSE s3 are transformed into IF ce = e1 THEN s1 ELSEIF (ce >= e2) & (ce <= e3) THEN s2 ELSE 32 END If a case has more than one condition then they are combined with Or operators.

    Definition Classes

    Desugarer

73.  def cat(ds: Seq[Doc]): Doc

    Definition Classes

    PrettyPrinterBase

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

    Definition Classes

    Parsers

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

    Definition Classes

    Parsers

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

    Definition Classes

    Parsers

77.  implicit def char(c: Char): Doc

    Definition Classes

    PrettyPrinterBase

78.  def check[ASSERTION](p: Prop, configParams: PropertyCheckConfigParam*)(implicit config: PropertyCheckConfigurable, asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Definition Classes

    Checkers

79.  def check[ASSERTION](p: Prop, prms: Parameters)(implicit asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Definition Classes

    Checkers

80.  def check[A1, A2, A3, A4, A5, A6, P, ASSERTION](f: (A1, A2, A3, A4, A5, A6) ⇒ P, configParams: PropertyCheckConfigParam*)(implicit config: PropertyCheckConfigurable, p: (P) ⇒ Prop, a1: Arbitrary[A1], s1: Shrink[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], s2: Shrink[A2], pp2: (A2) ⇒ Pretty, a3: Arbitrary[A3], s3: Shrink[A3], pp3: (A3) ⇒ Pretty, a4: Arbitrary[A4], s4: Shrink[A4], pp4: (A4) ⇒ Pretty, a5: Arbitrary[A5], s5: Shrink[A5], pp5: (A5) ⇒ Pretty, a6: Arbitrary[A6], s6: Shrink[A6], pp6: (A6) ⇒ Pretty, asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Definition Classes

    Checkers

81.  def check[A1, A2, A3, A4, A5, P, ASSERTION](f: (A1, A2, A3, A4, A5) ⇒ P, configParams: PropertyCheckConfigParam*)(implicit config: PropertyCheckConfigurable, p: (P) ⇒ Prop, a1: Arbitrary[A1], s1: Shrink[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], s2: Shrink[A2], pp2: (A2) ⇒ Pretty, a3: Arbitrary[A3], s3: Shrink[A3], pp3: (A3) ⇒ Pretty, a4: Arbitrary[A4], s4: Shrink[A4], pp4: (A4) ⇒ Pretty, a5: Arbitrary[A5], s5: Shrink[A5], pp5: (A5) ⇒ Pretty, asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Definition Classes

    Checkers

82.  def check[A1, A2, A3, A4, P, ASSERTION](f: (A1, A2, A3, A4) ⇒ P, configParams: PropertyCheckConfigParam*)(implicit config: PropertyCheckConfigurable, p: (P) ⇒ Prop, a1: Arbitrary[A1], s1: Shrink[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], s2: Shrink[A2], pp2: (A2) ⇒ Pretty, a3: Arbitrary[A3], s3: Shrink[A3], pp3: (A3) ⇒ Pretty, a4: Arbitrary[A4], s4: Shrink[A4], pp4: (A4) ⇒ Pretty, asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Definition Classes

    Checkers

83.  def check[A1, A2, A3, P, ASSERTION](f: (A1, A2, A3) ⇒ P, configParams: PropertyCheckConfigParam*)(implicit config: PropertyCheckConfigurable, p: (P) ⇒ Prop, a1: Arbitrary[A1], s1: Shrink[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], s2: Shrink[A2], pp2: (A2) ⇒ Pretty, a3: Arbitrary[A3], s3: Shrink[A3], pp3: (A3) ⇒ Pretty, asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Definition Classes

    Checkers

84.  def check[A1, A2, P, ASSERTION](f: (A1, A2) ⇒ P, configParams: PropertyCheckConfigParam*)(implicit config: PropertyCheckConfigurable, p: (P) ⇒ Prop, a1: Arbitrary[A1], s1: Shrink[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], s2: Shrink[A2], pp2: (A2) ⇒ Pretty, asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Definition Classes

    Checkers

85.  def check[A1, P, ASSERTION](f: (A1) ⇒ P, configParams: PropertyCheckConfigParam*)(implicit config: PropertyCheckConfigurable, p: (P) ⇒ Prop, a1: Arbitrary[A1], s1: Shrink[A1], pp1: (A1) ⇒ Pretty, asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Definition Classes

    Checkers

86.  def checkFor(record: Record, dim: Dimension, eventtype: String, needed: Dimension)(f: (Value) ⇒ Value): Value

    Definition Classes

    Values

87.  def checkNonLocalVarAccess(u: IdnUse): Messages

    Check for non-local variable and procedure accesses.

    Check for non-local variable and procedure accesses. In the L3 language non-local variable accesses are disallowed, unless they are to a variable at the top level. Non-local procedure accesses are just disallowed.

    Definition Classes

    NameAnalyser

88.  def clone(): AnyRef

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

89.  def colon: Doc

    Definition Classes

    PrettyPrinterBase

90.  def column(f: (Int) ⇒ Doc): Doc

    Definition Classes

    PrettyPrinter → PrettyPrinterBase

91.  def comma: Doc

    Definition Classes

    PrettyPrinterBase

92.  lazy val comment: PackratParser[Any]

    Definition Classes

    SyntaxAnalyser

93.  def commit[T](p: ⇒ Parser[T]): Parser[T]

    Definition Classes

    Parsers

94.  lazy val condition: Parser[Condition with Serializable]

    Definition Classes

    SyntaxAnalyser

95.  lazy val conditions: Parser[List[Condition with Serializable]]

    Definition Classes

    SyntaxAnalyser

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

    Definition Classes

    ParserUtilities

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

    Definition Classes

    ParserUtilities

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

    Definition Classes

    ParserUtilities

99.  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

100.  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

101.  lazy val constdecl: Parser[ConstDecl]

     Definition Classes

     SyntaxAnalyser

102.  lazy val constdeclsection: Parser[List[ConstDecl]]

     Definition Classes

     SyntaxAnalyser

103.  lazy val constrainedInt: PackratParser[Int]

     Definition Classes

     ParserUtilities

104.  def consumeast(ast: ModuleDecl, config: Oberon0Config): Unit

     Consume the AST by translating it to C.

     Consume the AST by translating it to C.

     Definition Classes

     TranslatingDriver → FrontEndDriver

105.  def conversionCheckedConstraint[A, B](implicit equivalenceOfA: Equivalence[A], cnv: (B) ⇒ A): CanEqual[A, B]

     Definition Classes

     TripleEquals → TripleEqualsSupport

106.  def convertEquivalenceToAToBConstraint[A, B](equivalenceOfB: Equivalence[B])(implicit ev: <:<[A, B]): CanEqual[A, B]

     Definition Classes

     TripleEquals → TripleEqualsSupport

107.  def convertEquivalenceToAToBConversionConstraint[A, B](equivalenceOfB: Equivalence[B])(implicit ev: (A) ⇒ B): CanEqual[A, B]

     Definition Classes

     TripleEquals → TripleEqualsSupport

108.  def convertEquivalenceToBToAConstraint[A, B](equivalenceOfA: Equivalence[A])(implicit ev: <:<[B, A]): CanEqual[A, B]

     Definition Classes

     TripleEquals → TripleEqualsSupport

109.  def convertEquivalenceToBToAConversionConstraint[A, B](equivalenceOfA: Equivalence[A])(implicit ev: (B) ⇒ A): CanEqual[A, B]

     Definition Classes

     TripleEquals → TripleEqualsSupport

110.  def convertToCheckingEqualizer[T](left: T): CheckingEqualizer[T]

     Definition Classes

     TripleEquals → TripleEqualsSupport

111.  implicit def convertToEqualizer[T](left: T): Equalizer[T]

     Definition Classes

     TripleEquals → TripleEqualsSupport

112.  def createConfig(args: Seq[String], output: Emitter = new OutputEmitter, error: Emitter = new ErrorEmitter): Oberon0Config

     In the test configuration we pretty print the source and C ASTs by default.

     In the test configuration we pretty print the source and C ASTs by default.

     Definition Classes

     TestDriver

113.  lazy val declarations: PackratParser[Seq[Declaration]]

     Definition Classes

     SyntaxAnalyser

114.  def declarationsDef: PackratParser[Seq[Declaration]]

     Definition Classes

     SyntaxAnalyser → SyntaxAnalyser → SyntaxAnalyser

115.  def declsToDoc(ds: Seq[Declaration]): Doc

     Definition Classes

     SourcePrettyPrinter

116.  def declsection(d: Declaration): String

     Definition Classes

     SourcePrettyPrinter → SourcePrettyPrinter

117.  lazy val decltype: (TypeDecl) ⇒ Type

     The built-in type associated with a type declaration.

     The built-in type associated with a type declaration.

     Definition Classes

     TypeAnalyser

118.  def defaultEquality[A]: Equality[A]

     Definition Classes

     TripleEqualsSupport

119.  val defaultIndent: Int

     Definition Classes

     PrettyPrinterBase

120.  val defaultWidth: Int

     Definition Classes

     PrettyPrinterBase

121.  def defenv: Environment

     The default environment.

     The default environment.

     Definition Classes

     SymbolTable

122.  def defenvPairs: Seq[(String, Entity)]

     The default environment with pre-defined procedures added.

     The default environment with pre-defined procedures added.

     Definition Classes

     SymbolTable → SymbolTable

123.  def define(env: Environment, i: String, e: Entity): Environment

     Definition Classes

     Environments

124.  lazy val deftype: (TypeDef) ⇒ Type

     The type given by a type definition.

     The type given by a type definition.

     Definition Classes

     TypeAnalyser

125.  def deftypeDef: (TypeDef) ⇒ Type

     Definition Classes

     TypeAnalyser → TypeAnalyser

126.  lazy val desugarCase: Strategy

     Desugar CASE statements into equivalent blocks containing cascading IF statements.

     Desugar CASE statements into equivalent blocks containing cascading IF statements. A new variable called "casevar" is introduced in the block to hold the selection value so that it does not need to be re-evaluated. Specifically, CASE e OF cases END is transformed into VAR caseval : INTEGER; BEGIN caseval := e; IF caseval ... THEN ... END END

     Definition Classes

     Desugarer

127.  lazy val desugarFor: Strategy

     Desugar FOR statements into equivalent blocks containing a WHILE loop.

     Desugar FOR statements into equivalent blocks containing a WHILE loop. A new variable called "limit" is introduced in the block to hold the upper limit of the FOR to protect against changes in the body. Specifically, FOR id := e1 TO e2 BY e3 DO body END is transformed into VAR limit : INTEGER; BEGIN id := e1; limit := e2; WHILE (id op limit) DO body id := id + e3 END END If e3 is negative, op is <=, otherwise it is >=.

     Definition Classes

     Desugarer

128.  def dimValue(record: Record, dim: Dimension): Value

     Definition Classes

     Profiler → Profiler → Values

129.  def dollar: Doc

     Definition Classes

     PrettyPrinterBase

130.  def dosanitisation: Boolean

     Flag to decide whether to sanitise the output before comparison of test results with expected results (see sanitise method).

     Flag to decide whether to sanitise the output before comparison of test results with expected results (see sanitise method). Default is true; override with false if you want actual results compared.

     Definition Classes

     TestCompilerWithConfig

131.  def dot: Doc

     Definition Classes

     PrettyPrinterBase

132.  def dquote: Doc

     Definition Classes

     PrettyPrinterBase

133.  def dquotes(d: Doc): Doc

     Definition Classes

     PrettyPrinterBase

134.  def driver(args: Seq[String]): Unit

     Definition Classes

     CompilerBase

135.  def elem(e: Elem): Parser[Elem]

     Definition Classes

     Parsers

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

     Definition Classes

     Parsers

137.  lazy val elsif: PackratParser[(Expression, Block)]

     Definition Classes

     SyntaxAnalyser

138.  lazy val elsifs: Parser[List[(Expression, Block)]]

     Definition Classes

     SyntaxAnalyser

139.  def empty: Doc

     Definition Classes

     PrettyPrinter → PrettyPrinterBase

140.  def enclose(l: Doc, d: Doc, r: Doc): Doc

     Definition Classes

     PrettyPrinterBase

141.  def encoding: String

     Definition Classes

     CompilerBase

142.  def enter(env: Environment): Environment

     Definition Classes

     Environments

143.  lazy val entity: (Identifier) ⇒ Entity

     The program entity referred to by an identifier definition or use.

     The program entity referred to by an identifier definition or use. In the case of a definition it's the thing being defined, so define it to be a reference to the declaration. If it's already defined, return a entity that indicates a multiple definition. In the case of a use, it's the thing defined elsewhere that is being referred to here, so look it up in the environment.

     Definition Classes

     NameAnalyser

144.  def entityFromDecl(n: IdnDef, i: String): Entity

     The entity for an identifier definition as given by its declaration context.

     The entity for an identifier definition as given by its declaration context.

     Definition Classes

     TypeAnalyser → NameAnalyser → NameAnalyser

145.  lazy val env: Chain[SourceTree, Environment]

     The environment containing bindings for all identifiers visible at the given node.

     The environment containing bindings for all identifiers visible at the given node. It starts at the module declaration with the default environment. At blocks we enter a nested scope which is removed on exit from the block. At constant and type declarations the left-hand side binding is not in scope on the right-hand side. Each identifier definition just adds its binding to the chain. The envout cases for assignment and expression mean that we don't need to traverse into those constructs, since declarations can't occur there.

     Definition Classes

     NameAnalyser

146.  def envin(in: (SourceTree) ⇒ Environment): ==>[SourceTree, Environment]

     Definition Classes

     NameAnalyser → NameAnalyser

147.  def envinl(in: (SourceTree) ⇒ Environment): ==>[SourceTree, Environment]

     Blocks that are immediately inside procedure decls do not introduce new scopes since the procedure itself does.

     Blocks that are immediately inside procedure decls do not introduce new scopes since the procedure itself does. This computation overrides the one earlier that pushes a scope for all blocks. Don't include the procedure name in the scope of its own body.

     Definition Classes

     NameAnalyser

148.  def envout(out: (SourceTree) ⇒ Environment): ==>[SourceTree, Environment]

     Definition Classes

     NameAnalyser → NameAnalyser

149.  def envoutl(out: (SourceTree) ⇒ Environment): ==>[SourceTree, Environment]

     Similarly for envin we don't need to leave a scope for a procedure block, since we didn't enter one.

     Similarly for envin we don't need to leave a scope for a procedure block, since we didn't enter one. The IdnDef that is for a ProcDecl needs to be in the outer scope, but not in the scope of its own body. All arguments and local declarations go in the nested scope.

     Definition Classes

     NameAnalyser

150.  final def eq(arg0: AnyRef): Boolean

     Definition Classes

     AnyRef

151.  def equal: Doc

     Definition Classes

     PrettyPrinterBase

152.  def equals(arg0: Any): Boolean

     Definition Classes

     AnyRef → Any

153.  def err(msg: String): Parser[Nothing]

     Definition Classes

     ParserUtilities → Parsers

154.  val errors: (SourceTree) ⇒ Messages

     The semantic errors for a tree.

     The semantic errors for a tree.

     Definition Classes

     Analyser

155.  def errorsDef(n: SourceTree): Messages

     The error checking for this level.

     The error checking for this level.

     Definition Classes

     TypeAnalyser → TypeAnalyser → NameAnalyser → TypeAnalyser → TypeAnalyser → NameAnalyser → Analyser

156.  def exclamation: Doc

     Definition Classes

     PrettyPrinterBase

157.  final def execute(testName: String, configMap: ConfigMap, color: Boolean, durations: Boolean, shortstacks: Boolean, fullstacks: Boolean, stats: Boolean): Unit

     Definition Classes

     Suite

158.  lazy val expconst: (Expression) ⇒ Boolean

     Is an expression expected to be constant or not? Either the expression is the root of an expected constant expression or its parent expression is expected to be constant.

     Is an expression expected to be constant or not? Either the expression is the root of an expected constant expression or its parent expression is expected to be constant.

     Definition Classes

     NameAnalyser

159.  def expectedTestCount(filter: Filter): Int

     Definition Classes

     Suite

160.  lazy val expression: Parser[Expression]

     Definition Classes

     SyntaxAnalyser

161.  lazy val exptype: (Expression) ⇒ Type

     The type expected of an expression as defined by its context.

     The type expected of an expression as defined by its context.

     Definition Classes

     TypeAnalyser

162.  def exptypeDef: (Expression) ⇒ Type

     Use of arrays and records is dealt with separately, not via the expected type.

     Use of arrays and records is dealt with separately, not via the expected type.

     Definition Classes

     TypeAnalyser → TypeAnalyser → TypeAnalyser → TypeAnalyser → TypeAnalyser

163.  lazy val factor: PackratParser[Expression]

     Definition Classes

     SyntaxAnalyser

164.  def fail(cause: Throwable)(implicit pos: Position): Nothing

     Definition Classes

     Assertions

165.  def fail(message: String, cause: Throwable)(implicit pos: Position): Nothing

     Definition Classes

     Assertions

166.  def fail(message: String)(implicit pos: Position): Nothing

     Definition Classes

     Assertions

167.  def fail()(implicit pos: Position): Nothing

     Definition Classes

     Assertions

168.  def failExpectedTest[T](expected: T, found: T, description: String = ""): Unit

     Fail a test with a message about finding something and expecting something else.

     Fail a test with a message about finding something and expecting something else.

     Definition Classes

     Tests

169.  def failure(msg: String): Parser[Nothing]

     Definition Classes

     ParserUtilities → Parsers

170.  lazy val falseConstant: IntegerValue

     Built-in false constant.

     Built-in false constant.

     Definition Classes

     SymbolTable

171.  def fieldListsToFields(fls: Seq[FieldList]): Seq[Field]

     Definition Classes

     TypeAnalyser

172.  lazy val fieldlist: Parser[Option[FieldList]]

     Definition Classes

     SyntaxAnalyser

173.  lazy val fieldlists: Parser[List[FieldList]]

     Definition Classes

     SyntaxAnalyser

174.  def filetests(name: String, path: String, srcext: String, resext: String, optinext: Option[String] = None, indefault: String = "", argslist: Seq[Seq[String]] = Seq (Seq ())): Unit

     Make tests that process the files in path.

     Make tests that process the files in path. name is an identifying name for this set of tests. All files whose names end in srcext are processed. Processing is done by the function compile which must return either Some (s) where s is the output or None if processing failed. If srcext is .x and resext is .y, then the expected result for foo.x is found in file foo.y. If optinext is Some (z), then foo.z is used for standard input, if it exists, otherwise the string indefault is used. A test fails if either the processing fails or it succeeds with the wrong result. argslist is used to specify the sets of command-line arguments that you want to use. Each test is run with each set of arguments. The default is an empty argument list.

     Definition Classes

     TestCompilerWithConfig

175.  def fillcat(ds: Seq[Doc]): Doc

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     PrettyPrinterBase

177.  def fillsep(ds: Seq[Doc]): Doc

     Definition Classes

     PrettyPrinterBase

178.  def finalize(): Unit

     Attributes

     protected[java.lang]

     Definition Classes

     AnyRef

     Annotations

     @throws( classOf[java.lang.Throwable] )

179.  def finishReport(): Unit

     Definition Classes

     Values

180.  lazy val fldidn: Parser[FieldIdn]

     Definition Classes

     SyntaxAnalyser

181.  def folddoc(ds: Seq[Doc], f: (Doc, Doc) ⇒ Doc): Doc

     Definition Classes

     PrettyPrinterBase

182.  lazy val forStatement: Parser[ForStatement]

     Definition Classes

     SyntaxAnalyser

183.  def forToDoc(s: ForStatement): Doc

     Definition Classes

     SourcePrettyPrinter

184.  lazy val forVar: Parser[IdnExp]

     Definition Classes

     SyntaxAnalyser

185.  def forwslash: Doc

     Definition Classes

     PrettyPrinterBase

186.  lazy val fpsection: Parser[FPSection]

     Definition Classes

     SyntaxAnalyser

187.  implicit val generatorDrivenConfig: PropertyCheckConfiguration

     Definition Classes

     Configuration

188.  final def getClass(): Class[_]

     Definition Classes

     AnyRef → Any

189.  def group(d: Doc): Doc

     Definition Classes

     PrettyPrinter → PrettyPrinterBase

190.  def guard[T](p: ⇒ Parser[T]): Parser[T]

     Definition Classes

     Parsers

191.  def handleWhiteSpace(in: Input): Int

     Definition Classes

     WhitespacePositionedParserUtilities → ParserUtilities

192.  def handleWhiteSpace(source: CharSequence, offset: Int): Int

     Attributes

     protected

     Definition Classes

     RegexParsers

193.  def hang(d: Doc, i: Indent): Doc

     Definition Classes

     PrettyPrinterBase

194.  def hasField(t: Type, f: String): Boolean

     Is a given type a record type containing a field called f?

     Is a given type a record type containing a field called f?

     Definition Classes

     SymbolTable

195.  def hash: Doc

     Definition Classes

     PrettyPrinterBase

196.  def hashCode(): Int

     Definition Classes

     AnyRef → Any

197.  def hcat(ds: Seq[Doc]): Doc

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     PrettyPrinterBase

199.  def hsep(ds: Seq[Doc]): Doc

     Definition Classes

     PrettyPrinterBase

200.  lazy val ident: Parser[String]

     Definition Classes

     SyntaxAnalyser

201.  def idlistToDoc(ids: Seq[IdnDef]): Doc

     Definition Classes

     SourcePrettyPrinter

202.  lazy val idndef: Parser[IdnDef]

     Definition Classes

     SyntaxAnalyser

203.  lazy val idndeflist: Parser[List[IdnDef]]

     Definition Classes

     SyntaxAnalyser

204.  lazy val idnlist: Parser[List[String]]

     Definition Classes

     SyntaxAnalyser

205.  lazy val idntype: (IdnUse) ⇒ Type

     The type of the entity denoted by an identifier use.

     The type of the entity denoted by an identifier use.

     Definition Classes

     TypeAnalyser

206.  def idntypeDef: (IdnUse) ⇒ Type

     The type of a parameter is the type of its underlying variable.

     The type of a parameter is the type of its underlying variable.

     Definition Classes

     TypeAnalyser → TypeAnalyser

207.  lazy val idnuse: Parser[IdnUse]

     Definition Classes

     SyntaxAnalyser

208.  lazy val ifStatement: Parser[IfStatement]

     Definition Classes

     SyntaxAnalyser

209.  def ifToDoc(s: IfStatement): Doc

     Definition Classes

     SourcePrettyPrinter

210.  def ignore(testName: String, testTags: Tag*)(testFun: ⇒ Any)(implicit pos: Position): Unit

     Attributes

     protected

     Definition Classes

     FunSuiteLike

211.  def includeTimings: Boolean

     Definition Classes

     Profiler

212.  def indent(d: Doc, i: Indent): Doc

     Definition Classes

     PrettyPrinterBase

213.  def info: Informer

     Attributes

     protected

     Definition Classes

     FunSuiteLike → Informing

214.  def initialiseSemanticAnalysis: Unit

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

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

     Definition Classes

     Driver

215.  lazy val integerType: BuiltinType

     Built-in integer type.

     Built-in integer type.

     Definition Classes

     SymbolTable

216.  def intercept[T <: AnyRef](f: ⇒ Any)(implicit classTag: ClassTag[T], pos: Position): T

     Definition Classes

     Assertions

217.  lazy val intexp: Parser[IntExp]

     Definition Classes

     SyntaxAnalyser

218.  val invokeBeforeAllAndAfterAllEvenIfNoTestsAreExpected: Boolean

     Definition Classes

     BeforeAndAfterAll

219.  def isArray(e: Entity): Boolean

     Return true if the entity is erroneous or is an array.

     Return true if the entity is erroneous or is an array.

     Definition Classes

     SymbolTable

220.  def isBoolean(e: Type): Boolean

     Return true if the given type is Boolean or an unknown type.

     Return true if the given type is Boolean or an unknown type.

     Definition Classes

     SymbolTable

221.  def isCompatible(tipe: Type, exptype: Type): Boolean

     Array and record types are only compatible if they have the same name.

     Array and record types are only compatible if they have the same name.

     Definition Classes

     TypeAnalyser → TypeAnalyser

222.  def isConstant(e: Entity): Boolean

     Return true if the entity is erroneous or is a constant.

     Return true if the entity is erroneous or is a constant.

     Definition Classes

     SymbolTable

223.  def isDefinedInEnv(env: Environment, i: String): Boolean

     Definition Classes

     Environments

224.  def isDefinedInInner(env: Environment, i: String): Boolean

     Definition Classes

     Environments

225.  def isDefinedInOuter(env: Environment, i: String): Boolean

     Definition Classes

     Environments

226.  def isDefinedInScope(scope: Scope, i: String): Boolean

     Definition Classes

     Environments

227.  def isDefinedInScope(env: Environment, i: String): Boolean

     Definition Classes

     Environments

228.  def isError(e: Entity): Boolean

     Return true if the entity is an error, false otherwise.

     Return true if the entity is an error, false otherwise.

     Definition Classes

     SymbolTable

229.  def isEventType(record: Record, eventtype: String): Boolean

     Definition Classes

     Values

230.  final def isInstanceOf[T0]: Boolean

     Definition Classes

     Any

231.  def isInteger(e: Type): Boolean

     Return true if the given type is integer or an unknown type.

     Return true if the given type is integer or an unknown type.

     Definition Classes

     SymbolTable

232.  def isLvalue(l: Expression): Boolean

     Return true if the expression can legally appear on the left-hand side of an assignment statement.

     Return true if the expression can legally appear on the left-hand side of an assignment statement. At this level only allow identifiers of variables or things we don't know anything about. The true default is used so that this computation can be used in redefinitions.

     Definition Classes

     NameAnalyser → NameAnalyser

233.  def isModule(e: Entity): Boolean

     Return true if the entity is erroneous or is a module.

     Return true if the entity is erroneous or is a module.

     Definition Classes

     SymbolTable

234.  def isNotArray(e: Entity): Boolean

     Return true if the entity is erroneous or is not an array.

     Return true if the entity is erroneous or is not an array.

     Definition Classes

     SymbolTable

235.  def isNotRecord(e: Entity): Boolean

     Return true if the entity is erroneous or is not a record.

     Return true if the entity is erroneous or is not a record.

     Definition Classes

     SymbolTable

236.  def isRecord(e: Entity): Boolean

     Return true if the entity is erroneous or is a record.

     Return true if the entity is erroneous or is a record.

     Definition Classes

     SymbolTable

237.  def isRvalue(r: IdnExp): Boolean

     Return true if the identifier is an r-value and hence its value can be used (ie.

     Return true if the identifier is an r-value and hence its value can be used (ie. it's erroneous or is a constant, value or variable).

     Definition Classes

     NameAnalyser

238.  def isType(e: Entity): Boolean

     Return true if the entity is erroneous or is a type.

     Return true if the entity is erroneous or is a type.

     Definition Classes

     SymbolTable

239.  def isVariable(e: Entity): Boolean

     Parameters are variables too.

     Parameters are variables too.

     Definition Classes

     SymbolTable → SymbolTable

240.  lazy val isconst: (Expression) ⇒ Boolean

     Is an expression constant or not? Unknown entities are constant.

     Is an expression constant or not? Unknown entities are constant. Strictly speaking we only need to support integer expressions here, but we treat Boolean ones as constant in the same way so that we avoid spurious errors. Type analysis will reject Boolean constant expressions anyway.

     Definition Classes

     NameAnalyser

241.  lazy val kase: Parser[Case]

     Definition Classes

     SyntaxAnalyser

242.  lazy val keyword: Parser[String]

     Definition Classes

     SyntaxAnalyser

243.  def keywordStrings: Seq[String]

     Definition Classes

     SyntaxAnalyser → SyntaxAnalyser → SyntaxAnalyser → SyntaxAnalyser → SyntaxAnalyser → SyntaxAnalyser

244.  def keywords(ext: Regex, kws: Seq[String]): Parser[String]

     Definition Classes

     ParserUtilities

245.  def langle: Doc

     Definition Classes

     PrettyPrinterBase

246.  def langlevel: Int

     Definition Classes

     A4Phases

247.  def lbrace: Doc

     Definition Classes

     PrettyPrinterBase

248.  def lbracket: Doc

     Definition Classes

     PrettyPrinterBase

249.  def leave(env: Environment): Environment

     Definition Classes

     Environments

250.  lazy val level: (SourceTree) ⇒ Int

     Level of a node considering the module level to be zero and incrementing each time we enter a nested procedure declaration.

     Level of a node considering the module level to be zero and incrementing each time we enter a nested procedure declaration.

     Definition Classes

     NameAnalyser

251.  lazy val lhs: PackratParser[Expression]

     Definition Classes

     SyntaxAnalyser

252.  def lhsDef: PackratParser[Expression]

     Definition Classes

     SyntaxAnalyser → SyntaxAnalyser

253.  def line: Doc

     Definition Classes

     PrettyPrinter → PrettyPrinterBase

254.  def line(repl: Layout): Doc

     Definition Classes

     PrettyPrinter → PrettyPrinterBase

255.  def linebreak: Doc

     Definition Classes

     PrettyPrinter → PrettyPrinterBase

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

     Definition Classes

     PrettyPrinterBase

257.  implicit def literal(s: String): Parser[String]

     Definition Classes

     WhitespaceParser → RegexParsers

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

     Definition Classes

     Parsers

259.  def lookup(env: Environment, i: String, e: Entity, scope: Boolean): Entity

     Definition Classes

     Environments

260.  def lowPriorityConversionCheckedConstraint[A, B](implicit equivalenceOfB: Equivalence[B], cnv: (A) ⇒ B): CanEqual[A, B]

     Definition Classes

     TripleEquals → TripleEqualsSupport

261.  def lowPriorityTypeCheckedConstraint[A, B](implicit equivalenceOfB: Equivalence[B], ev: <:<[A, B]): CanEqual[A, B]

     Definition Classes

     TripleEquals → TripleEqualsSupport

262.  def lparen: Doc

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     PrettyPrinterBase

266.  def main(args: Array[String]): Unit

     Definition Classes

     CompilerBase

267.  def makeast(reader: Reader, filename: String, config: Oberon0Config): Either[ModuleDecl, String]

     Definition Classes

     CompilerWithConfig → CompilerBase

268.  def mangle(s: String): String

     Mangle an Oberon name so it is safe to be used at the C level.

     Mangle an Oberon name so it is safe to be used at the C level. We assume that there are no C names with "ob_" prefix.

     Definition Classes

     CCodeGenerator

269.  def mark[T](p: Parser[String]): Parser[Marker]

     Definition Classes

     PositionedParserUtilities

270.  def markup: Documenter

     Attributes

     protected

     Definition Classes

     FunSuiteLike → Documenting

271.  def maxDiscardedFactor(value: PosZDouble): MaxDiscardedFactor

     Definition Classes

     Configuration

272.  val maxlanglevel: Int

     The maximum language level we support.

     The maximum language level we support.

     Definition Classes

     TestDriver

273.  def memo[T](p: Parser[T]): PackratParser[T]

     Definition Classes

     PackratParsers

274.  def minSize(value: PosZInt): MinSize

     Definition Classes

     Configuration

275.  def minSuccessful(value: PosInt): MinSuccessful

     Definition Classes

     Configuration

276.  def minus: Doc

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     Parsers

278.  def mktests(proglang: String): Unit

     Make the tests for a given language subset.

     Make the tests for a given language subset. proglang denotes the language subset whose tests are used.

     Definition Classes

     TestDriver

279.  lazy val moduledecl: Parser[ModuleDecl]

     Definition Classes

     SyntaxAnalyser

280.  val nameCounter: Counter

     Definition Classes

     Environments

281.  lazy val namedtypedef: Parser[NamedType]

     Definition Classes

     SyntaxAnalyser

282.  def nanoToMs(nano: Long): Long

     Definition Classes

     Profiler

283.  final def ne(arg0: AnyRef): Boolean

     Definition Classes

     AnyRef

284.  def nest(d: Doc, j: Indent): Doc

     Definition Classes

     PrettyPrinter → PrettyPrinterBase

285.  def nestedSuites: IndexedSeq[Suite]

     Definition Classes

     Suite

286.  def nesting(f: (Int) ⇒ Doc): Doc

     Definition Classes

     PrettyPrinter → PrettyPrinterBase

287.  def noparens(inner: PrettyOperatorExpression, outer: PrettyOperatorExpression, side: Side): Boolean

     Definition Classes

     ParenPrettyPrinter

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

     Definition Classes

     Parsers

289.  def note: Notifier

     Attributes

     protected

     Definition Classes

     FunSuiteLike → Notifying

290.  final def notify(): Unit

     Definition Classes

     AnyRef

291.  final def notifyAll(): Unit

     Definition Classes

     AnyRef

292.  lazy val numparams: (IdnUse) ⇒ Option[Int]

     Calculate the number of parameters to a procedure.

     Calculate the number of parameters to a procedure. Return None if the identifier use does not denote a procedure.

     Definition Classes

     TypeAnalyser

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

     Definition Classes

     Parsers

294.  lazy val optActualParameters: Parser[List[Expression]]

     Definition Classes

     SyntaxAnalyser

295.  def optSectionToDoc(section: String, optds: Option[Seq[Declaration]]): Doc

     Definition Classes

     SourcePrettyPrinter

296.  lazy val optelse: Parser[Option[Block]]

     Definition Classes

     SyntaxAnalyser

297.  lazy val optformalParameters: PackratParser[Seq[FPSection]]

     Definition Classes

     SyntaxAnalyser

298.  lazy val optvar: Parser[Product with Serializable with Mode]

     Definition Classes

     SyntaxAnalyser

299.  def output(str: String): Unit

     Definition Classes

     Values

300.  def outputln(str: String): Unit

     Definition Classes

     Values

301.  def padto(p: Int, d: Doc): Doc

     Definition Classes

     PrettyPrinterBase

302.  def padtobreak(p: Int, d: Doc): Doc

     Definition Classes

     PrettyPrinterBase

303.  lazy val parameters: (Identifier) ⇒ Option[Seq[ParamInfo]]

     Calculate the parameter information list for a procedure.

     Calculate the parameter information list for a procedure. If it's a built-in we have the information already, otherwise we need to work it out from the declaration. Returns None if the entity is not a procedure.

     Definition Classes

     TypeAnalyser

304.  def parammode(u: IdnUse, i: Int): Mode

     Return the ith parameter mode of the procedure denoted by u (counting from one).

     Return the ith parameter mode of the procedure denoted by u (counting from one). If u is not a procedure or has less than i parameters, return a value mode, since that mode places no constraints on its actual parameter.

     Definition Classes

     TypeAnalyser

305.  def paramsToDoc(ds: Seq[Doc], sep: Doc): Doc

     Definition Classes

     SourcePrettyPrinter

306.  def paramtype(u: IdnUse, i: Int): Type

     Return the ith parameter type of the procedure denoted by u (counting from one).

     Return the ith parameter type of the procedure denoted by u (counting from one). If u is not a procedure or has less than i parameters, return an unknown type.

     Definition Classes

     TypeAnalyser

307.  def parens(d: Doc): Doc

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     RegexParsers

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

     Definition Classes

     RegexParsers

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

     Definition Classes

     RegexParsers

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

     Definition Classes

     RegexParsers

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

     Definition Classes

     RegexParsers

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

     Definition Classes

     RegexParsers

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

     Definition Classes

     PositionedParserUtilities

315.  def parseProfileOption(value: String): Seq[Dimension]

     Definition Classes

     Profiler

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

     Definition Classes

     ParserUtilities

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

     Definition Classes

     ParserUtilities

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

     Definition Classes

     ParserUtilities

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

     Definition Classes

     ParserUtilities

320.  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

321.  def parseString[T](parser: Parser[T], str: String): Either[T, String]

     Definition Classes

     ParserUtilities

322.  def parseWhitespace(in: Input): ParseResult[Any]

     Attributes

     protected

     Definition Classes

     WhitespaceParser

323.  lazy val parser: PackratParser[ModuleDecl]

     Definition Classes

     SyntaxAnalyser

324.  implicit def parser2packrat[T](p: ⇒ Parser[T]): PackratParser[T]

     Definition Classes

     PackratParsers

325.  val parsingWhitespace: Boolean

     Attributes

     protected

     Definition Classes

     WhitespaceParser

326.  def pending: Assertion with PendingStatement

     Definition Classes

     Assertions

327.  def pendingUntilFixed(f: ⇒ Unit)(implicit pos: Position): Assertion with PendingStatement

     Definition Classes

     Assertions

328.  def percent: Doc

     Definition Classes

     PrettyPrinterBase

329.  def percent(v: Long, total: Long): String

     Definition Classes

     Profiler

330.  def phrase[T](p: Parser[T]): PackratParser[T]

     Definition Classes

     PackratParsers → Parsers

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

     Definition Classes

     PrettyPrinterBase

332.  def plus: Doc

     Definition Classes

     PrettyPrinterBase

333.  def positioned[T <: Positional](p: ⇒ Parser[T]): Parser[T]

     Definition Classes

     WhitespaceParser → RegexParsers → Parsers

334.  def pretty(d: Doc, w: Width): Layout

     Definition Classes

     PrettyPrinter → PrettyPrinterBase

335.  def pretty(p: PrettyPrintable): Layout

     Definition Classes

     PrettyPrinterBase

336.  def pretty_any(a: Any): Layout

     Definition Classes

     PrettyPrinterBase

337.  def prettyprint(ast: ModuleDecl): String

     Definition Classes

     CompilerBase

338.  def printDependencyGraph(record: Record, dim: Dimension): Unit

     Definition Classes

     Profiler

339.  def printReports(totalTime: Long, dimensionNames: Seq[Dimension], records: List[Record]): Unit

     Definition Classes

     Profiler

340.  val printTables: Boolean

     Definition Classes

     Values

341.  lazy val procedureCall: Parser[Call]

     Definition Classes

     SyntaxAnalyser

342.  lazy val procedureDeclaration: Parser[ProcDecl]

     Definition Classes

     SyntaxAnalyser

343.  def process(filename: String, ast: ModuleDecl, config: Oberon0Config): Unit

     Process the given abstract syntax tree.

     Process the given abstract syntax tree. Send output to emitter, marking sections so that we can split things later.

     Definition Classes

     FrontEndDriver → CompilerWithConfig → CompilerBase

344.  def processast(ast: ModuleDecl, config: Oberon0Config): ModuleDecl

     Process the AST by transforming it.

     Process the AST by transforming it. Then apply higher-level transformations.

     Definition Classes

     TransformingDriver → FrontEndDriver

345.  def processfile(filename: String, config: Oberon0Config): Unit

     Custom driver for section tagging and challenge mode for errors.

     Custom driver for section tagging and challenge mode for errors. If a parse error occurs: in challenge mode, just send "parse failed" to standard output, otherwise send the message to the errors file.

     Definition Classes

     FrontEndDriver → CompilerBase

346.  def processfiles(filenames: Seq[String], config: Oberon0Config): Unit

     Definition Classes

     CompilerBase

347.  def profile[T](computation: ⇒ T, dimensionNames: Seq[Dimension], logging: Boolean): T

     Definition Classes

     Profiler

348.  def profileStart(logging: Boolean): Unit

     Definition Classes

     Profiler

349.  def profileStop(): (Seq[Dimension]) ⇒ Unit

     Definition Classes

     Profiler

350.  def profileStop(dimensionNames: Seq[Dimension]): Unit

     Definition Classes

     Profiler

351.  def profileStopInteractive(): Unit

     Definition Classes

     Profiler

352.  def pseq(l: Seq[PrettyPrintable], prefix: String, elemToDoc: (PrettyPrintable) ⇒ Doc, sep: Doc, sepfn: (Seq[Doc], Doc) ⇒ Doc): Doc

     Definition Classes

     PrettyPrinterBase

353.  def question: Doc

     Definition Classes

     PrettyPrinterBase

354.  def rangle: Doc

     Definition Classes

     PrettyPrinterBase

355.  def rbrace: Doc

     Definition Classes

     PrettyPrinterBase

356.  def rbracket: Doc

     Definition Classes

     PrettyPrinterBase

357.  lazy val readProc: BuiltinProc

     The built-in Read procedure.

     The built-in Read procedure.

     Definition Classes

     SymbolTable

358.  implicit def regex(r: Regex): Parser[String]

     Definition Classes

     WhitespaceParser → RegexParsers

359.  final def registerIgnoredTest(testText: String, testTags: Tag*)(testFun: ⇒ Any)(implicit pos: Position): Unit

     Definition Classes

     FunSuiteLike → TestRegistration

360.  final def registerTest(testText: String, testTags: Tag*)(testFun: ⇒ Any)(implicit pos: Position): Unit

     Definition Classes

     FunSuiteLike → TestRegistration

361.  def rep[T](p: ⇒ Parser[T]): Parser[List[T]]

     Definition Classes

     Parsers

362.  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.

363.  def rep1[T](p: ⇒ Parser[T]): Parser[List[T]]

     Definition Classes

     Parsers

364.  def rep1sep[T](p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]

     Definition Classes

     Parsers

365.  def repN[T](num: Int, p: ⇒ Parser[T]): Parser[List[T]]

     Definition Classes

     Parsers

366.  def repsep[T](p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]

     Definition Classes

     Parsers

367.  def rerunner: Option[String]

     Definition Classes

     Suite

368.  def resetEnvironments(): Unit

     Definition Classes

     Environments

369.  def result[T](v: ⇒ T): Parser[T]

     Definition Classes

     ParserUtilities

370.  lazy val rootconstexp: (Expression) ⇒ Boolean

     Is this expression the root of what is expected to be a constant expression? At this level only expressions on the RHS of a constant declaration have this property.

     Is this expression the root of what is expected to be a constant expression? At this level only expressions on the RHS of a constant declaration have this property.

     Definition Classes

     NameAnalyser

371.  def rootconstexpDef: (Expression) ⇒ Boolean

     Definition Classes

     TypeAnalyser → NameAnalyser → NameAnalyser

372.  def rootenv(bindings: (String, Entity)*): Environment

     Definition Classes

     Environments

373.  def rparen: Doc

     Definition Classes

     PrettyPrinterBase

374.  def run(testName: Option[String], args: Args): Status

     Definition Classes

     BeforeAndAfterAll → SuiteMixin

375.  def runNestedSuites(args: Args): Status

     Attributes

     protected

     Definition Classes

     Suite

376.  def runTest(testName: String, args: Args): Status

     Attributes

     protected

     Definition Classes

     BeforeAndAfter → SuiteMixin

377.  def runTests(testName: Option[String], args: Args): Status

     Attributes

     protected

     Definition Classes

     FunSuiteLike → Suite

378.  def sanitise(s: String): String

     Sanitise the output from a test.

     Sanitise the output from a test. Remove any output that doesn't make sense to this program. I.e., if we are running a program that performs tasks 1-m, then any lines marked with [p], where p > m should be removed before comparison. Also, there can be three numbers, a'la [p,q,r] where p is as before and q (r) are lower (upper) inclusive bounds on the language level to which this output should apply. If p is omitted, the output applies to all task levels. If p is given, but q and r are omitted, the output also applies to all language levels.

     Definition Classes

     TestDriver → TestCompilerWithConfig

379.  def section(emitter: Emitter, name: String): Unit

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

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

     Definition Classes

     Driver

380.  def semi: Doc

     Definition Classes

     PrettyPrinterBase

381.  def semisep(l: Seq[SourceTree], sep: Doc = semi): Doc

     Pretty-print a nested list of nodes separated by sep (default: semi colon) and line breaks.

     Pretty-print a nested list of nodes separated by sep (default: semi colon) and line breaks.

     Definition Classes

     SourcePrettyPrinter

382.  def sep(ds: Seq[Doc]): Doc

     Definition Classes

     PrettyPrinterBase

383.  def seq[T](l: Seq[T], prefix: String, elemToDoc: (T) ⇒ Doc, sep: Doc, sepfn: (Seq[Doc], Doc) ⇒ Doc): Doc

     Definition Classes

     PrettyPrinterBase

384.  lazy val simpexp: PackratParser[Expression]

     Definition Classes

     SyntaxAnalyser

385.  def sizeRange(value: PosZInt): SizeRange

     Definition Classes

     Configuration

386.  def skipWhitespace: Boolean

     Definition Classes

     WhitespaceParser → RegexParsers

387.  def softbreak: Doc

     Definition Classes

     PrettyPrinterBase

388.  def softline: Doc

     Definition Classes

     PrettyPrinterBase

389.  def space: Doc

     Definition Classes

     PrettyPrinterBase

390.  def spaces(n: Int): Doc

     Definition Classes

     PrettyPrinterBase

391.  def squote: Doc

     Definition Classes

     PrettyPrinterBase

392.  def squotes(d: Doc): Doc

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     PrettyPrinterBase

394.  def startReport(dimensionNames: Seq[Dimension]): Unit

     Definition Classes

     Profiler → Values

395.  val startTime: Long

     Definition Classes

     Profiler

396.  lazy val statement: PackratParser[Statement]

     Definition Classes

     SyntaxAnalyser

397.  def statementDef: PackratParser[Statement]

     Definition Classes

     SyntaxAnalyser → SyntaxAnalyser → SyntaxAnalyser → SyntaxAnalyser → SyntaxAnalyser

398.  lazy val statementSequence: Parser[Block]

     Definition Classes

     SyntaxAnalyser

399.  lazy val statements: Parser[Block]

     Definition Classes

     SyntaxAnalyser

400.  lazy val step: Parser[Option[Expression]]

     Definition Classes

     SyntaxAnalyser

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

     Definition Classes

     PrettyPrinterBase

402.  def string(s: String): Doc

     Definition Classes

     PrettyPrinterBase

403.  def stringToInt(s: String): Either[Int, String]

     Definition Classes

     ParserUtilities

404.  final val styleName: String

     Definition Classes

     FunSuiteLike → Suite

405.  def subjectsToStep(src: Any, dst: Any): Step

     Definition Classes

     Profiler

406.  final val succeed: Assertion

     Definition Classes

     Assertions

407.  def success[T](v: T): Parser[T]

     Definition Classes

     Parsers

408.  def suiteId: String

     Definition Classes

     Suite

409.  def suiteName: String

     ScalaTest by default only shows the unqualified class name when it displays the name of the suite.

     ScalaTest by default only shows the unqualified class name when it displays the name of the suite. If a suite class name is used in more than one package we can't tell them apart. Here we override the name that is printed so that we get a project relative source file name as well.

     This definition assumes that the test suite resides in the library project, that the name of the suite class is the same as the basename of the file and that the file is located in the folder given by the package name.

     Definition Classes

     Tests → SuiteMixin → Suite

410.  def summariseAlongDims(dimensionNames: Seq[Dimension], records: List[Record], nrecords: Int, profiledTime: Long): Unit

     Definition Classes

     Profiler

411.  def surround(d: Doc, b: Doc): Doc

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     AnyRef

413.  def tags: Map[String, Set[String]]

     Definition Classes

     FunSuiteLike → Suite

414.  def tasklevel: Int

     Definition Classes

     A4Phases

415.  lazy val term: PackratParser[Expression]

     Definition Classes

     SyntaxAnalyser

416.  def test(testName: String, testTags: Tag*)(testFun: ⇒ Any)(implicit pos: Position): Unit

     Attributes

     protected

     Definition Classes

     FunSuiteLike

417.  def testDataFor(testName: String, theConfigMap: ConfigMap): TestData

     Definition Classes

     FunSuiteLike → Suite

418.  def testNames: Set[String]

     Definition Classes

     FunSuiteLike → Suite

419.  def testdriver(config: Oberon0Config): Unit

     Run the compiler in test mode using the given configuration.

     Run the compiler in test mode using the given configuration.

     Definition Classes

     TestCompilerWithConfig

420.  def testsFor(unit: Unit): Unit

     Attributes

     protected

     Definition Classes

     FunSuiteLike

421.  implicit def text(t: String): Doc

     Definition Classes

     PrettyPrinter → PrettyPrinterBase

422.  def textOf[T](t: T, includeWhiteSpace: Boolean): Option[String]

     Definition Classes

     PositionedParserUtilities

423.  def tilde: Doc

     Definition Classes

     PrettyPrinterBase

424.  def time[T](computation: ⇒ T, warmup: Int, n: Int, discard: Int): Unit

     Definition Classes

     Profiler

425.  lazy val tipe: (Expression) ⇒ Type

     The type of an expression.

     The type of an expression.

     Definition Classes

     TypeAnalyser

426.  def tipeDef: (Expression) ⇒ Type

     Definition Classes

     TypeAnalyser → TypeAnalyser

427.  def toDoc(n: CTree): Doc

     Definition Classes

     CPrettyPrinter → CPrettyPrinter → CPrettyPrinter → CPrettyPrinter

428.  def toDoc(n: SourceTree): Doc

     Definition Classes

     SourcePrettyPrinter → SourcePrettyPrinter → SourcePrettyPrinter → SourcePrettyPrinter → SourcePrettyPrinter → SourcePrettyPrinter

429.  def toParenDoc(e: PrettyExpression): Doc

     CNegExp (CNegExp) special case is to avoid output of --e which is interpreted as a pre-decrement operator.

     CNegExp (CNegExp) special case is to avoid output of --e which is interpreted as a pre-decrement operator.

     Definition Classes

     CPrettyPrinter → CPrettyPrinter → CPrettyPrinter → CPrettyPrinter → ParenPrettyPrinter

430.  def toString(): String

     Definition Classes

     AnyRef → Any

431.  def trace(predicate: (Event) ⇒ Boolean): Unit

     Definition Classes

     Profiler

432.  def transform(m: ModuleDecl): ModuleDecl

     Desugar FOR and CASE statements into simpler constructs.

     Desugar FOR and CASE statements into simpler constructs. Then call the next level of transformation.

     Definition Classes

     Desugarer → Desugarer → Transformer

433.  def translate(e: Expression): CExpression

     Uses of array parameter names don't need to be dereferenced.

     Uses of array parameter names don't need to be dereferenced.

     Definition Classes

     CCodeGenerator → CCodeGenerator → CCodeGenerator

434.  def translate(t: Type): CType

     Add translation for array and record types.

     Add translation for array and record types.

     Definition Classes

     CCodeGenerator → CCodeGenerator

435.  def translate(s: Statement): CStatement

     Add translation of call statements.

     Add translation of call statements.

     Definition Classes

     CCodeGenerator → CCodeGenerator → CCodeGenerator → CCodeGenerator → Translator

436.  def translate(d: Declaration): Seq[CDeclaration]

     Add translation of procedure declarations.

     Add translation of procedure declarations.

     Definition Classes

     CCodeGenerator → CCodeGenerator → CCodeGenerator → Translator

437.  def translate(m: ModuleDecl): CProgram

     Add STDIO header since output is now possible.

     Add STDIO header since output is now possible.

     Definition Classes

     CCodeGenerator → CCodeGenerator → Translator

438.  def translate(eis: Seq[(Expression, Block)], oe: Option[Block]): CStatement

     Translation of expression, block pairs from an IF statement into cascading C IFs.

     Translation of expression, block pairs from an IF statement into cascading C IFs.

     Definition Classes

     CCodeGenerator

439.  def translateActualParam(p: Expression, mode: Mode): CExpression

     Array parameters get passed by reference, so we don't need to insert addressing operations for VAR.

     Array parameters get passed by reference, so we don't need to insert addressing operations for VAR.

     Definition Classes

     CCodeGenerator → CCodeGenerator

440.  def translateActualParams(u: IdnUse, ps: Seq[Expression]): Seq[CExpression]

     Translate the actual parameters of a procedure call.

     Translate the actual parameters of a procedure call. Assumes that the right number of parameters are present.

     Definition Classes

     CCodeGenerator

441.  def translateFormalParam(m: Mode, i: String, t: Type): CDeclaration

     Array formal parameters are not made into address types.

     Array formal parameters are not made into address types.

     Definition Classes

     CCodeGenerator → CCodeGenerator

442.  def translateFormalParams(p: IdnDef): Seq[CDeclaration]

     Translate the formal parameters of a particular defined procedure.

     Translate the formal parameters of a particular defined procedure.

     Definition Classes

     CCodeGenerator

443.  lazy val trueConstant: IntegerValue

     Built-in true constant.

     Built-in true constant.

     Definition Classes

     SymbolTable

444.  def typeCheckedConstraint[A, B](implicit equivalenceOfA: Equivalence[A], ev: <:<[B, A]): CanEqual[A, B]

     Definition Classes

     TripleEquals → TripleEqualsSupport

445.  lazy val typebasetype: (Type) ⇒ Type

     The actual type that a user type denotes.

     The actual type that a user type denotes.

     Definition Classes

     TypeAnalyser

446.  lazy val typedecl: Parser[TypeDecl]

     Definition Classes

     SyntaxAnalyser

447.  lazy val typedeclsection: Parser[List[TypeDecl]]

     Definition Classes

     SyntaxAnalyser

448.  lazy val typedef: PackratParser[TypeDef]

     Definition Classes

     SyntaxAnalyser

449.  def typedefDef: PackratParser[TypeDef]

     Definition Classes

     SyntaxAnalyser → SyntaxAnalyser

450.  implicit def unconstrainedEquality[A, B](implicit equalityOfA: Equality[A]): CanEqual[A, B]

     Definition Classes

     TripleEquals → TripleEqualsSupport

451.  def underscore: Doc

     Definition Classes

     PrettyPrinterBase

452.  def uniquifyNames(m: ModuleDecl): ModuleDecl

     Rename user-defined names to avoid clashes with outer declarations of the same name.

     Rename user-defined names to avoid clashes with outer declarations of the same name. This transformation is not idempotent.

     Definition Classes

     Desugarer

453.  lazy val unknownType: BuiltinType

     A type that is unknown, eg because the typed thing is erroneously defined.

     A type that is unknown, eg because the typed thing is erroneously defined.

     Definition Classes

     SymbolTable

454.  def value(v: Any): Doc

     Definition Classes

     PrettyPrinterBase

455.  lazy val value: (Expression) ⇒ Int

     What is the value of an integer expression? Only needs to be valid if the expression is an integer constant (see isconst above) and is defined (eg, no divide by zero.) Returns zero in all other cases.

     What is the value of an integer expression? Only needs to be valid if the expression is an integer constant (see isconst above) and is defined (eg, no divide by zero.) Returns zero in all other cases. FIXME: Ignores issues of overflow.

     Definition Classes

     NameAnalyser

456.  def valueToString(a: Value): String

     Definition Classes

     Values

457.  lazy val vardecl: Parser[VarDecl]

     Definition Classes

     SyntaxAnalyser

458.  lazy val vardeclsection: Parser[List[VarDecl]]

     Definition Classes

     SyntaxAnalyser

459.  def vcat(ds: Seq[Doc]): Doc

     Definition Classes

     PrettyPrinterBase

460.  def verticalbar: Doc

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     PrettyPrinterBase

462.  def vsep(ds: Seq[Doc]): Doc

     Definition Classes

     PrettyPrinterBase

463.  final def wait(): Unit

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

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

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

465.  final def wait(arg0: Long): Unit

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

466.  lazy val whileStatement: Parser[WhileStatement]

     Definition Classes

     SyntaxAnalyser

467.  val whiteSpace: Regex

     Attributes

     protected

     Definition Classes

     RegexParsers

468.  lazy val whitespaceParser: PackratParser[Any]

     Definition Classes

     SyntaxAnalyser → WhitespaceParser

469.  def width(d: Doc, f: (Int) ⇒ Doc): Doc

     Definition Classes

     PrettyPrinterBase

470.  def withClue[T](clue: Any)(fun: ⇒ T): T

     Definition Classes

     Assertions

471.  def withFixture(test: NoArgTest): Outcome

     Attributes

     protected

     Definition Classes

     TestSuite

472.  def workers(value: PosInt): Workers

     Definition Classes

     Configuration

473.  def wrap[T, U](p: ⇒ Parser[T], f: (T) ⇒ Either[U, String]): Parser[U]

     Definition Classes

     ParserUtilities

474.  lazy val writeProc: BuiltinProc

     The built-in Write procedure.

     The built-in Write procedure.

     Definition Classes

     SymbolTable

475.  lazy val writelnProc: BuiltinProc

     The built-in WriteLn procedure.

     The built-in WriteLn procedure.

     Definition Classes

     SymbolTable

476.  object FocusTest extends Tag

     A ScalaTest tag that enables us to focus attention on particular tests rather than running all of them each time.

     A ScalaTest tag that enables us to focus attention on particular tests rather than running all of them each time. Add this as an argument to the particular test methods that you want to focus on. Then you can use an sbt command such as "test-only *RewriterTests -- -n FocusTest" to run just the tests in that suite with this tag.

     Definition Classes

     Tests