scala.tools.scalap.scalax.rules.scalasig.ClassFileParser

Ordering

Alphabetic
By inheritance

Inherited

Hide All
Show all

ClassFileParser
ByteCodeReader
RulesWithState
StateRules
Rules
AnyRef
Any

Visibility

Public
All

Type Members

case class Annotation (typeIndex: Int, elementValuePairs: Seq[AnnotationElement]) extends ElementValue with Product with Serializable
case class AnnotationElement (elementNameIndex: Int, elementValue: ElementValue) extends Product with Serializable
case class ArrayValue (values: Seq[ElementValue]) extends ElementValue with Product with Serializable
case class ClassInfoIndex (index: Int) extends ElementValue with Product with Serializable
case class ConstValueIndex (index: Int) extends ElementValue with Product with Serializable
class DefaultRule [In, Out, A, X] extends Rule[In, Out, A, X]
class ElementValue extends AnyRef

Attributes
abstract
case class EnumConstValue (typeNameIndex: Int, constNameIndex: Int) extends ElementValue with Product with Serializable
type Parser [A] = Rule[S, S, A, String]

Definition Classes
ByteCodeReader
type Rule [+A, +X] = Rule[S, S, A, X]

Definition Classes
StateRules
type S = ByteCode

Definition Classes
ByteCodeReader → 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
def add1 [T] (f: (T) ⇒ (ConstantPool) ⇒ Any)(raw: T)(pool: ConstantPool): ConstantPool
def add2 [T] (f: (T) ⇒ (ConstantPool) ⇒ Any)(raw: T)(pool: ConstantPool): ConstantPool
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
val annotation : Parser[Annotation]
val annotations : Rule[S, S, Seq[Annotation], 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 attribute : Rule[S, S, Attribute, Nothing]
val attributes : Rule[S, S, Seq[Attribute], Nothing]
val byte : Rule[S, S, Byte, Nothing]

Definition Classes
ByteCodeReader
def bytes (n: Int): Rule[S, S, ByteCode, Nothing]

Definition Classes
ByteCodeReader
val classFile : Rule[S, S, ClassFile, String]
val classRef : Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]
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
val constantPool : Rule[S, S, ConstantPool, Nothing]
val constantPoolEntry : Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]
val doubleConstant : Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]
def element_value : Parser[ElementValue]
val element_value_pair : Rule[S, S, AnnotationElement, String]
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 factory : RulesWithState

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

Definition Classes
Rules
val field : Rule[S, S, Field, Nothing]
val fieldRef : Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]
val fields : Rule[S, S, Seq[Field], Nothing]
def finalize (): Unit

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws()
val floatConstant : Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]
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
val header : Rule[S, S, ClassFileHeader, String]
implicit def inRule [In, Out, A, X] (rule: Rule[In, Out, A, X]): InRule[In, Out, A, X]

Attributes
implicit
Definition Classes
Rules
val intConstant : Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]
val interfaceMethodRef : Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]
val interfaces : Rule[S, S, Seq[Int], Nothing]
def isInstanceOf [T0] : Boolean

Attributes
final
Definition Classes
Any
val longConstant : Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]
val magicNumber : Rule[S, S, Int, String]
def memberRef (description: String): Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]
val method : Rule[S, S, Method, Nothing]
val methodRef : Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]
val methods : Rule[S, S, Seq[Method], Nothing]
val nameAndType : Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]
def ne (arg0: AnyRef): Boolean

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

Definition Classes
StateRules
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
def oneOf [In, Out, A, X] (rules: Rule[In, Out, A, X]*): Rule[In, Out, A, X]

Definition Classes
Rules
def parse (byteCode: ByteCode): ClassFile
def parseAnnotations (byteCode: ByteCode): Seq[Annotation]
def read [A] (f: (S) ⇒ A): Rule[S, S, A, Nothing]

Definition Classes
StateRules
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
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
val stringRef : Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]
def success [Out, A] (out: Out, a: A): Rule[Any, Out, A, Nothing]

Definition Classes
Rules
def synchronized [T0] (arg0: ⇒ T0): T0

Attributes
final
Definition Classes
AnyRef
def toString (): String

Definition Classes
AnyRef → Any
val u1 : Rule[S, S, Int, Nothing]

Definition Classes
ByteCodeReader
val u2 : Rule[S, S, Int, Nothing]

Definition Classes
ByteCodeReader
val u4 : Rule[S, S, Int, Nothing]

Definition Classes
ByteCodeReader
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
val utf8String : Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]
val version : Rule[S, S, (Int, Int), Nothing]
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()

ClassFileParser

object ClassFileParser extends ByteCodeReader

Type Members

case class Annotation (typeIndex: Int, elementValuePairs: Seq[AnnotationElement]) extends ElementValue with Product with Serializable

case class AnnotationElement (elementNameIndex: Int, elementValue: ElementValue) extends Product with Serializable

case class ArrayValue (values: Seq[ElementValue]) extends ElementValue with Product with Serializable

case class ClassInfoIndex (index: Int) extends ElementValue with Product with Serializable

case class ConstValueIndex (index: Int) extends ElementValue with Product with Serializable

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

class ElementValue extends AnyRef

case class EnumConstValue (typeNameIndex: Int, constNameIndex: Int) extends ElementValue with Product with Serializable

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

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

type S = ByteCode

Value Members

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

def add1 [T] (f: (T) ⇒ (ConstantPool) ⇒ Any)(raw: T)(pool: ConstantPool): ConstantPool

def add2 [T] (f: (T) ⇒ (ConstantPool) ⇒ Any)(raw: T)(pool: ConstantPool): ConstantPool

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

val annotation : Parser[Annotation]

val annotations : Rule[S, S, Seq[Annotation], 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 attribute : Rule[S, S, Attribute, Nothing]

val attributes : Rule[S, S, Seq[Attribute], Nothing]

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

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

val classFile : Rule[S, S, ClassFile, String]

val classRef : Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]

def clone (): AnyRef

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

val constantPool : Rule[S, S, ConstantPool, Nothing]

val constantPoolEntry : Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]

val doubleConstant : Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]

def element_value : Parser[ElementValue]

val element_value_pair : Rule[S, S, AnnotationElement, String]

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 factory : RulesWithState

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

val field : Rule[S, S, Field, Nothing]

val fieldRef : Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]

val fields : Rule[S, S, Seq[Field], Nothing]

def finalize (): Unit

val floatConstant : Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]

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

val header : Rule[S, S, ClassFileHeader, String]

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

val intConstant : Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]

val interfaceMethodRef : Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]

val interfaces : Rule[S, S, Seq[Int], Nothing]

def isInstanceOf [T0] : Boolean

val longConstant : Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]

val magicNumber : Rule[S, S, Int, String]

def memberRef (description: String): Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]

val method : Rule[S, S, Method, Nothing]

val methodRef : Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]

val methods : Rule[S, S, Seq[Method], Nothing]

val nameAndType : Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]

def ne (arg0: AnyRef): Boolean

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

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

def notify (): Unit

def notifyAll (): Unit

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

def parse (byteCode: ByteCode): ClassFile

def parseAnnotations (byteCode: ByteCode): Seq[Annotation]

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

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