ScalaSigEntryParsers

Type Members

class DefaultRule[In, Out, A, X] extends Rule[In, Out, A, X]

Definition Classes
Rules
type EntryParser[A] = scalap.Rule[S, S, A, String]
trait FromRule[In] extends AnyRef

Definition Classes
Rules
type Rule[+A, +X] = scalap.Rule[S, S, A, X]

Definition Classes
StateRules
type S = Entry

Definition Classes
ScalaSigEntryParsers → StateRules

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
val aliasSymbol: scalap.Rule[S, S, AliasSymbol, String] with Name
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.
Create a rule that succeeds if all of the given rules succeed.
rules
the rules to apply in sequence.

Definition Classes
StateRules
lazy val annotInfo: scalap.Rule[S, S, AnnotInfo, String]
def anyOf[A, X](rules: Seq[Rule[A, X]]): scalap.Rule[S, S, List[A], X]

Create a rule that succeeds with a list of all the provided rules that succeed.
Create a rule that succeeds with a list of all the provided rules that succeed.
rules
the rules to apply in sequence.

Definition Classes
StateRules
def apply[A, X](f: (S) ⇒ Result[S, A, X]): scalap.Rule[S, S, A, X]

Definition Classes
StateRules
final def asInstanceOf[T0]: T0

Definition Classes
Any
val attribTreeRef: EntryParser[Int]
lazy val attributeInfo: scalap.Rule[S, S, AttributeInfo, String]
implicit def byteCodeEntryParser[A](rule: ScalaSigAttributeParsers.Parser[A]): EntryParser[A]
lazy val children: scalap.Rule[S, S, Children, String]
val classSymRef: EntryParser[ClassSymbol]
val classSymbol: scalap.Rule[S, S, ClassSymbol, String] with Name
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def cond(f: (S) ⇒ Boolean): scalap.Rule[S, S, S, Nothing]

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

Definition Classes
StateRules
lazy val constantRef: EntryParser[Any]
lazy val entry: EntryParser[Any]
implicit def entryType(code: Int): scalap.Rule[S, S, Int, Nothing]
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def error[X](err: X): scalap.Rule[Any, Nothing, Nothing, X]

Definition Classes
Rules
def error[In]: scalap.Rule[In, Nothing, Nothing, In]

Definition Classes
Rules
def expect[In, Out, A, Any](rule: scalap.Rule[In, Out, A, Any]): (In) ⇒ A

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

Definition Classes
Rules
val extModClassRef: scalap.Rule[S, S, ExternalSymbol, String] with Name
val extRef: scalap.Rule[S, S, ExternalSymbol, String] with Name
val factory: RulesWithState

Definition Classes
RulesWithState → StateRules
def failure: scalap.Rule[Any, Nothing, Nothing, Nothing]

Definition Classes
Rules
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def from[In]: FromRule[In]

Definition Classes
Rules
def get: scalap.Rule[S, S, S, Nothing]

Definition Classes
StateRules
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
implicit def inRule[In, Out, A, X](rule: scalap.Rule[In, Out, A, X]): InRule[In, Out, A, X]

Definition Classes
Rules
val index: scalap.Rule[S, S, Int, Nothing]
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isTopLevel(symbol: Symbol): Boolean
def isTopLevelClass(symbol: Symbol): Boolean
val key: scalap.Rule[S, S, Int, Nothing]
lazy val literal: EntryParser[Any]
def memo[In <: Memoisable, Out, A, X](key: AnyRef)(toRule: ⇒ (In) ⇒ Result[Out, A, X]): scalap.Rule[In, Out, A, X]

Definition Classes
MemoisableRules
val methodSymbol: scalap.Rule[S, S, MethodSymbol, String] with Name
val name: scalap.Rule[S, S, String, String] with Name
lazy val nameRef: EntryParser[String]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def nil: scalap.Rule[S, S, Nil.type, Nothing]

Definition Classes
StateRules
val noSymbol: scalap.Rule[S, S, NoSymbol.type, Nothing]
def none: scalap.Rule[S, S, None.type, Nothing]

Definition Classes
StateRules
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val objectSymbol: scalap.Rule[S, S, ObjectSymbol, String] with Name
def oneOf[In, Out, A, X](rules: scalap.Rule[In, Out, A, X]*): scalap.Rule[In, Out, A, X]

Definition Classes
Rules
def parseEntry[A](parser: EntryParser[A])(index: Int): scalap.Rule[S, S, A, String]
def read[A](f: (S) ⇒ A): scalap.Rule[S, S, A, Nothing]

Definition Classes
StateRules
val ref: EntryParser[Int]
def refTo[A](rule: EntryParser[A]): EntryParser[A]
def repeatUntil[T, X](rule: Rule[(T) ⇒ T, X])(finished: (T) ⇒ Boolean)(initial: T): scalap.Rule[S, S, T, X]

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

Definition Classes
StateRules
implicit def rule[In, Out, A, X](f: (In) ⇒ Result[Out, A, X]): scalap.Rule[In, Out, A, X]

Definition Classes
Rules
def ruleWithName[In, Out, A, X](name: String, f: (In) ⇒ Result[Out, A, X]): scalap.Rule[In, Out, A, X] with Name

