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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
|
/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2003-2013, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */
package scala
package reflect
/** Provides functions to encode and decode Scala symbolic names.
* Also provides some constants.
*/
object NameTransformer {
// TODO: reduce duplication with and in StdNames
// I made these constants because we cannot change them without bumping our major version anyway.
final val NAME_JOIN_STRING = "$"
final val MODULE_SUFFIX_STRING = "$"
final val MODULE_INSTANCE_NAME = "MODULE$"
final val LOCAL_SUFFIX_STRING = " "
final val LAZY_LOCAL_SUFFIX_STRING = "$lzy"
final val MODULE_VAR_SUFFIX_STRING = "$module"
final val SETTER_SUFFIX_STRING = "_$eq"
final val TRAIT_SETTER_SEPARATOR_STRING = "$_setter_$"
private val nops = 128
private val ncodes = 26 * 26
private class OpCodes(val op: Char, val code: String, val next: OpCodes)
private val op2code = new Array[String](nops)
private val code2op = new Array[OpCodes](ncodes)
private def enterOp(op: Char, code: String) = {
op2code(op.toInt) = code
val c = (code.charAt(1) - 'a') * 26 + code.charAt(2) - 'a'
code2op(c.toInt) = new OpCodes(op, code, code2op(c))
}
/* Note: decoding assumes opcodes are only ever lowercase. */
enterOp('~', "$tilde")
enterOp('=', "$eq")
enterOp('<', "$less")
enterOp('>', "$greater")
enterOp('!', "$bang")
enterOp('#', "$hash")
enterOp('%', "$percent")
enterOp('^', "$up")
enterOp('&', "$amp")
enterOp('|', "$bar")
enterOp('*', "$times")
enterOp('/', "$div")
enterOp('+', "$plus")
enterOp('-', "$minus")
enterOp(':', "$colon")
enterOp('\\', "$bslash")
enterOp('?', "$qmark")
enterOp('@', "$at")
/** Replace operator symbols by corresponding `\$opname`.
*
* @param name the string to encode
* @return the string with all recognized opchars replaced with their encoding
*/
def encode(name: String): String = {
var buf: StringBuilder = null
val len = name.length()
var i = 0
while (i < len) {
val c = name charAt i
if (c < nops && (op2code(c.toInt) ne null)) {
if (buf eq null) {
buf = new StringBuilder()
buf.append(name.substring(0, i))
}
buf.append(op2code(c.toInt))
/* Handle glyphs that are not valid Java/JVM identifiers */
}
else if (!Character.isJavaIdentifierPart(c)) {
if (buf eq null) {
buf = new StringBuilder()
buf.append(name.substring(0, i))
}
buf.append("$u%04X".format(c.toInt))
}
else if (buf ne null) {
buf.append(c)
}
i += 1
}
if (buf eq null) name else buf.toString()
}
/** Replace `\$opname` by corresponding operator symbol.
*
* @param name0 the string to decode
* @return the string with all recognized operator symbol encodings replaced with their name
*/
def decode(name0: String): String = {
//System.out.println("decode: " + name);//DEBUG
val name = if (name0.endsWith("<init>")) name0.stripSuffix("<init>") + "this"
else name0
var buf: StringBuilder = null
val len = name.length()
var i = 0
while (i < len) {
var ops: OpCodes = null
var unicode = false
val c = name charAt i
if (c == '$' && i + 2 < len) {
val ch1 = name.charAt(i+1)
if ('a' <= ch1 && ch1 <= 'z') {
val ch2 = name.charAt(i+2)
if ('a' <= ch2 && ch2 <= 'z') {
ops = code2op((ch1 - 'a') * 26 + ch2 - 'a')
while ((ops ne null) && !name.startsWith(ops.code, i)) ops = ops.next
if (ops ne null) {
if (buf eq null) {
buf = new StringBuilder()
buf.append(name.substring(0, i))
}
buf.append(ops.op)
i += ops.code.length()
}
/* Handle the decoding of Unicode glyphs that are
* not valid Java/JVM identifiers */
} else if ((len - i) >= 6 && // Check that there are enough characters left
ch1 == 'u' &&
((Character.isDigit(ch2)) ||
('A' <= ch2 && ch2 <= 'F'))) {
/* Skip past "$u", next four should be hexadecimal */
val hex = name.substring(i+2, i+6)
try {
val str = Integer.parseInt(hex, 16).toChar
if (buf eq null) {
buf = new StringBuilder()
buf.append(name.substring(0, i))
}
buf.append(str)
/* 2 for "$u", 4 for hexadecimal number */
i += 6
unicode = true
} catch {
case _:NumberFormatException =>
/* `hex` did not decode to a hexadecimal number, so
* do nothing. */
}
}
}
}
/* If we didn't see an opcode or encoded Unicode glyph, and the
buffer is non-empty, write the current character and advance
one */
if ((ops eq null) && !unicode) {
if (buf ne null)
buf.append(c)
i += 1
}
}
//System.out.println("= " + (if (buf == null) name else buf.toString()));//DEBUG
if (buf eq null) name else buf.toString()
}
}
|
