scala.tools.scalap.scalax.rules.scalasig.ScalaSigEntryParsers

Ordering

Alphabetic
By inheritance

Inherited

Hide All
Show all

ScalaSigEntryParsers
MemoisableRules
RulesWithState
StateRules
Rules
AnyRef
Any

Visibility

Public
All

Type Members

class DefaultRule [In, Out, A, X] extends Rule[In, Out, A, X]
type EntryParser [A] = Rule[S, S, A, String]
type Rule [+A, +X] = Rule[S, S, A, X]

Definition Classes
StateRules
type S = Entry

Definition Classes
ScalaSigEntryParsers → StateRules

Value Members

def != (arg0: AnyRef): Boolean

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

Attributes
final
Definition Classes
Any
def ## (): Int

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

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

Attributes
final
Definition Classes
Any
val aliasSymbol : 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 : Rule[S, S, AnnotInfo, String]
def anyOf [A, X] (rules: Seq[Rule[A, X]]): 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]): Rule[S, S, A, X]

Definition Classes
StateRules
def asInstanceOf [T0] : T0

Attributes
final
Definition Classes
Any
val attribTreeRef : EntryParser[Int]
lazy val attributeInfo : Rule[S, S, AttributeInfo, String]
implicit def byteCodeEntryParser [A] (rule: Parser[A]): EntryParser[A]

Attributes
implicit
lazy val children : Rule[S, S, Children, String]
val classSymRef : EntryParser[ClassSymbol]
val classSymbol : Rule[S, S, ClassSymbol, String] with Name
def clone (): AnyRef

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws()
def cond (f: (S) ⇒ Boolean): 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): Rule[S, S, Int, Nothing]

Attributes
implicit
def eq (arg0: AnyRef): Boolean

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

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

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

Definition Classes
Rules
def expect [In, Out, A, Any] (rule: 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 : Rule[S, S, ExternalSymbol, String] with Name
val extRef : Rule[S, S, ExternalSymbol, String] with Name
val factory : RulesWithState

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

Definition Classes
Rules
def finalize (): Unit

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws()
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] }

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

Definition Classes
StateRules
def getClass (): java.lang.Class[_]

Attributes
final
Definition Classes
AnyRef → Any
def hashCode (): Int

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

Attributes
implicit
Definition Classes
Rules
val index : Rule[S, S, Int, Nothing]
def isInstanceOf [T0] : Boolean

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

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

Attributes
final
Definition Classes
AnyRef
def nil : Rule[S, S, scala.collection.immutable.Nil.type, Nothing]

Definition Classes
StateRules
val noSymbol : Rule[S, S, scala.tools.scalap.scalax.rules.scalasig.NoSymbol.type, Nothing]

