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 artefact: String

    The name of this artefact.

    The name of this artefact.

    Definition Classes

    A3Phases → Driver

29.  final def asInstanceOf[T0]: T0

    Definition Classes

    Any

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

    Definition Classes

    Assertions

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

    Definition Classes

    Assertions

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

    Definition Classes

    Assertions

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

    Definition Classes

    Assertions

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

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

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

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

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

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

    Definition Classes

    Assertions

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

    Definition Classes

    Assertions

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

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

    Definition Classes

    Assertions

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

    Definition Classes

    Assertions

44.  val assertionsHelper: AssertionsHelper

    Definition Classes

    Assertions

45.  lazy val assignment: Parser[Assignment]

    Definition Classes

    SyntaxAnalyser

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

    Definition Classes

    Assertions

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

    Definition Classes

    Assertions

48.  def asterisk: Doc

    Definition Classes

    PrettyPrinterBase

49.  def atsign: Doc

    Definition Classes

    PrettyPrinterBase

50.  def backquote: Doc

    Definition Classes

    PrettyPrinterBase

51.  def backslash: Doc

    Definition Classes

    PrettyPrinterBase

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

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

    Attributes

    protected

    Definition Classes

    BeforeAndAfter

54.  def beforeAll(): Unit

    Attributes

    protected

    Definition Classes

    BeforeAndAfterAll

55.  lazy val block: Parser[Block]

    Definition Classes

    SyntaxAnalyser

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

57.  lazy val booleanType: BuiltinType

    Built-in Boolean type.

    Built-in Boolean type.

    Definition Classes

    SymbolTable

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

    Definition Classes

    PrettyPrinterBase

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

    Definition Classes

    ParenPrettyPrinter

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

    Definition Classes

    PrettyPrinterBase

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

    Definition Classes

    Assertions

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

    Definition Classes

    Assertions

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

    Definition Classes

    Assertions

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

    Definition Classes

    Assertions

65.  def caret: Doc

    Definition Classes

    PrettyPrinterBase

66.  lazy val caseStatement: Parser[CaseStatement]

    Definition Classes

    SyntaxAnalyser

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

    Definition Classes

    SourcePrettyPrinter

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

    Definition Classes

    SyntaxAnalyser

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

    Definition Classes

    SourcePrettyPrinter

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

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

    Definition Classes

    PrettyPrinterBase

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

    Definition Classes

    Parsers

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

    Definition Classes

    Parsers

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

    Definition Classes

    Parsers

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

    Definition Classes

    PrettyPrinterBase

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

    Definition Classes

    Checkers

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

    Definition Classes

    Checkers

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

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

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

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

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

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

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

    Definition Classes

    Values

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

86.  def clone(): AnyRef

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

87.  def colon: Doc

    Definition Classes

    PrettyPrinterBase

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

    Definition Classes

    PrettyPrinter → PrettyPrinterBase

89.  def comma: Doc

    Definition Classes

    PrettyPrinterBase

90.  lazy val comment: PackratParser[Any]

    Definition Classes

    SyntaxAnalyser

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

    Definition Classes

    Parsers

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

    Definition Classes

    SyntaxAnalyser

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

    Definition Classes

    SyntaxAnalyser

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

    Definition Classes

    ParserUtilities

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

    Definition Classes

    ParserUtilities

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

    Definition Classes

    ParserUtilities

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

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

99.  lazy val constdecl: Parser[ConstDecl]

    Definition Classes

    SyntaxAnalyser

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

     Definition Classes

     SyntaxAnalyser

