Instance Constructors
-
new
ObrNumberingTest
()
Type Members
-
type
?0
-
type
Elem
= Char
-
type
Input
= Reader[Elem]
-
case class
Pos
(s: String) extends Positional with Product with Serializable
-
type
_$4
-
type
_$4
-
type
_$4
-
type
_$5
-
type
_$5
-
type
_$5
-
type
_$6
-
type
_$6
-
type
_$6
-
type
_$7
-
type
_$7
-
type
_$7
-
type
_$8
-
type
_$8
-
type
_$8
-
type
_$9
-
type
_$9
-
type
_$9
Value Members
-
def
!=
(arg0: AnyRef): Boolean
-
def
!=
(arg0: Any): Boolean
-
def
##
(): Int
-
def
==
(arg0: AnyRef): Boolean
-
def
==
(arg0: Any): Boolean
-
def
OnceParser
[T]
(f: (Input) ⇒ ParseResult[T]): Parser[T] with OnceParser[T]
-
def
Parser
[T]
(f: (Input) ⇒ ParseResult[T]): Parser[T]
-
def
accept
[U]
(expected: String, f: PartialFunction[Elem, U]): Parser[U]
-
def
accept
[ES]
(es: ES)(implicit arg0: (ES) ⇒ List[Elem]): Parser[List[Elem]]
-
implicit def
accept
(e: Elem): Parser[Elem]
-
def
acceptIf
(p: (Elem) ⇒ Boolean)(err: (Elem) ⇒ String): Parser[Elem]
-
def
acceptMatch
[U]
(expected: String, f: PartialFunction[Elem, U]): Parser[U]
-
def
acceptSeq
[ES]
(es: ES)(implicit arg0: (ES) ⇒ Iterable[Elem]): Parser[List[Elem]]
-
def
any
: PackratParser[Char]
-
def
asInstanceOf
[T0]
: T0
-
def
assert
(o: Option[String]): Unit
-
def
assert
(o: Option[String], clue: Any): Unit
-
def
assert
(condition: Boolean, clue: Any): Unit
-
def
assert
(condition: Boolean): Unit
-
lazy val
catchclause
: Parser[Catch]
-
def
chainl1
[T, U]
(first: ⇒ Parser[T], p: ⇒ Parser[U], q: ⇒ Parser[(T, U) ⇒ T]): Parser[T]
-
def
chainl1
[T]
(p: ⇒ Parser[T], q: ⇒ Parser[(T, T) ⇒ T]): Parser[T]
-
def
chainr1
[T, U]
(p: ⇒ Parser[T], q: ⇒ Parser[(T, U) ⇒ U], combine: (T, U) ⇒ U, first: U): Parser[U]
-
def
checkargs
(args: Array[String], emitter: Emitter): Array[String]
-
def
checkintdatums
(expected: List[Int])(title: String, emitter: Emitter, code: RISCNode): Unit
-
def
clone
(): AnyRef
-
def
commit
[T]
(p: ⇒ Parser[T]): Parser[T]
-
def
compile
(args: Array[String], console: Console): String
-
lazy val
conditional
: Parser[IfStmt]
-
implicit def
constToTupleFunction2
[A, B, R]
(r: (A, B) ⇒ R): (~[A, B]) ⇒ R
-
implicit def
constToTupleFunction3
[A, B, C, R]
(r: (A, B, C) ⇒ R): (~[~[A, B], C]) ⇒ R
-
implicit def
constToTupleFunction4
[A, B, C, D, R]
(r: (A, B, C, D) ⇒ R): (~[~[~[A, B], C], D]) ⇒ R
-
implicit def
constToTupleFunction5
[A, B, C, D, E, R]
(r: (A, B, C, D, E) ⇒ R): (~[~[~[~[A, B], C], D], E]) ⇒ R
-
implicit def
constToTupleFunction6
[A, B, C, D, E, F, R]
(r: (A, B, C, D, E, F) ⇒ R): (~[~[~[~[~[A, B], C], D], E], F]) ⇒ R
-
lazy val
constantdecl
: Parser[Declaration]
-
lazy val
constantdecls
: Parser[List[Declaration]]
-
lazy val
constrainedInt
: PackratParser[Int]
-
implicit def
convertToEqualizer
(left: Any): Equalizer
-
lazy val
declarations
: Parser[List[Declaration]]
-
def
dosanitisation
: Boolean
-
def
driver
(args: Array[String], console: Console, emitter: Emitter): Unit
-
def
elem
(e: Elem): Parser[Elem]
-
def
elem
(kind: String, p: (Elem) ⇒ Boolean): Parser[Elem]
-
def
eq
(arg0: AnyRef): Boolean
-
def
equals
(arg0: Any): Boolean
-
def
err
(msg: String): Parser[Nothing]
-
var
execFlag
: Boolean
-
def
execute
(testName: String, configMap: Map[String, Any], color: Boolean, durations: Boolean, shortstacks: Boolean, fullstacks: Boolean, stats: Boolean): Unit
-
def
expect
(expected: Any)(actual: Any): Unit
-
def
expect
(expected: Any, clue: Any)(actual: Any): Unit
-
def
expectedTestCount
(filter: Filter): Int
-
lazy val
expression
: PackratParser[Expression]
-
lazy val
factor
: PackratParser[Expression]
-
def
fail
(cause: Throwable): Nothing
-
def
fail
(message: String, cause: Throwable): Nothing
-
def
fail
(message: String): Nothing
-
def
fail
(): Nothing
-
def
failure
(msg: String): Parser[Nothing]
-
lazy val
fielddecl
: Parser[Identifier]
-
def
filetests
(name: String, path: String, srcext: String, resext: String, optinext: Option[String] = None, indefault: String = "", argslist: List[Array[String]] = List (Array ())): Unit
-
def
finalize
(): Unit
-
def
getClass
(): java.lang.Class[_]
-
def
guard
[T]
(p: ⇒ Parser[T]): Parser[T]
-
def
handleWhiteSpace
(source: CharSequence, offset: Int): Int
-
def
hashCode
(): Int
-
lazy val
ident
: PackratParser[Identifier]
-
def
ignore
(testName: String, testTags: Tag*)(testFun: ⇒ Unit): Unit
-
implicit def
info
: Informer
-
lazy val
integer
: PackratParser[Int]
-
def
intercept
[T <: AnyRef]
(f: ⇒ Any)(implicit manifest: Manifest[T]): T
-
def
isInstanceOf
[T0]
: Boolean
-
lazy val
iteration
: Parser[Statement]
-
var
lastNoSuccess
: NoSuccess
-
implicit def
literal
(s: String): Parser[String]
-
def
log
[T]
(p: ⇒ Parser[T])(name: String): Parser[T]
-
lazy val
lvalue
: PackratParser[AssignNode]
-
def
main
(args: Array[String]): Unit
-
def
makeast
(reader: Reader, filename: String, emitter: Emitter): Either[ObrInt, String]
-
def
memo
[T]
(p: Parser[T]): PackratParser[T]
-
def
mkList
[T]
: (~[T, List[T]]) ⇒ List[T]
-
def
ne
(arg0: AnyRef): Boolean
-
def
nestedSuites
: List[Suite]
-
def
not
[T]
(p: ⇒ Parser[T]): Parser[Unit]
-
def
notify
(): Unit
-
def
notifyAll
(): Unit
-
def
opt
[T]
(p: ⇒ Parser[T]): Parser[Option[T]]
-
lazy val
optelseend
: Parser[List[Statement]]
-
lazy val
parameterdecl
: Parser[Declaration]
-
def
parse
[T]
(p: Parser[T], in: Reader): ParseResult[T]
-
def
parse
[T]
(p: Parser[T], in: CharSequence): ParseResult[T]
-
def
parse
[T]
(p: Parser[T], in: Reader[Char]): ParseResult[T]
-
def
parseAll
[T]
(p: Parser[T], in: CharSequence): ParseResult[T]
-
def
parseAll
[T]
(p: Parser[T], in: Reader): ParseResult[T]
-
def
parseAll
[T]
(p: Parser[T], in: Reader[Char]): ParseResult[T]
-
implicit def
parseResultToTuple2
[A, B]
(p: Parser[~[A, B]]): PackratParser[(A, B)]
-
implicit def
parseResultToTuple3
[A, B, C]
(p: Parser[~[~[A, B], C]]): PackratParser[(A, B, C)]
-
implicit def
parseResultToTuple4
[A, B, C, D]
(p: Parser[~[~[~[A, B], C], D]]): PackratParser[(A, B, C, D)]
-
implicit def
parseResultToTuple5
[A, B, C, D, E]
(p: Parser[~[~[~[~[A, B], C], D], E]]): PackratParser[(A, B, C, D, E)]
-
implicit def
parseResultToTuple6
[A, B, C, D, E, F]
(p: Parser[~[~[~[~[~[A, B], C], D], E], F]]): PackratParser[(A, B, C, D, E, F)]
-
lazy val
parser
: Parser[ObrInt]
-
implicit def
parser2packrat
[T]
(p: ⇒ Parser[T]): PackratParser[T]
-
def
pending
: PendingNothing
-
def
pendingUntilFixed
(f: ⇒ Unit): Unit
-
def
phrase
[T]
(p: Parser[T]): PackratParser[T]
-
def
positioned
[T <: Positional]
(p: ⇒ Parser[T]): Parser[T]
-
def
process
(ast: ObrInt, console: Console, emitter: Emitter): Boolean
-
lazy val
program
: Parser[ObrInt]
-
implicit def
regex
(r: Regex): Parser[String]
-
def
rep
[T]
(p: ⇒ Parser[T]): Parser[List[T]]
-
def
rep1
[T]
(first: ⇒ Parser[T], p0: ⇒ Parser[T]): Parser[List[T]]
-
def
rep1
[T]
(p: ⇒ Parser[T]): Parser[List[T]]
-
def
rep1sep
[T]
(p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]
-
def
repN
[T]
(num: Int, p: ⇒ Parser[T]): Parser[List[T]]
-
def
repsep
[T]
(p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]
-
val
reservedWords
: HashSet[String]
-
def
result
[T]
(v: ⇒ T): Parser[T]
-
def
run
(testName: Option[String], reporter: Reporter, stopper: Stopper, filter: Filter, configMap: Map[String, Any], distributor: Option[Distributor], tracker: Tracker): Unit
-
def
runNestedSuites
(reporter: Reporter, stopper: Stopper, filter: Filter, configMap: Map[String, Any], distributor: Option[Distributor], tracker: Tracker): Unit
-
def
runTest
(testName: String, reporter: Reporter, stopper: Stopper, configMap: Map[String, Any], tracker: Tracker): Unit
-
def
runTests
(testName: Option[String], reporter: Reporter, stopper: Stopper, filter: Filter, configMap: Map[String, Any], distributor: Option[Distributor], tracker: Tracker): Unit
-
def
sanitise
(s: String): String
-
lazy val
signed
: PackratParser[Int]
-
lazy val
simplexp
: PackratParser[Expression]
-
def
skipWhitespace
: Boolean
-
var
spillEnvirFlag
: Boolean
-
var
spillRISCAssemFlag
: Boolean
-
var
spillTargetTreeFlag
: Boolean
-
lazy val
statement
: Parser[Statement]
-
lazy val
statementseq
: Parser[List[Statement]]
-
def
stringToInt
(s: String): Either[Int, String]
-
def
success
[T]
(v: T): Parser[T]
-
def
suiteName
: String
-
def
synchronized
[T0]
(arg0: ⇒ T0): T0
-
def
tags
: Map[String, Set[String]]
-
def
targettreetest
(name: String, dirname: String, obrfile: String, tester: (String, Emitter, RISCNode) ⇒ Unit, emitter: Emitter = new Emitter): Unit
-
lazy val
term
: PackratParser[Expression]
-
def
test
(testName: String, testTags: Tag*)(testFun: ⇒ Unit): Unit
-
def
testNames
: Set[String]
-
def
testsFor
(unit: Unit): Unit
-
def
toString
(): String
-
lazy val
trycatch
: Parser[TryStmt]
-
val
usage
: String
-
lazy val
variabledecl
: Parser[Declaration]
-
lazy val
variabledecls
: Parser[List[Declaration]]
-
def
wait
(): Unit
-
def
wait
(arg0: Long, arg1: Int): Unit
-
def
wait
(arg0: Long): Unit
-
val
whiteSpace
: Regex
-
def
withClue
(clue: Any)(fun: ⇒ Unit): Unit
-
def
withFixture
(test: NoArgTest): Unit
-
def
withPos
(op: Parser[String]): Parser[Pos]
-
def
wrap
[T, U]
(p: ⇒ Parser[T], f: (T) ⇒ Either[U, String]): Parser[U]
Inherited from FunSuite
Inherited from Suite
Inherited from Serializable
Inherited from AbstractSuite
Inherited from Assertions
Inherited from Compiler[ObrInt]
Inherited from RegexCompiler[ObrInt]
Inherited from CompilerBase[ObrInt]
Inherited from ParserUtilities
Inherited from PackratParsers
Inherited from RegexParsers
Inherited from Parsers
Inherited from AnyRef
Inherited from Any
Obr tests: check that exception and enumeration numbers are correct. Simply compiles the files except8.obr and enumtest2.obr then collects together the list of integers which occur in the IntDatum leaves of the resulting RISCTrees (in bottom up, left to right post-order). Having done that it then checks that list to see if the integers that should be attached to applied uses of each constant of the original source file occur in an appropriate order.