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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
/* __ *\
** ________ ___ / / ___ __ ____ Scala.js IR **
** / __/ __// _ | / / / _ | __ / // __/ (c) 2014, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ |/_// /_\ \ http://scala-js.org/ **
** /____/\___/_/ |_/____/_/ | |__/ /____/ **
** |/____/ **
\* */
package scala.scalajs.ir
object Definitions {
val ObjectClass = "O"
val ClassClass = "jl_Class"
val StringClass = "T"
val PrimitiveClasses = Set("V", "Z", "C", "B", "S", "I", "J", "F", "D")
def isPrimitiveClass(encodedName: String): Boolean =
PrimitiveClasses.contains(encodedName)
val BoxedUnitClass = "sr_BoxedUnit"
val BoxedBooleanClass = "jl_Boolean"
val BoxedCharacterClass = "jl_Character"
val BoxedByteClass = "jl_Byte"
val BoxedShortClass = "jl_Short"
val BoxedIntegerClass = "jl_Integer"
val BoxedLongClass = "jl_Long"
val BoxedFloatClass = "jl_Float"
val BoxedDoubleClass = "jl_Double"
val CharSequenceClass = "jl_CharSequence"
val SerializableClass = "Ljava_io_Serializable"
val ComparableClass = "jl_Comparable"
val NumberClass = "jl_Number"
val HijackedBoxedClasses = Set(
BoxedUnitClass, BoxedBooleanClass, BoxedByteClass, BoxedShortClass,
BoxedIntegerClass, BoxedLongClass, BoxedFloatClass, BoxedDoubleClass)
val HijackedClasses =
HijackedBoxedClasses + StringClass
val AncestorsOfStringClass = Set(
CharSequenceClass, ComparableClass, SerializableClass)
val AncestorsOfHijackedNumberClasses = Set(
NumberClass, ComparableClass, SerializableClass)
val AncestorsOfBoxedBooleanClass = Set(
ComparableClass, SerializableClass)
val AncestorsOfHijackedClasses =
AncestorsOfStringClass ++ AncestorsOfHijackedNumberClasses ++
AncestorsOfBoxedBooleanClass
val RuntimeNullClass = "sr_Null$"
val RuntimeNothingClass = "sr_Nothing$"
val ThrowableClass = "jl_Throwable"
/** Encodes a class name. */
def encodeClassName(fullName: String): String = {
val base = fullName.replace("_", "$und").replace(".", "_")
val encoded = compressedClasses.getOrElse(base, {
compressedPrefixes collectFirst {
case (prefix, compressed) if base.startsWith(prefix) =>
compressed + base.substring(prefix.length)
} getOrElse {
"L"+base
}
})
if (Trees.isKeyword(encoded) || encoded.charAt(0).isDigit ||
encoded.charAt(0) == '$') {
"$" + encoded
} else encoded
}
// !!! Duplicate logic: this code must be in sync with runtime.StackTrace
/** Decodes a class name encoded with [[encodeClassName]]. */
def decodeClassName(encodedName: String): String = {
val encoded =
if (encodedName.charAt(0) == '$') encodedName.substring(1)
else encodedName
val base = decompressedClasses.getOrElse(encoded, {
decompressedPrefixes collectFirst {
case (prefix, decompressed) if encoded.startsWith(prefix) =>
decompressed + encoded.substring(prefix.length)
} getOrElse {
assert(!encoded.isEmpty && encoded.charAt(0) == 'L',
s"Cannot decode invalid encoded name '$encodedName'")
encoded.substring(1)
}
})
base.replace("_", ".").replace("$und", "_")
}
private val compressedClasses: Map[String, String] = Map(
"java_lang_Object" -> "O",
"java_lang_String" -> "T",
"scala_Unit" -> "V",
"scala_Boolean" -> "Z",
"scala_Char" -> "C",
"scala_Byte" -> "B",
"scala_Short" -> "S",
"scala_Int" -> "I",
"scala_Long" -> "J",
"scala_Float" -> "F",
"scala_Double" -> "D"
) ++ (
for (index <- 2 to 22)
yield s"scala_Tuple$index" -> ("T"+index)
) ++ (
for (index <- 0 to 22)
yield s"scala_Function$index" -> ("F"+index)
)
private val decompressedClasses: Map[String, String] =
compressedClasses map { case (a, b) => (b, a) }
private val compressedPrefixes = Seq(
"scala_scalajs_runtime_" -> "sjsr_",
"scala_scalajs_" -> "sjs_",
"scala_collection_immutable_" -> "sci_",
"scala_collection_mutable_" -> "scm_",
"scala_collection_generic_" -> "scg_",
"scala_collection_" -> "sc_",
"scala_runtime_" -> "sr_",
"scala_" -> "s_",
"java_lang_" -> "jl_",
"java_util_" -> "ju_"
)
private val decompressedPrefixes: Seq[(String, String)] =
compressedPrefixes map { case (a, b) => (b, a) }
/* Common predicates on encoded names */
def isConstructorName(name: String): Boolean =
name.startsWith("init___")
def isReflProxyName(name: String): Boolean =
name.endsWith("__") && !isConstructorName(name)
}
|