101.  lazy val constrainedInt: PackratParser[Int]

     Definition Classes

     ParserUtilities

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

     Consume the AST.

     Consume the AST. For example, translate it to something else. By default, do nothing.

     Definition Classes

     FrontEndDriver

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

     Definition Classes

     TripleEquals → TripleEqualsSupport

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

     Definition Classes

     TripleEquals → TripleEqualsSupport

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

     Definition Classes

     TripleEquals → TripleEqualsSupport

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

     Definition Classes

     TripleEquals → TripleEqualsSupport

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

     Definition Classes

     TripleEquals → TripleEqualsSupport

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

     Definition Classes

     TripleEquals → TripleEqualsSupport

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

     Definition Classes

     TripleEquals → TripleEqualsSupport

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

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

     Definition Classes

     SyntaxAnalyser

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

     Definition Classes

     SyntaxAnalyser → SyntaxAnalyser → SyntaxAnalyser

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

     Definition Classes

     SourcePrettyPrinter

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

     Definition Classes

     SourcePrettyPrinter → SourcePrettyPrinter

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

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

     Definition Classes

     TripleEqualsSupport

117.  val defaultIndent: Int

     Definition Classes

     PrettyPrinterBase

118.  val defaultWidth: Int

     Definition Classes

     PrettyPrinterBase

119.  def defenv: Environment

     The default environment.

     The default environment.

     Definition Classes

     SymbolTable

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

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

     Definition Classes

     Environments

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

     The type given by a type definition.

     The type given by a type definition.

     Definition Classes

     TypeAnalyser

123.  def deftypeDef: (TypeDef) ⇒ Type

     Definition Classes

     TypeAnalyser

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

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

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

     Definition Classes

     Profiler → Profiler → Values

127.  def dollar: Doc

     Definition Classes

     PrettyPrinterBase

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

129.  def dot: Doc

     Definition Classes

     PrettyPrinterBase

130.  def dquote: Doc

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     CompilerBase

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

     Definition Classes

     Parsers

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

     Definition Classes

     Parsers

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

     Definition Classes

     SyntaxAnalyser

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

     Definition Classes

     SyntaxAnalyser

137.  def empty: Doc

     Definition Classes

     PrettyPrinter → PrettyPrinterBase

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

     Definition Classes

     PrettyPrinterBase

139.  def encoding: String

     Definition Classes

     CompilerBase

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

     Definition Classes

     Environments

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

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

     NameAnalyser → NameAnalyser

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

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

     Definition Classes

     NameAnalyser → NameAnalyser

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

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

     Definition Classes

     NameAnalyser → NameAnalyser

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

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

     Definition Classes

     AnyRef

149.  def equal: Doc

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     AnyRef → Any

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

     Definition Classes

     ParserUtilities → Parsers

152.  val errors: (SourceTree) ⇒ Messages

     The semantic errors for a tree.

     The semantic errors for a tree.

     Definition Classes

     Analyser

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

     The error checking for this level.

     The error checking for this level.

     Definition Classes

     TypeAnalyser → NameAnalyser → TypeAnalyser → TypeAnalyser → NameAnalyser → Analyser

154.  def exclamation: Doc

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     Suite

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

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

     Definition Classes

     Suite

158.  lazy val expression: Parser[Expression]

     Definition Classes

     SyntaxAnalyser

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

160.  def exptypeDef: (Expression) ⇒ Type

     The expected type of a parameter to a call is the type of the parameter at that position.

     The expected type of a parameter to a call is the type of the parameter at that position.

     Definition Classes

     TypeAnalyser → TypeAnalyser → TypeAnalyser → TypeAnalyser

161.  lazy val factor: PackratParser[Expression]

     Definition Classes

     SyntaxAnalyser

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

     Definition Classes

     Assertions

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

     Definition Classes

     Assertions

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

     Definition Classes

     Assertions

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

     Definition Classes

     Assertions

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

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

     Definition Classes

     ParserUtilities → Parsers

168.  lazy val falseConstant: IntegerValue

     Built-in false constant.

     Built-in false constant.

     Definition Classes

     SymbolTable

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

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

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     PrettyPrinterBase

173.  def finalize(): Unit

     Attributes

     protected[java.lang]

     Definition Classes

     AnyRef

     Annotations

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

174.  def finishReport(): Unit

     Definition Classes

     Values

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

     Definition Classes

     PrettyPrinterBase

