1 // Copyright 2014 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
4 5 package cases
6 7 import "golang.org/x/text/transform"
8 9 // A context is used for iterating over source bytes, fetching case info and
10 // writing to a destination buffer.
11 //
12 // Casing operations may need more than one rune of context to decide how a rune
13 // should be cased. Casing implementations should call checkpoint on context
14 // whenever it is known to be safe to return the runes processed so far.
15 //
16 // It is recommended for implementations to not allow for more than 30 case
17 // ignorables as lookahead (analogous to the limit in norm) and to use state if
18 // unbounded lookahead is needed for cased runes.
19 type context struct {
20 dst, src []byte
21 atEOF bool
22 23 pDst int // pDst points past the last written rune in dst.
24 pSrc int // pSrc points to the start of the currently scanned rune.
25 26 // checkpoints safe to return in Transform, where nDst <= pDst and nSrc <= pSrc.
27 nDst, nSrc int
28 err error
29 30 sz int // size of current rune
31 info info // case information of currently scanned rune
32 33 // State preserved across calls to Transform.
34 isMidWord bool // false if next cased letter needs to be title-cased.
35 }
36 37 func (c *context) Reset() {
38 c.isMidWord = false
39 }
40 41 // ret returns the return values for the Transform method. It checks whether
42 // there were insufficient bytes in src to complete and introduces an error
43 // accordingly, if necessary.
44 func (c *context) ret() (nDst, nSrc int, err error) {
45 if c.err != nil || c.nSrc == len(c.src) {
46 return c.nDst, c.nSrc, c.err
47 }
48 // This point is only reached by mappers if there was no short destination
49 // buffer. This means that the source buffer was exhausted and that c.sz was
50 // set to 0 by next.
51 if c.atEOF && c.pSrc == len(c.src) {
52 return c.pDst, c.pSrc, nil
53 }
54 return c.nDst, c.nSrc, transform.ErrShortSrc
55 }
56 57 // retSpan returns the return values for the Span method. It checks whether
58 // there were insufficient bytes in src to complete and introduces an error
59 // accordingly, if necessary.
60 func (c *context) retSpan() (n int, err error) {
61 _, nSrc, err := c.ret()
62 return nSrc, err
63 }
64 65 // checkpoint sets the return value buffer points for Transform to the current
66 // positions.
67 func (c *context) checkpoint() {
68 if c.err == nil {
69 c.nDst, c.nSrc = c.pDst, c.pSrc+c.sz
70 }
71 }
72 73 // unreadRune causes the last rune read by next to be reread on the next
74 // invocation of next. Only one unreadRune may be called after a call to next.
75 func (c *context) unreadRune() {
76 c.sz = 0
77 }
78 79 func (c *context) next() bool {
80 c.pSrc += c.sz
81 if c.pSrc == len(c.src) || c.err != nil {
82 c.info, c.sz = 0, 0
83 return false
84 }
85 v, sz := trie.lookup(c.src[c.pSrc:])
86 c.info, c.sz = info(v), sz
87 if c.sz == 0 {
88 if c.atEOF {
89 // A zero size means we have an incomplete rune. If we are atEOF,
90 // this means it is an illegal rune, which we will consume one
91 // byte at a time.
92 c.sz = 1
93 } else {
94 c.err = transform.ErrShortSrc
95 return false
96 }
97 }
98 return true
99 }
100 101 // writeBytes adds bytes to dst.
102 func (c *context) writeBytes(b []byte) bool {
103 if len(c.dst)-c.pDst < len(b) {
104 c.err = transform.ErrShortDst
105 return false
106 }
107 // This loop is faster than using copy.
108 for _, ch := range b {
109 c.dst[c.pDst] = ch
110 c.pDst++
111 }
112 return true
113 }
114 115 // writeString writes the given string to dst.
116 func (c *context) writeString(s string) bool {
117 if len(c.dst)-c.pDst < len(s) {
118 c.err = transform.ErrShortDst
119 return false
120 }
121 // This loop is faster than using copy.
122 for i := 0; i < len(s); i++ {
123 c.dst[c.pDst] = s[i]
124 c.pDst++
125 }
126 return true
127 }
128 129 // copy writes the current rune to dst.
130 func (c *context) copy() bool {
131 return c.writeBytes(c.src[c.pSrc : c.pSrc+c.sz])
132 }
133 134 // copyXOR copies the current rune to dst and modifies it by applying the XOR
135 // pattern of the case info. It is the responsibility of the caller to ensure
136 // that this is a rune with a XOR pattern defined.
137 func (c *context) copyXOR() bool {
138 if !c.copy() {
139 return false
140 }
141 if c.info&xorIndexBit == 0 {
142 // Fast path for 6-bit XOR pattern, which covers most cases.
143 c.dst[c.pDst-1] ^= byte(c.info >> xorShift)
144 } else {
145 // Interpret XOR bits as an index.
146 // TODO: test performance for unrolling this loop. Verify that we have
147 // at least two bytes and at most three.
148 idx := c.info >> xorShift
149 for p := c.pDst - 1; ; p-- {
150 c.dst[p] ^= xorData[idx]
151 idx--
152 if xorData[idx] == 0 {
153 break
154 }
155 }
156 }
157 return true
158 }
159 160 // hasPrefix returns true if src[pSrc:] starts with the given string.
161 func (c *context) hasPrefix(s string) bool {
162 b := c.src[c.pSrc:]
163 if len(b) < len(s) {
164 return false
165 }
166 for i, c := range b[:len(s)] {
167 if c != s[i] {
168 return false
169 }
170 }
171 return true
172 }
173 174 // caseType returns an info with only the case bits, normalized to either
175 // cLower, cUpper, cTitle or cUncased.
176 func (c *context) caseType() info {
177 cm := c.info & 0x7
178 if cm < 4 {
179 return cm
180 }
181 if cm >= cXORCase {
182 // xor the last bit of the rune with the case type bits.
183 b := c.src[c.pSrc+c.sz-1]
184 return info(b&1) ^ cm&0x3
185 }
186 if cm == cIgnorableCased {
187 return cLower
188 }
189 return cUncased
190 }
191 192 // lower writes the lowercase version of the current rune to dst.
193 func lower(c *context) bool {
194 ct := c.caseType()
195 if c.info&hasMappingMask == 0 || ct == cLower {
196 return c.copy()
197 }
198 if c.info&exceptionBit == 0 {
199 return c.copyXOR()
200 }
201 e := exceptions[c.info>>exceptionShift:]
202 offset := 2 + e[0]&lengthMask // size of header + fold string
203 if nLower := (e[1] >> lengthBits) & lengthMask; nLower != noChange {
204 return c.writeString(e[offset : offset+nLower])
205 }
206 return c.copy()
207 }
208 209 func isLower(c *context) bool {
210 ct := c.caseType()
211 if c.info&hasMappingMask == 0 || ct == cLower {
212 return true
213 }
214 if c.info&exceptionBit == 0 {
215 c.err = transform.ErrEndOfSpan
216 return false
217 }
218 e := exceptions[c.info>>exceptionShift:]
219 if nLower := (e[1] >> lengthBits) & lengthMask; nLower != noChange {
220 c.err = transform.ErrEndOfSpan
221 return false
222 }
223 return true
224 }
225 226 // upper writes the uppercase version of the current rune to dst.
227 func upper(c *context) bool {
228 ct := c.caseType()
229 if c.info&hasMappingMask == 0 || ct == cUpper {
230 return c.copy()
231 }
232 if c.info&exceptionBit == 0 {
233 return c.copyXOR()
234 }
235 e := exceptions[c.info>>exceptionShift:]
236 offset := 2 + e[0]&lengthMask // size of header + fold string
237 // Get length of first special case mapping.
238 n := (e[1] >> lengthBits) & lengthMask
239 if ct == cTitle {
240 // The first special case mapping is for lower. Set n to the second.
241 if n == noChange {
242 n = 0
243 }
244 n, e = e[1]&lengthMask, e[n:]
245 }
246 if n != noChange {
247 return c.writeString(e[offset : offset+n])
248 }
249 return c.copy()
250 }
251 252 // isUpper writes the isUppercase version of the current rune to dst.
253 func isUpper(c *context) bool {
254 ct := c.caseType()
255 if c.info&hasMappingMask == 0 || ct == cUpper {
256 return true
257 }
258 if c.info&exceptionBit == 0 {
259 c.err = transform.ErrEndOfSpan
260 return false
261 }
262 e := exceptions[c.info>>exceptionShift:]
263 // Get length of first special case mapping.
264 n := (e[1] >> lengthBits) & lengthMask
265 if ct == cTitle {
266 n = e[1] & lengthMask
267 }
268 if n != noChange {
269 c.err = transform.ErrEndOfSpan
270 return false
271 }
272 return true
273 }
274 275 // title writes the title case version of the current rune to dst.
276 func title(c *context) bool {
277 ct := c.caseType()
278 if c.info&hasMappingMask == 0 || ct == cTitle {
279 return c.copy()
280 }
281 if c.info&exceptionBit == 0 {
282 if ct == cLower {
283 return c.copyXOR()
284 }
285 return c.copy()
286 }
287 // Get the exception data.
288 e := exceptions[c.info>>exceptionShift:]
289 offset := 2 + e[0]&lengthMask // size of header + fold string
290 291 nFirst := (e[1] >> lengthBits) & lengthMask
292 if nTitle := e[1] & lengthMask; nTitle != noChange {
293 if nFirst != noChange {
294 e = e[nFirst:]
295 }
296 return c.writeString(e[offset : offset+nTitle])
297 }
298 if ct == cLower && nFirst != noChange {
299 // Use the uppercase version instead.
300 return c.writeString(e[offset : offset+nFirst])
301 }
302 // Already in correct case.
303 return c.copy()
304 }
305 306 // isTitle reports whether the current rune is in title case.
307 func isTitle(c *context) bool {
308 ct := c.caseType()
309 if c.info&hasMappingMask == 0 || ct == cTitle {
310 return true
311 }
312 if c.info&exceptionBit == 0 {
313 if ct == cLower {
314 c.err = transform.ErrEndOfSpan
315 return false
316 }
317 return true
318 }
319 // Get the exception data.
320 e := exceptions[c.info>>exceptionShift:]
321 if nTitle := e[1] & lengthMask; nTitle != noChange {
322 c.err = transform.ErrEndOfSpan
323 return false
324 }
325 nFirst := (e[1] >> lengthBits) & lengthMask
326 if ct == cLower && nFirst != noChange {
327 c.err = transform.ErrEndOfSpan
328 return false
329 }
330 return true
331 }
332 333 // foldFull writes the foldFull version of the current rune to dst.
334 func foldFull(c *context) bool {
335 if c.info&hasMappingMask == 0 {
336 return c.copy()
337 }
338 ct := c.caseType()
339 if c.info&exceptionBit == 0 {
340 if ct != cLower || c.info&inverseFoldBit != 0 {
341 return c.copyXOR()
342 }
343 return c.copy()
344 }
345 e := exceptions[c.info>>exceptionShift:]
346 n := e[0] & lengthMask
347 if n == 0 {
348 if ct == cLower {
349 return c.copy()
350 }
351 n = (e[1] >> lengthBits) & lengthMask
352 }
353 return c.writeString(e[2 : 2+n])
354 }
355 356 // isFoldFull reports whether the current run is mapped to foldFull
357 func isFoldFull(c *context) bool {
358 if c.info&hasMappingMask == 0 {
359 return true
360 }
361 ct := c.caseType()
362 if c.info&exceptionBit == 0 {
363 if ct != cLower || c.info&inverseFoldBit != 0 {
364 c.err = transform.ErrEndOfSpan
365 return false
366 }
367 return true
368 }
369 e := exceptions[c.info>>exceptionShift:]
370 n := e[0] & lengthMask
371 if n == 0 && ct == cLower {
372 return true
373 }
374 c.err = transform.ErrEndOfSpan
375 return false
376 }
377