************************************************* Symbol table attribute format: Symtab = nentries_Nat {Entry} Entry = 1 TERMNAME len_Nat NameInfo | 2 TYPENAME len_Nat NameInfo | 3 NONEsym len_Nat | 4 TYPEsym len_Nat SymbolInfo | 5 ALIASsym len_Nat SymbolInfo | 6 CLASSsym len_Nat SymbolInfo [thistype_Ref] | 7 MODULEsym len_Nat SymbolInfo | 8 VALsym len_Nat [defaultGetter_Ref /* no longer needed*/ SymbolInfo [alias_Ref] | 9 EXTref len_Nat name_Ref [owner_Ref] | 10 EXTMODCLASSref len_Nat name_Ref [owner_Ref] | 11 NOtpe len_Nat | 12 NOPREFIXtpe len_Nat | 13 THIStpe len_Nat sym_Ref | 14 SINGLEtpe len_Nat type_Ref sym_Ref | 15 CONSTANTtpe len_Nat constant_Ref | 16 TYPEREFtpe len_Nat type_Ref sym_Ref {targ_Ref} | 17 TYPEBOUNDStpe len_Nat tpe_Ref tpe_Ref | 18 REFINEDtpe len_Nat classsym_Ref {tpe_Ref} | 19 CLASSINFOtpe len_Nat classsym_Ref {tpe_Ref} | 20 METHODtpe len_Nat tpe_Ref {sym_Ref} | 21 POLYTtpe len_Nat tpe_Ref {sym_Ref} | 22 IMPLICITMETHODtpe len_Nat tpe_Ref {sym_Ref} /* no longer needed */ * | 52 SUPERtpe len_Nat tpe_Ref tpe_Ref | 24 LITERALunit len_Nat | 25 LITERALboolean len_Nat value_Long | 26 LITERALbyte len_Nat value_Long | 27 LITERALshort len_Nat value_Long | 28 LITERALchar len_Nat value_Long | 29 LITERALint len_Nat value_Long | 30 LITERALlong len_Nat value_Long | 31 LITERALfloat len_Nat value_Long | 32 LITERALdouble len_Nat value_Long | 33 LITERALstring len_Nat name_Ref | 34 LITERALnull len_Nat | 35 LITERALclass len_Nat tpe_Ref | 36 LITERALenum len_Nat sym_Ref | 40 SYMANNOT len_Nat sym_Ref AnnotInfoBody | 41 CHILDREN len_Nat sym_Ref {sym_Ref} | 42 ANNOTATEDtpe len_Nat [sym_Ref /* no longer needed */ tpe_Ref {annotinfo_Ref} | 43 ANNOTINFO len_Nat AnnotInfoBody | 44 ANNOTARGARRAY len_Nat {constAnnotArg_Ref} | 47 DEBRUIJNINDEXtpe len_Nat level_Nat index_Nat | 48 EXISTENTIALtpe len_Nat type_Ref {symbol_Ref}
def none : Rule[S, S, None.type, Nothing]

Definition Classes
StateRules
def notify (): Unit

Attributes
final
Definition Classes
AnyRef
def notifyAll (): Unit

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

Definition Classes
Rules
def parseEntry [A] (parser: EntryParser[A])(index: Int): Rule[S, S, A, String]
def read [A] (f: (S) ⇒ A): 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): 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]): Rule[In, Out, A, X]

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

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

Attributes
implicit
Definition Classes
Rules
def set (s: ⇒ S): 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): Rule[Any, Out, A, Nothing]

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

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

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

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

Definition Classes
StateRules
def wait (): Unit

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

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

Attributes
final
Definition Classes
AnyRef
Annotations
@throws()

ScalaSigEntryParsers

object ScalaSigEntryParsers extends RulesWithState with MemoisableRules

Type Members

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

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

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

type S = Entry

Value Members

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

val aliasSymbol : 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 : Rule[S, S, AnnotInfo, String]

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

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

def asInstanceOf [T0] : T0

val attribTreeRef : EntryParser[Int]

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

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

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

val classSymRef : EntryParser[ClassSymbol]

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

def clone (): AnyRef

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

lazy val constantRef : EntryParser[Any]

lazy val entry : EntryParser[Any]

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

def eq (arg0: AnyRef): Boolean

def equals (arg0: Any): Boolean

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

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

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

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

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

val factory : RulesWithState

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

def finalize (): Unit

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 : Rule[S, S, S, Nothing]

def getClass (): java.lang.Class[_]

def hashCode (): Int

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

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

def isInstanceOf [T0] : Boolean

def isTopLevel (symbol: Symbol): Boolean

def isTopLevelClass (symbol: Symbol): Boolean

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

lazy val literal : Rule[Entry, Entry, Any, String]

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

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

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

lazy val nameRef : EntryParser[String]

def ne (arg0: AnyRef): Boolean

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

val noSymbol : Rule[S, S, scala.tools.scalap.scalax.rules.scalasig.NoSymbol.type, Nothing]

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

def notify (): Unit

def notifyAll (): Unit

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

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

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

def read [A] (f: (S) ⇒ A): 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): Rule[S, S, T, X]

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

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

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

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

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

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

def symHeader (key: Int): Rule[S, S, Any, String]

lazy val symbol : EntryParser[Symbol]

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

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

lazy val symbolRef : EntryParser[Symbol]

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