176.  lazy val forStatement: Parser[ForStatement]

     Definition Classes

     SyntaxAnalyser

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

     Definition Classes

     SourcePrettyPrinter

178.  lazy val forVar: Parser[IdnExp]

     Definition Classes

     SyntaxAnalyser

179.  def forwslash: Doc

     Definition Classes

     PrettyPrinterBase

180.  lazy val fpsection: Parser[FPSection]

     Definition Classes

     SyntaxAnalyser

181.  implicit val generatorDrivenConfig: PropertyCheckConfiguration

     Definition Classes

     Configuration

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

     Definition Classes

     AnyRef → Any

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

     Definition Classes

     PrettyPrinter → PrettyPrinterBase

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

     Definition Classes

     Parsers

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

     Definition Classes

     WhitespacePositionedParserUtilities → ParserUtilities

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

     Attributes

     protected

     Definition Classes

     RegexParsers

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

     Definition Classes

     PrettyPrinterBase

188.  def hash: Doc

     Definition Classes

     PrettyPrinterBase

189.  def hashCode(): Int

     Definition Classes

     AnyRef → Any

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

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     PrettyPrinterBase

193.  lazy val ident: Parser[String]

     Definition Classes

     SyntaxAnalyser

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

     Definition Classes

     SourcePrettyPrinter

195.  lazy val idndef: Parser[IdnDef]

     Definition Classes

     SyntaxAnalyser

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

     Definition Classes

     SyntaxAnalyser

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

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

199.  lazy val idnuse: Parser[IdnUse]

     Definition Classes

     SyntaxAnalyser

200.  lazy val ifStatement: Parser[IfStatement]

     Definition Classes

     SyntaxAnalyser

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

     Definition Classes

     SourcePrettyPrinter

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

     Attributes

     protected

     Definition Classes

     FunSuiteLike

203.  def includeTimings: Boolean

     Definition Classes

     Profiler

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

     Definition Classes

     PrettyPrinterBase

205.  def info: Informer

     Attributes

     protected

     Definition Classes

     FunSuiteLike → Informing

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

207.  lazy val integerType: BuiltinType

     Built-in integer type.

     Built-in integer type.

     Definition Classes

     SymbolTable

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

     Definition Classes

     Assertions

209.  lazy val intexp: Parser[IntExp]

     Definition Classes

     SyntaxAnalyser

210.  val invokeBeforeAllAndAfterAllEvenIfNoTestsAreExpected: Boolean

     Definition Classes

     BeforeAndAfterAll

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

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

     Compatibility of types.

     Compatibility of types. Return true if the type is compatible with the expected type. Unknown types are compatible with any other type. Otherwise, use look up the base types of what we have and compare them.

     Definition Classes

     TypeAnalyser

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

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

     Definition Classes

     Environments

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

     Definition Classes

     Environments

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

     Definition Classes

     Environments

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

     Definition Classes

     Environments

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

     Definition Classes

     Environments

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

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

     Definition Classes

     Values

221.  final def isInstanceOf[T0]: Boolean

     Definition Classes

     Any

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

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

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

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

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

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

     Parameters are variables too.

     Parameters are variables too.

     Definition Classes

     SymbolTable → SymbolTable

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

229.  lazy val kase: Parser[Case]

     Definition Classes

     SyntaxAnalyser

230.  lazy val keyword: Parser[String]

     Definition Classes

     SyntaxAnalyser

231.  def keywordStrings: Seq[String]

     Definition Classes

     SyntaxAnalyser → SyntaxAnalyser → SyntaxAnalyser → SyntaxAnalyser → SyntaxAnalyser

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

     Definition Classes

     ParserUtilities

233.  def langle: Doc

     Definition Classes

     PrettyPrinterBase

234.  def langlevel: Int

     Definition Classes

     A3Phases

235.  def lbrace: Doc

     Definition Classes

     PrettyPrinterBase

236.  def lbracket: Doc

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     Environments

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

