ByteCodeReader

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (ByteCodeReader, B)

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def allOf[A, X](rules: Seq[Rule[A, X]]): (S) ⇒ Result[S, List[A], X]

Create a rule that succeeds if all of the given rules succeed.

def anyOf[A, X](rules: Seq[Rule[A, X]]): rules.Rule[S, S, collection.immutable.List[A], X]

Create a rule that succeeds with a list of all the provided rules that succeed.

def apply[A, X](f: (S) ⇒ Result[S, A, X]): rules.Rule[S, S, A, X]

final def asInstanceOf[T0]: T0

val byte: rules.Rule[S, S, Byte, Nothing]

def bytes(n: Int): rules.Rule[S, S, ByteCode, Nothing]

def clone(): AnyRef

def cond(f: (S) ⇒ Boolean): rules.Rule[S, S, S, Nothing]

Create a rule that identities if f(in) is true.

def ensuring(cond: (ByteCodeReader) ⇒ Boolean, msg: ⇒ Any): ByteCodeReader

def ensuring(cond: (ByteCodeReader) ⇒ Boolean): ByteCodeReader

def ensuring(cond: Boolean, msg: ⇒ Any): ByteCodeReader

def ensuring(cond: Boolean): ByteCodeReader

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def error[X](err: X): rules.Rule[Any, Nothing, Nothing, X]

def error[In]: rules.Rule[In, Nothing, Nothing, In]

def expect[In, Out, A, Any](rule: rules.Rule[In, Out, A, Any]): (In) ⇒ A

Converts a rule into a function that throws an Exception on failure.

val factory: RulesWithState

def failure: rules.Rule[Any, Nothing, Nothing, Nothing]

def finalize(): Unit

def formatted(fmtstr: String): String

def from[In]: AnyRef { def apply[Out, A, X](f: In => scala.tools.scalap.scalax.rules.Result[Out,A,X]): scala.tools.scalap.scalax.rules.Rule[In,Out,A,X] }

def get: rules.Rule[S, S, S, Nothing]

final def getClass(): Class[_]

def hashCode(): Int

implicit def inRule[In, Out, A, X](rule: rules.Rule[In, Out, A, X]): InRule[In, Out, A, X]

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

def nil: rules.Rule[S, S, collection.immutable.Nil.type, Nothing]

def none: rules.Rule[S, S, None.type, Nothing]

final def notify(): Unit

final def notifyAll(): Unit

def oneOf[In, Out, A, X](rules: rules.Rule[In, Out, A, X]*): rules.Rule[In, Out, A, X]

def read[A](f: (S) ⇒ A): rules.Rule[S, S, A, Nothing]

def repeatUntil[T, X](rule: Rule[(T) ⇒ T, X])(finished: (T) ⇒ Boolean)(initial: T): rules.Rule[S, S, T, X]

Repeatedly apply a rule from initial value until finished condition is met.

implicit def rule[In, Out, A, X](f: (In) ⇒ Result[Out, A, X]): rules.Rule[In, Out, A, X]

def ruleWithName[In, Out, A, X](_name: String, f: (In) ⇒ Result[Out, A, X]): rules.Rule[In, Out, A, X] with Name

implicit def seqRule[In, A, X](rule: rules.Rule[In, In, A, X]): SeqRule[In, A, X]

def set(s: ⇒ S): rules.Rule[S, S, S, Nothing]

def state[s]: StateRules { type S = s }

def success[Out, A](out: Out, a: A): rules.Rule[Any, Out, A, Nothing]

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

def toString(): String

val u1: rules.Rule[S, S, Int, Nothing]

val u2: rules.Rule[S, S, Int, Nothing]

val u4: rules.Rule[S, S, Int, Nothing]

def unit[A](a: ⇒ A): rules.Rule[S, S, A, Nothing]

def update(f: (S) ⇒ S): rules.Rule[S, S, S, Nothing]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def →[B](y: B): (ByteCodeReader, B)

val self: Any

val self: Any

def x: ByteCodeReader

def x: ByteCodeReader