1
// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
2

3
package cases
4

5
// This file contains definitions for interpreting the trie value of the case
6
// trie generated by "go run gen*.go". It is shared by both the generator
7
// program and the resultant package. Sharing is achieved by the generator
8
// copying gen_trieval.go to trieval.go and changing what's above this comment.
9

10
// info holds case information for a single rune. It is the value returned
11
// by a trie lookup. Most mapping information can be stored in a single 16-bit
12
// value. If not, for example when a rune is mapped to multiple runes, the value
13
// stores some basic case data and an index into an array with additional data.
14
//
15
// The per-rune values have the following format:
16
//
17
//	if (exception) {
18
//	  15..4  unsigned exception index
19
//	} else {
20
//	  15..8  XOR pattern or index to XOR pattern for case mapping
21
//	         Only 13..8 are used for XOR patterns.
22
//	      7  inverseFold (fold to upper, not to lower)
23
//	      6  index: interpret the XOR pattern as an index
24
//	         or isMid if case mode is cIgnorableUncased.
25
//	   5..4  CCC: zero (normal or break), above or other
26
//	}
27
//	   3  exception: interpret this value as an exception index
28
//	      (TODO: is this bit necessary? Probably implied from case mode.)
29
//	2..0  case mode
30
//
31
// For the non-exceptional cases, a rune must be either uncased, lowercase or
32
// uppercase. If the rune is cased, the XOR pattern maps either a lowercase
33
// rune to uppercase or an uppercase rune to lowercase (applied to the 10
34
// least-significant bits of the rune).
35
//
36
// See the definitions below for a more detailed description of the various
37
// bits.
38
type info uint16
39

40
const (
41
	casedMask      = 0x0003
42
	fullCasedMask  = 0x0007
43
	ignorableMask  = 0x0006
44
	ignorableValue = 0x0004
45

46
	inverseFoldBit = 1 << 7
47
	isMidBit       = 1 << 6
48

49
	exceptionBit     = 1 << 3
50
	exceptionShift   = 4
51
	numExceptionBits = 12
52

53
	xorIndexBit = 1 << 6
54
	xorShift    = 8
55

56
	// There is no mapping if all xor bits and the exception bit are zero.
57
	hasMappingMask = 0xff80 | exceptionBit
58
)
59

60
// The case mode bits encodes the case type of a rune. This includes uncased,
61
// title, upper and lower case and case ignorable. (For a definition of these
62
// terms see Chapter 3 of The Unicode Standard Core Specification.) In some rare
63
// cases, a rune can be both cased and case-ignorable. This is encoded by
64
// cIgnorableCased. A rune of this type is always lower case. Some runes are
65
// cased while not having a mapping.
66
//
67
// A common pattern for scripts in the Unicode standard is for upper and lower
68
// case runes to alternate for increasing rune values (e.g. the accented Latin
69
// ranges starting from U+0100 and U+1E00 among others and some Cyrillic
70
// characters). We use this property by defining a cXORCase mode, where the case
71
// mode (always upper or lower case) is derived from the rune value. As the XOR
72
// pattern for case mappings is often identical for successive runes, using
73
// cXORCase can result in large series of identical trie values. This, in turn,
74
// allows us to better compress the trie blocks.
75
const (
76
	cUncased          info = iota // 000
77
	cTitle                        // 001
78
	cLower                        // 010
79
	cUpper                        // 011
80
	cIgnorableUncased             // 100
81
	cIgnorableCased               // 101 // lower case if mappings exist
82
	cXORCase                      // 11x // case is cLower | ((rune&1) ^ x)
83

84
	maxCaseMode = cUpper
85
)
86

87
func (c info) isCased() bool {
88
	return c&casedMask != 0
89
}
90

91
func (c info) isCaseIgnorable() bool {
92
	return c&ignorableMask == ignorableValue
93
}
94

95
func (c info) isNotCasedAndNotCaseIgnorable() bool {
96
	return c&fullCasedMask == 0
97
}
98

99
func (c info) isCaseIgnorableAndNotCased() bool {
100
	return c&fullCasedMask == cIgnorableUncased
101
}
102

103
func (c info) isMid() bool {
104
	return c&(fullCasedMask|isMidBit) == isMidBit|cIgnorableUncased
105
}
106

107
// The case mapping implementation will need to know about various Canonical
108
// Combining Class (CCC) values. We encode two of these in the trie value:
109
// cccZero (0) and cccAbove (230). If the value is cccOther, it means that
110
// CCC(r) > 0, but not 230. A value of cccBreak means that CCC(r) == 0 and that
111
// the rune also has the break category Break (see below).
112
const (
113
	cccBreak info = iota << 4
114
	cccZero
115
	cccAbove
116
	cccOther
117

118
	cccMask = cccBreak | cccZero | cccAbove | cccOther
119
)
120

121
const (
122
	starter       = 0
123
	above         = 230
124
	iotaSubscript = 240
125
)
126

127
// The exceptions slice holds data that does not fit in a normal info entry.
128
// The entry is pointed to by the exception index in an entry. It has the
129
// following format:
130
//
131
// Header:
132
//
133
//	byte 0:
134
//	 7..6  unused
135
//	 5..4  CCC type (same bits as entry)
136
//	    3  unused
137
//	 2..0  length of fold
138
//
139
//	byte 1:
140
//	  7..6  unused
141
//	  5..3  length of 1st mapping of case type
142
//	  2..0  length of 2nd mapping of case type
143
//
144
//	  case     1st    2nd
145
//	  lower -> upper, title
146
//	  upper -> lower, title
147
//	  title -> lower, upper
148
//
149
// Lengths with the value 0x7 indicate no value and implies no change.
150
// A length of 0 indicates a mapping to zero-length string.
151
//
152
// Body bytes:
153
//
154
//	case folding bytes
155
//	lowercase mapping bytes
156
//	uppercase mapping bytes
157
//	titlecase mapping bytes
158
//	closure mapping bytes (for NFKC_Casefold). (TODO)
159
//
160
// Fallbacks:
161
//
162
//	missing fold  -> lower
163
//	missing title -> upper
164
//	all missing   -> original rune
165
//
166
// exceptions starts with a dummy byte to enforce that there is no zero index
167
// value.
168
const (
169
	lengthMask = 0x07
170
	lengthBits = 3
171
	noChange   = 0
172
)
173

174
// References to generated trie.
175

176
var trie = newCaseTrie(0)
177

178
var sparse = sparseBlocks{
179
	values:  sparseValues[:],
180
	offsets: sparseOffsets[:],
181
}
182

183
// Sparse block lookup code.
184

185
// valueRange is an entry in a sparse block.
186
type valueRange struct {
187
	value  uint16
188
	lo, hi byte
189
}
190

191
type sparseBlocks struct {
192
	values  []valueRange
193
	offsets []uint16
194
}
195

196
// lookup returns the value from values block n for byte b using binary search.
197
func (s *sparseBlocks) lookup(n uint32, b byte) uint16 {
198
	lo := s.offsets[n]
199
	hi := s.offsets[n+1]
200
	for lo < hi {
201
		m := lo + (hi-lo)/2
202
		r := s.values[m]
203
		if r.lo <= b && b <= r.hi {
204
			return r.value
205
		}
206
		if b < r.lo {
207
			hi = m
208
		} else {
209
			lo = m + 1
210
		}
211
	}
212
	return 0
213
}
214

215
// lastRuneForTesting is the last rune used for testing. Everything after this
216
// is boring.
217
const lastRuneForTesting = rune(0x1FFFF)
218

219