239.  lazy val lhs: PackratParser[Expression]

     Definition Classes

     SyntaxAnalyser

240.  def lhsDef: PackratParser[Expression]

     Definition Classes

     SyntaxAnalyser

241.  def line: Doc

     Definition Classes

     PrettyPrinter → PrettyPrinterBase

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

     Definition Classes

     PrettyPrinter → PrettyPrinterBase

243.  def linebreak: Doc

     Definition Classes

     PrettyPrinter → PrettyPrinterBase

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

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     WhitespaceParser → RegexParsers

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

     Definition Classes

     Parsers

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

     Definition Classes

     Environments

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

     Definition Classes

     TripleEquals → TripleEqualsSupport

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

     Definition Classes

     TripleEquals → TripleEqualsSupport

250.  def lparen: Doc

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     CompilerBase

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

     Definition Classes

     CompilerWithConfig → CompilerBase

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

     Definition Classes

     PositionedParserUtilities

257.  def markup: Documenter

     Attributes

     protected

     Definition Classes

     FunSuiteLike → Documenting

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

     Definition Classes

     Configuration

259.  val maxlanglevel: Int

     The maximum language level we support.

     The maximum language level we support.

     Definition Classes

     TestDriver

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

     Definition Classes

     PackratParsers

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

     Definition Classes

     Configuration

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

     Definition Classes

     Configuration

263.  def minus: Doc

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     Parsers

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

266.  lazy val moduledecl: Parser[ModuleDecl]

     Definition Classes

     SyntaxAnalyser

267.  val nameCounter: Counter

     Definition Classes

     Environments

268.  lazy val namedtypedef: Parser[NamedType]

     Definition Classes

     SyntaxAnalyser

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

     Definition Classes

     Profiler

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

     Definition Classes

     AnyRef

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

     Definition Classes

     PrettyPrinter → PrettyPrinterBase

272.  def nestedSuites: IndexedSeq[Suite]

     Definition Classes

     Suite

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

     Definition Classes

     PrettyPrinter → PrettyPrinterBase

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

     Definition Classes

     ParenPrettyPrinter

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

     Definition Classes

     Parsers

276.  def note: Notifier

     Attributes

     protected

     Definition Classes

     FunSuiteLike → Notifying

277.  final def notify(): Unit

     Definition Classes

     AnyRef

278.  final def notifyAll(): Unit

     Definition Classes

     AnyRef

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

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

     Definition Classes

     Parsers

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

     Definition Classes

     SyntaxAnalyser

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

     Definition Classes

     SourcePrettyPrinter

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

     Definition Classes

     SyntaxAnalyser

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

     Definition Classes

     SyntaxAnalyser

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

     Definition Classes

     SyntaxAnalyser

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

     Definition Classes

     Values

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

     Definition Classes

     Values

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

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     PrettyPrinterBase

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

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

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

     Definition Classes

     SourcePrettyPrinter

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

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

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     RegexParsers

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

     Definition Classes

     RegexParsers

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

     Definition Classes

     RegexParsers

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

     Definition Classes

     RegexParsers

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

     Definition Classes

     RegexParsers

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

     Definition Classes

     RegexParsers

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

     Definition Classes

     PositionedParserUtilities

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

     Definition Classes

     Profiler

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

     Definition Classes

     ParserUtilities

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

     Definition Classes

     ParserUtilities

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

     Definition Classes

     ParserUtilities

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

     Definition Classes

     ParserUtilities

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

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

     Definition Classes

     ParserUtilities

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

     Attributes

     protected

     Definition Classes

     WhitespaceParser

310.  lazy val parser: PackratParser[ModuleDecl]

     Definition Classes

     SyntaxAnalyser

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

     Definition Classes

     PackratParsers

312.  val parsingWhitespace: Boolean

     Attributes

     protected

     Definition Classes

     WhitespaceParser

313.  def pending: Assertion with PendingStatement

     Definition Classes

     Assertions

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

     Definition Classes

     Assertions

