1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
|
package scala.tools.scalap
package scalax
package rules
package scalasig
import ScalaSigEntryParsers._
trait Symbol extends Flags {
def name : String
def parent : Option[Symbol]
def children : Seq[Symbol]
def path : String = parent.map(_.path + ".").getOrElse("") + name
}
case object NoSymbol extends Symbol {
def name = "<no symbol>"
def parent = None
def hasFlag(flag : Long) = false
def children = Nil
}
abstract class ScalaSigSymbol extends Symbol {
def applyRule[A](rule : EntryParser[A]) : A = expect(rule)(entry)
def applyScalaSigRule[A](rule : ScalaSigParsers.Parser[A]) = ScalaSigParsers.expect(rule)(entry.scalaSig)
def entry : ScalaSig#Entry
def index = entry.index
lazy val children : Seq[Symbol] = applyScalaSigRule(ScalaSigParsers.symbols) filter (_.parent == Some(this))
lazy val attributes : Seq[AttributeInfo] = applyScalaSigRule(ScalaSigParsers.attributes) filter (_.symbol == this)
}
case class ExternalSymbol(name : String, parent : Option[Symbol], entry : ScalaSig#Entry) extends ScalaSigSymbol {
override def toString = path
def hasFlag(flag : Long) = false
}
case class SymbolInfo(name : String, owner : Symbol, flags : Int, privateWithin : Option[AnyRef], info : Int, entry : ScalaSig#Entry) {
def symbolString(any : AnyRef) = any match {
case sym : SymbolInfoSymbol => sym.index.toString
case other => other.toString
}
override def toString = name + ", owner=" + symbolString(owner) + ", flags=" + flags.toHexString + ", info=" + info + (privateWithin match {
case Some(any) => ", privateWithin=" + symbolString(any)
case None => " "
})
}
abstract class SymbolInfoSymbol extends ScalaSigSymbol {
def symbolInfo : SymbolInfo
def entry = symbolInfo.entry
def name = symbolInfo.name
def parent = Some(symbolInfo.owner)
def hasFlag(flag : Long) = (symbolInfo.flags & flag) != 0L
lazy val infoType = applyRule(parseEntry(typeEntry)(symbolInfo.info))
}
case class TypeSymbol(symbolInfo : SymbolInfo) extends SymbolInfoSymbol{
override def path = name
}
case class AliasSymbol(symbolInfo : SymbolInfo) extends SymbolInfoSymbol{
override def path = name
}
case class ClassSymbol(symbolInfo : SymbolInfo, thisTypeRef : Option[Int]) extends SymbolInfoSymbol {
lazy val selfType = thisTypeRef.map{(x: Int) => applyRule(parseEntry(typeEntry)(x))}
}
case class ObjectSymbol(symbolInfo : SymbolInfo) extends SymbolInfoSymbol
case class MethodSymbol(symbolInfo : SymbolInfo, aliasRef : Option[Int]) extends SymbolInfoSymbol
|
