blob: e6f95eb0d619684c5dd53e195a8f2eb8d04d622a (
plain) (
blame)
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
|
/* NSC -- new Scala compiler
* Copyright 2005-2013 LAMP/EPFL
* @author Martin Odersky
*/
package scala.tools.nsc
package util
import scala.reflect.internal.Chars._
trait CharArrayReaderData {
/** the last read character */
var ch: Char = _
/** The offset one past the last read character */
var charOffset: Int = 0
/** The start offset of the current line */
var lineStartOffset: Int = 0
/** The start offset of the line before the current one */
var lastLineStartOffset: Int = 0
protected var lastUnicodeOffset = -1
def copyFrom(cd: CharArrayReaderData): this.type = {
this.ch = cd.ch
this.charOffset = cd.charOffset
this.lineStartOffset = cd.lineStartOffset
this.lastLineStartOffset = cd.lastLineStartOffset
this.lastUnicodeOffset = cd.lastUnicodeOffset
this
}
}
abstract class CharArrayReader extends CharArrayReaderData { self =>
val buf: Array[Char]
def decodeUni: Boolean = true
/** An error routine to call on bad unicode escapes \\uxxxx. */
protected def error(offset: Int, msg: String): Unit
/** Is last character a unicode escape \\uxxxx? */
def isUnicodeEscape = charOffset == lastUnicodeOffset
/** Advance one character; reducing CR;LF pairs to just LF */
final def nextChar(): Unit = {
if (charOffset >= buf.length) {
ch = SU
} else {
val c = buf(charOffset)
ch = c
charOffset += 1
if (c == '\\') potentialUnicode()
if (ch < ' ') {
skipCR()
potentialLineEnd()
}
}
}
/** Advance one character, leaving CR;LF pairs intact.
* This is for use in multi-line strings, so there are no
* "potential line ends" here.
*/
final def nextRawChar() {
if (charOffset >= buf.length) {
ch = SU
} else {
val c = buf(charOffset)
ch = c
charOffset += 1
if (c == '\\') potentialUnicode()
}
}
/** Interpret \\uxxxx escapes */
private def potentialUnicode() = {
def evenSlashPrefix: Boolean = {
var p = charOffset - 2
while (p >= 0 && buf(p) == '\\') p -= 1
(charOffset - p) % 2 == 0
}
def udigit: Int = {
if (charOffset >= buf.length) {
// Since the positioning code is very insistent about throwing exceptions,
// we have to decrement the position so our error message can be seen, since
// we are one past EOF. This happens with e.g. val x = \ u 1 <EOF>
error(charOffset - 1, "incomplete unicode escape")
SU
}
else {
val d = digit2int(buf(charOffset), 16)
if (d >= 0) charOffset += 1
else error(charOffset, "error in unicode escape")
d
}
}
if (charOffset < buf.length && buf(charOffset) == 'u' && decodeUni && evenSlashPrefix) {
do charOffset += 1
while (charOffset < buf.length && buf(charOffset) == 'u')
val code = udigit << 12 | udigit << 8 | udigit << 4 | udigit
lastUnicodeOffset = charOffset
ch = code.toChar
}
}
/** replace CR;LF by LF */
private def skipCR() =
if (ch == CR && charOffset < buf.length)
buf(charOffset) match {
case LF =>
charOffset += 1
ch = LF
case '\\' =>
if (lookaheadReader.getu == LF)
potentialUnicode()
case _ =>
}
/** Handle line ends */
private def potentialLineEnd() {
if (ch == LF || ch == FF) {
lastLineStartOffset = lineStartOffset
lineStartOffset = charOffset
}
}
/** A new reader that takes off at the current character position */
def lookaheadReader = new CharArrayLookaheadReader
class CharArrayLookaheadReader extends CharArrayReader {
val buf = self.buf
charOffset = self.charOffset
ch = self.ch
override def decodeUni = self.decodeUni
def error(offset: Int, msg: String) = self.error(offset, msg)
/** A mystery why CharArrayReader.nextChar() returns Unit */
def getc() = { nextChar() ; ch }
def getu() = { require(buf(charOffset) == '\\') ; ch = '\\' ; charOffset += 1 ; potentialUnicode() ; ch }
}
}
|