315.  def percent: Doc

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     Profiler

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

     Definition Classes

     PackratParsers → Parsers

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

     Definition Classes

     PrettyPrinterBase

319.  def plus: Doc

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     WhitespaceParser → RegexParsers → Parsers

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

     Definition Classes

     PrettyPrinter → PrettyPrinterBase

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

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     CompilerBase

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

     Definition Classes

     Profiler

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

     Definition Classes

     Profiler

327.  val printTables: Boolean

     Definition Classes

     Values

328.  lazy val procedureCall: Parser[Call]

     Definition Classes

     SyntaxAnalyser

329.  lazy val procedureDeclaration: Parser[ProcDecl]

     Definition Classes

     SyntaxAnalyser

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

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

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

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

     Definition Classes

     CompilerBase

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

     Definition Classes

     Profiler

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

     Definition Classes

     Profiler

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

     Definition Classes

     Profiler

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

     Definition Classes

     Profiler

338.  def profileStopInteractive(): Unit

     Definition Classes

     Profiler

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

     Definition Classes

     PrettyPrinterBase

340.  def question: Doc

     Definition Classes

     PrettyPrinterBase

341.  def rangle: Doc

     Definition Classes

     PrettyPrinterBase

342.  def rbrace: Doc

     Definition Classes

     PrettyPrinterBase

343.  def rbracket: Doc

     Definition Classes

     PrettyPrinterBase

344.  lazy val readProc: BuiltinProc

     The built-in Read procedure.

     The built-in Read procedure.

     Definition Classes

     SymbolTable

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

     Definition Classes

     WhitespaceParser → RegexParsers

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

     Definition Classes

     FunSuiteLike → TestRegistration

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

     Definition Classes

     FunSuiteLike → TestRegistration

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

     Definition Classes

     Parsers

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

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

     Definition Classes

     Parsers

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

     Definition Classes

     Parsers

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

     Definition Classes

     Parsers

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

     Definition Classes

     Parsers

354.  def rerunner: Option[String]

     Definition Classes

     Suite

355.  def resetEnvironments(): Unit

     Definition Classes

     Environments

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

     Definition Classes

     ParserUtilities

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

358.  def rootconstexpDef: (Expression) ⇒ Boolean

     Definition Classes

     NameAnalyser → NameAnalyser

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

     Definition Classes

     Environments

360.  def rparen: Doc

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     BeforeAndAfterAll → SuiteMixin

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

     Attributes

     protected

     Definition Classes

     Suite

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

     Attributes

     protected

     Definition Classes

     BeforeAndAfter → SuiteMixin

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

     Attributes

     protected

     Definition Classes

     FunSuiteLike → Suite

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

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

367.  def semi: Doc

     Definition Classes

     PrettyPrinterBase

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

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

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     PrettyPrinterBase

371.  lazy val simpexp: PackratParser[Expression]

     Definition Classes

     SyntaxAnalyser

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

     Definition Classes

     Configuration

373.  def skipWhitespace: Boolean

     Definition Classes

     WhitespaceParser → RegexParsers

374.  def softbreak: Doc

     Definition Classes

     PrettyPrinterBase

375.  def softline: Doc

     Definition Classes

     PrettyPrinterBase

376.  def space: Doc

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     PrettyPrinterBase

378.  def squote: Doc

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     Profiler → Values

382.  val startTime: Long

     Definition Classes

     Profiler

383.  lazy val statement: PackratParser[Statement]

     Definition Classes

     SyntaxAnalyser

384.  def statementDef: PackratParser[Statement]

     Definition Classes

     SyntaxAnalyser → SyntaxAnalyser → SyntaxAnalyser → SyntaxAnalyser → SyntaxAnalyser

385.  lazy val statementSequence: Parser[Block]

     Definition Classes

     SyntaxAnalyser

386.  lazy val statements: Parser[Block]

     Definition Classes

     SyntaxAnalyser

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

     Definition Classes

     SyntaxAnalyser

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

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     ParserUtilities

