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-2011, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */
package dotty.tools.dotc
package util
import core.Names._
import core.Decorators._
/** Provides functions to encode and decode Scala symbolic names.
* Also provides some constants.
*/
object NameTransformer {
// XXX Short term: providing a way to alter these without having to recompile
// the compiler before recompiling the compiler.
val MODULE_SUFFIX_STRING = sys.props.getOrElse("SCALA_MODULE_SUFFIX_STRING", "$")
val NAME_JOIN_STRING = sys.props.getOrElse("SCALA_NAME_JOIN_STRING", "$")
val MODULE_INSTANCE_NAME = "MODULE$"
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) = code
val c = (code.charAt(1) - 'a') * 26 + code.charAt(2) - 'a'
code2op(c) = 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[N <: Name](name: N): N = {
var buf: StringBuilder = null
val len = name.length
var i = 0
while (i < len) {
val c = name(i)
if (c < nops && (op2code(c) ne null)) {
if (buf eq null) {
buf = new StringBuilder()
buf.append(name.slice(0, i))
}
buf.append(op2code(c))
/* Handle glyphs that are not valid Java/JVM identifiers */
}
else if (!Character.isJavaIdentifierPart(c)) {
if (buf eq null) {
buf = new StringBuilder()
buf.append(name.slice(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 if (name.isTermName) buf.toString.toTermName.asInstanceOf[N]
else buf.toString.toTypeName.asInstanceOf[N]
}
/** 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.substring(0, name0.length() - ("<init>").length()) + "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()
}
}
|