Definition Classes
MemoisableRules → Rules
implicit def seqRule[In, A, X](rule: scalap.Rule[In, In, A, X]): SeqRule[In, A, X]

Definition Classes
Rules
def set(s: ⇒ S): scalap.Rule[S, S, S, Nothing]

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

Definition Classes
Rules
def success[Out, A](out: Out, a: A): scalap.Rule[Any, Out, A, Nothing]

Definition Classes
Rules
def symHeader(key: Int): EntryParser[Any]
lazy val symbol: EntryParser[Symbol]
def symbolEntry(key: Int): scalap.Rule[S, S, SymbolInfo, String]
val symbolInfo: scalap.Rule[S, S, SymbolInfo, String]
lazy val symbolRef: EntryParser[Symbol]
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
val termName: scalap.Rule[S, S, String, String]
def toEntry[A](index: Int): scalap.Rule[S, S, Int, Nothing]
def toString(): String

Definition Classes
AnyRef → Any
lazy val topLevelClass: scalap.Rule[S, S, ClassSymbol, String]
lazy val topLevelObject: scalap.Rule[S, S, ObjectSymbol, String]
lazy val typeEntry: EntryParser[Type]
val typeIndex: scalap.Rule[ScalaSigAttributeParsers.S, ScalaSigAttributeParsers.S, Int, Nothing]
val typeLevel: scalap.Rule[ScalaSigAttributeParsers.S, ScalaSigAttributeParsers.S, Int, Nothing]
val typeName: scalap.Rule[S, S, String, String]
lazy val typeRef: EntryParser[Type]
val typeSymbol: scalap.Rule[S, S, TypeSymbol, String] with Name
def unit[A](a: ⇒ A): scalap.Rule[S, S, A, Nothing]

Definition Classes
StateRules
def update(f: (S) ⇒ S): scalap.Rule[S, S, S, Nothing]

Definition Classes
StateRules
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Doc: package scalasig

object ScalaSigEntryParsers extends RulesWithState with MemoisableRules

Type Members

class DefaultRule[In, Out, A, X] extends Rule[In, Out, A, X]

type EntryParser[A] = scalap.Rule[S, S, A, String]

trait FromRule[In] extends AnyRef

type Rule[+A, +X] = scalap.Rule[S, S, A, X]

type S = Entry

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val aliasSymbol: scalap.Rule[S, S, AliasSymbol, String] with Name

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

lazy val annotInfo: scalap.Rule[S, S, AnnotInfo, String]

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

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

final def asInstanceOf[T0]: T0

val attribTreeRef: EntryParser[Int]

lazy val attributeInfo: scalap.Rule[S, S, AttributeInfo, String]

implicit def byteCodeEntryParser[A](rule: ScalaSigAttributeParsers.Parser[A]): EntryParser[A]

lazy val children: scalap.Rule[S, S, Children, String]

val classSymRef: EntryParser[ClassSymbol]

val classSymbol: scalap.Rule[S, S, ClassSymbol, String] with Name

def clone(): AnyRef

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

lazy val constantRef: EntryParser[Any]

lazy val entry: EntryParser[Any]

implicit def entryType(code: Int): scalap.Rule[S, S, Int, Nothing]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

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

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

val extModClassRef: scalap.Rule[S, S, ExternalSymbol, String] with Name

val extRef: scalap.Rule[S, S, ExternalSymbol, String] with Name

val factory: RulesWithState

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

def finalize(): Unit

def from[In]: FromRule[In]

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

final def getClass(): Class[_]

def hashCode(): Int

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

val index: scalap.Rule[S, S, Int, Nothing]

final def isInstanceOf[T0]: Boolean

def isTopLevel(symbol: Symbol): Boolean

def isTopLevelClass(symbol: Symbol): Boolean

val key: scalap.Rule[S, S, Int, Nothing]

lazy val literal: EntryParser[Any]

def memo[In <: Memoisable, Out, A, X](key: AnyRef)(toRule: ⇒ (In) ⇒ Result[Out, A, X]): scalap.Rule[In, Out, A, X]

val methodSymbol: scalap.Rule[S, S, MethodSymbol, String] with Name

val name: scalap.Rule[S, S, String, String] with Name

lazy val nameRef: EntryParser[String]

final def ne(arg0: AnyRef): Boolean

def nil: scalap.Rule[S, S, Nil.type, Nothing]

val noSymbol: scalap.Rule[S, S, NoSymbol.type, Nothing]

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

final def notify(): Unit

final def notifyAll(): Unit

val objectSymbol: scalap.Rule[S, S, ObjectSymbol, String] with Name

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

def parseEntry[A](parser: EntryParser[A])(index: Int): scalap.Rule[S, S, A, String]

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

val ref: EntryParser[Int]

def refTo[A](rule: EntryParser[A]): EntryParser[A]

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

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

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

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

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

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

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

def symHeader(key: Int): EntryParser[Any]

lazy val symbol: EntryParser[Symbol]

def symbolEntry(key: Int): scalap.Rule[S, S, SymbolInfo, String]

val symbolInfo: scalap.Rule[S, S, SymbolInfo, String]

lazy val symbolRef: EntryParser[Symbol]

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