391.  final val styleName: String

     Definition Classes

     FunSuiteLike → Suite

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

     Definition Classes

     Profiler

393.  final val succeed: Assertion

     Definition Classes

     Assertions

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

     Definition Classes

     Parsers

395.  def suiteId: String

     Definition Classes

     Suite

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

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

     Definition Classes

     Profiler

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

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     AnyRef

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

     Definition Classes

     FunSuiteLike → Suite

401.  def tasklevel: Int

     Definition Classes

     A3Phases

402.  lazy val term: PackratParser[Expression]

     Definition Classes

     SyntaxAnalyser

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

     Attributes

     protected

     Definition Classes

     FunSuiteLike

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

     Definition Classes

     FunSuiteLike → Suite

405.  def testNames: Set[String]

     Definition Classes

     FunSuiteLike → Suite

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

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

     Attributes

     protected

     Definition Classes

     FunSuiteLike

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

     Definition Classes

     PrettyPrinter → PrettyPrinterBase

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

     Definition Classes

     PositionedParserUtilities

410.  def tilde: Doc

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     Profiler

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

     The type of an expression.

     The type of an expression.

     Definition Classes

     TypeAnalyser

413.  def tipeDef: (Expression) ⇒ Type

     Definition Classes

     TypeAnalyser

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

     Definition Classes

     SourcePrettyPrinter → SourcePrettyPrinter → SourcePrettyPrinter → SourcePrettyPrinter → SourcePrettyPrinter

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

     Definition Classes

     SourcePrettyPrinter → ParenPrettyPrinter

416.  def toString(): String

     Definition Classes

     AnyRef → Any

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

     Definition Classes

     Profiler

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

419.  lazy val trueConstant: IntegerValue

     Built-in true constant.

     Built-in true constant.

     Definition Classes

     SymbolTable

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

     Definition Classes

     TripleEquals → TripleEqualsSupport

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

     The actual type that a user type denotes.

     The actual type that a user type denotes.

     Definition Classes

     TypeAnalyser

422.  lazy val typedecl: Parser[TypeDecl]

     Definition Classes

     SyntaxAnalyser

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

     Definition Classes

     SyntaxAnalyser

424.  lazy val typedef: PackratParser[TypeDef]

     Definition Classes

     SyntaxAnalyser

425.  def typedefDef: PackratParser[TypeDef]

     Definition Classes

     SyntaxAnalyser

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

     Definition Classes

     TripleEquals → TripleEqualsSupport

427.  def underscore: Doc

     Definition Classes

     PrettyPrinterBase

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

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

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

     Definition Classes

     PrettyPrinterBase

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

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

     Definition Classes

     Values

433.  lazy val vardecl: Parser[VarDecl]

     Definition Classes

     SyntaxAnalyser

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

     Definition Classes

     SyntaxAnalyser

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

     Definition Classes

     PrettyPrinterBase

436.  def verticalbar: Doc

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     PrettyPrinterBase

439.  final def wait(): Unit

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

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

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

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

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

442.  lazy val whileStatement: Parser[WhileStatement]

     Definition Classes

     SyntaxAnalyser

443.  val whiteSpace: Regex

     Attributes

     protected

     Definition Classes

     RegexParsers

444.  lazy val whitespaceParser: PackratParser[Any]

     Definition Classes

     SyntaxAnalyser → WhitespaceParser

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

     Definition Classes

     PrettyPrinterBase

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

     Definition Classes

     Assertions

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

     Attributes

     protected

     Definition Classes

     TestSuite

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

     Definition Classes

     Configuration

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

     Definition Classes

     ParserUtilities

450.  lazy val writeProc: BuiltinProc

     The built-in Write procedure.

     The built-in Write procedure.

     Definition Classes

     SymbolTable

451.  lazy val writelnProc: BuiltinProc

     The built-in WriteLn procedure.

     The built-in WriteLn procedure.

     Definition Classes

     SymbolTable

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