URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgo/] [go/] [unicode/] [letter.go] - Blame information for rev 747

Details | Compare with Previous | View Log


// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
 
// Package unicode provides data and functions to test some properties of
// Unicode code points.
package unicode
 
const (
        MaxRune         = '\U0010FFFF' // Maximum valid Unicode code point.
        ReplacementChar = '\uFFFD'     // Represents invalid code points.
        MaxASCII        = '\u007F'     // maximum ASCII value.
        MaxLatin1       = '\u00FF'     // maximum Latin-1 value.
)
 
// RangeTable defines a set of Unicode code points by listing the ranges of
// code points within the set. The ranges are listed in two slices
// to save space: a slice of 16-bit ranges and a slice of 32-bit ranges.
// The two slices must be in sorted order and non-overlapping.
// Also, R32 should contain only values >= 0x10000 (1<<16).
type RangeTable struct {
        R16 []Range16
        R32 []Range32
}
 
// Range16 represents of a range of 16-bit Unicode code points.  The range runs from Lo to Hi
// inclusive and has the specified stride.
type Range16 struct {
        Lo     uint16
        Hi     uint16
        Stride uint16
}
 
// Range32 represents of a range of Unicode code points and is used when one or
// more of the values will not fit in 16 bits.  The range runs from Lo to Hi
// inclusive and has the specified stride. Lo and Hi must always be >= 1<<16.
type Range32 struct {
        Lo     uint32
        Hi     uint32
        Stride uint32
}
 
// CaseRange represents a range of Unicode code points for simple (one
// code point to one code point) case conversion.
// The range runs from Lo to Hi inclusive, with a fixed stride of 1.  Deltas
// are the number to add to the code point to reach the code point for a
// different case for that character.  They may be negative.  If zero, it
// means the character is in the corresponding case. There is a special
// case representing sequences of alternating corresponding Upper and Lower
// pairs.  It appears with a fixed Delta of
//      {UpperLower, UpperLower, UpperLower}
// The constant UpperLower has an otherwise impossible delta value.
type CaseRange struct {
        Lo    uint32
        Hi    uint32
        Delta d
}
 
// SpecialCase represents language-specific case mappings such as Turkish.
// Methods of SpecialCase customize (by overriding) the standard mappings.
type SpecialCase []CaseRange
 
//BUG(r): Provide a mechanism for full case folding (those that involve
// multiple runes in the input or output).
 
// Indices into the Delta arrays inside CaseRanges for case mapping.
const (
        UpperCase = iota
        LowerCase
        TitleCase
        MaxCase
)
 
type d [MaxCase]rune // to make the CaseRanges text shorter
 
// If the Delta field of a CaseRange is UpperLower or LowerUpper, it means
// this CaseRange represents a sequence of the form (say)
// Upper Lower Upper Lower.
const (
        UpperLower = MaxRune + 1 // (Cannot be a valid delta.)
)
 
// is16 uses binary search to test whether rune is in the specified slice of 16-bit ranges.
func is16(ranges []Range16, r uint16) bool {
        // binary search over ranges
        lo := 0
        hi := len(ranges)
        for lo < hi {
                m := lo + (hi-lo)/2
                range_ := ranges[m]
                if range_.Lo <= r && r <= range_.Hi {
                        return (r-range_.Lo)%range_.Stride == 0
                }
                if r < range_.Lo {
                        hi = m
                } else {
                        lo = m + 1
                }
        }
        return false
}
 
// is32 uses binary search to test whether rune is in the specified slice of 32-bit ranges.
func is32(ranges []Range32, r uint32) bool {
        // binary search over ranges
        lo := 0
        hi := len(ranges)
        for lo < hi {
                m := lo + (hi-lo)/2
                range_ := ranges[m]
                if range_.Lo <= r && r <= range_.Hi {
                        return (r-range_.Lo)%range_.Stride == 0
                }
                if r < range_.Lo {
                        hi = m
                } else {
                        lo = m + 1
                }
        }
        return false
}
 
// Is tests whether rune is in the specified table of ranges.
func Is(rangeTab *RangeTable, r rune) bool {
        // common case: rune is ASCII or Latin-1.
        if uint32(r) <= MaxLatin1 {
                // Only need to check R16, since R32 is always >= 1<<16.
                r16 := uint16(r)
                for _, r := range rangeTab.R16 {
                        if r16 > r.Hi {
                                continue
                        }
                        if r16 < r.Lo {
                                return false
                        }
                        return (r16-r.Lo)%r.Stride == 0
                }
                return false
        }
        r16 := rangeTab.R16
        if len(r16) > 0 && r <= rune(r16[len(r16)-1].Hi) {
                return is16(r16, uint16(r))
        }
        r32 := rangeTab.R32
        if len(r32) > 0 && r >= rune(r32[0].Lo) {
                return is32(r32, uint32(r))
        }
        return false
}
 
// IsUpper reports whether the rune is an upper case letter.
func IsUpper(r rune) bool {
        // See comment in IsGraphic.
        if uint32(r) <= MaxLatin1 {
                return properties[uint8(r)]&pLu != 0
        }
        return Is(Upper, r)
}
 
// IsLower reports whether the rune is a lower case letter.
func IsLower(r rune) bool {
        // See comment in IsGraphic.
        if uint32(r) <= MaxLatin1 {
                return properties[uint8(r)]&pLl != 0
        }
        return Is(Lower, r)
}
 
// IsTitle reports whether the rune is a title case letter.
func IsTitle(r rune) bool {
        if r <= MaxLatin1 {
                return false
        }
        return Is(Title, r)
}
 
// to maps the rune using the specified case mapping.
func to(_case int, r rune, caseRange []CaseRange) rune {
        if _case < 0 || MaxCase <= _case {
                return ReplacementChar // as reasonable an error as any
        }
        // binary search over ranges
        lo := 0
        hi := len(caseRange)
        for lo < hi {
                m := lo + (hi-lo)/2
                cr := caseRange[m]
                if rune(cr.Lo) <= r && r <= rune(cr.Hi) {
                        delta := rune(cr.Delta[_case])
                        if delta > MaxRune {
                                // In an Upper-Lower sequence, which always starts with
                                // an UpperCase letter, the real deltas always look like:
                                //      {0, 1, 0}    UpperCase (Lower is next)
                                //      {-1, 0, -1}  LowerCase (Upper, Title are previous)
                                // The characters at even offsets from the beginning of the
                                // sequence are upper case; the ones at odd offsets are lower.
                                // The correct mapping can be done by clearing or setting the low
                                // bit in the sequence offset.
                                // The constants UpperCase and TitleCase are even while LowerCase
                                // is odd so we take the low bit from _case.
                                return rune(cr.Lo) + ((r-rune(cr.Lo))&^1 | rune(_case&1))
                        }
                        return r + delta
                }
                if r < rune(cr.Lo) {
                        hi = m
                } else {
                        lo = m + 1
                }
        }
        return r
}
 
// To maps the rune to the specified case: UpperCase, LowerCase, or TitleCase.
func To(_case int, r rune) rune {
        return to(_case, r, CaseRanges)
}
 
// ToUpper maps the rune to upper case.
func ToUpper(r rune) rune {
        if r <= MaxASCII {
                if 'a' <= r && r <= 'z' {
                        r -= 'a' - 'A'
                }
                return r
        }
        return To(UpperCase, r)
}
 
// ToLower maps the rune to lower case.
func ToLower(r rune) rune {
        if r <= MaxASCII {
                if 'A' <= r && r <= 'Z' {
                        r += 'a' - 'A'
                }
                return r
        }
        return To(LowerCase, r)
}
 
// ToTitle maps the rune to title case.
func ToTitle(r rune) rune {
        if r <= MaxASCII {
                if 'a' <= r && r <= 'z' { // title case is upper case for ASCII
                        r -= 'a' - 'A'
                }
                return r
        }
        return To(TitleCase, r)
}
 
// ToUpper maps the rune to upper case giving priority to the special mapping.
func (special SpecialCase) ToUpper(r rune) rune {
        r1 := to(UpperCase, r, []CaseRange(special))
        if r1 == r {
                r1 = ToUpper(r)
        }
        return r1
}
 
// ToTitle maps the rune to title case giving priority to the special mapping.
func (special SpecialCase) ToTitle(r rune) rune {
        r1 := to(TitleCase, r, []CaseRange(special))
        if r1 == r {
                r1 = ToTitle(r)
        }
        return r1
}
 
// ToLower maps the rune to lower case giving priority to the special mapping.
func (special SpecialCase) ToLower(r rune) rune {
        r1 := to(LowerCase, r, []CaseRange(special))
        if r1 == r {
                r1 = ToLower(r)
        }
        return r1
}
 
// caseOrbit is defined in tables.go as []foldPair.  Right now all the
// entries fit in uint16, so use uint16.  If that changes, compilation
// will fail (the constants in the composite literal will not fit in uint16)
// and the types here can change to uint32.
type foldPair struct {
        From uint16
        To   uint16
}
 
// SimpleFold iterates over Unicode code points equivalent under
// the Unicode-defined simple case folding.  Among the code points
// equivalent to rune (including rune itself), SimpleFold returns the
// smallest r >= rune if one exists, or else the smallest r >= 0.
//
// For example:
//      SimpleFold('A') = 'a'
//      SimpleFold('a') = 'A'
//
//      SimpleFold('K') = 'k'
//      SimpleFold('k') = '\u212A' (Kelvin symbol, K)
//      SimpleFold('\u212A') = 'K'
//
//      SimpleFold('1') = '1'
//
func SimpleFold(r rune) rune {
        // Consult caseOrbit table for special cases.
        lo := 0
        hi := len(caseOrbit)
        for lo < hi {
                m := lo + (hi-lo)/2
                if rune(caseOrbit[m].From) < r {
                        lo = m + 1
                } else {
                        hi = m
                }
        }
        if lo < len(caseOrbit) && rune(caseOrbit[lo].From) == r {
                return rune(caseOrbit[lo].To)
        }
 
        // No folding specified.  This is a one- or two-element
        // equivalence class containing rune and ToLower(rune)
        // and ToUpper(rune) if they are different from rune.
        if l := ToLower(r); l != r {
                return l
        }
        return ToUpper(r)
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgo/] [go/] [unicode/] [letter.go] - Blame information for rev 747

Line No.	Rev	Author	Line
1	747	jeremybenn	`// Copyright 2009 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 unicode provides data and functions to test some properties of`
6			`// Unicode code points.`
7			`package unicode`
8
9			`const (`
10			`MaxRune = '\U0010FFFF' // Maximum valid Unicode code point.`
11			`ReplacementChar = '\uFFFD' // Represents invalid code points.`
12			`MaxASCII = '\u007F' // maximum ASCII value.`
13			`MaxLatin1 = '\u00FF' // maximum Latin-1 value.`
14			`)`
15
16			`// RangeTable defines a set of Unicode code points by listing the ranges of`
17			`// code points within the set. The ranges are listed in two slices`
18			`// to save space: a slice of 16-bit ranges and a slice of 32-bit ranges.`
19			`// The two slices must be in sorted order and non-overlapping.`
20			`// Also, R32 should contain only values >= 0x10000 (1<<16).`
21			`type RangeTable struct {`
22			`R16 []Range16`
23			`R32 []Range32`
24			`}`
25
26			`// Range16 represents of a range of 16-bit Unicode code points. The range runs from Lo to Hi`
27			`// inclusive and has the specified stride.`
28			`type Range16 struct {`
29			`Lo uint16`
30			`Hi uint16`
31			`Stride uint16`
32			`}`
33
34			`// Range32 represents of a range of Unicode code points and is used when one or`
35			`// more of the values will not fit in 16 bits. The range runs from Lo to Hi`
36			`// inclusive and has the specified stride. Lo and Hi must always be >= 1<<16.`
37			`type Range32 struct {`
38			`Lo uint32`
39			`Hi uint32`
40			`Stride uint32`
41			`}`
42
43			`// CaseRange represents a range of Unicode code points for simple (one`
44			`// code point to one code point) case conversion.`
45			`// The range runs from Lo to Hi inclusive, with a fixed stride of 1. Deltas`
46			`// are the number to add to the code point to reach the code point for a`
47			`// different case for that character. They may be negative. If zero, it`
48			`// means the character is in the corresponding case. There is a special`
49			`// case representing sequences of alternating corresponding Upper and Lower`
50			`// pairs. It appears with a fixed Delta of`
51			`// {UpperLower, UpperLower, UpperLower}`
52			`// The constant UpperLower has an otherwise impossible delta value.`
53			`type CaseRange struct {`
54			`Lo uint32`
55			`Hi uint32`
56			`Delta d`
57			`}`
58
59			`// SpecialCase represents language-specific case mappings such as Turkish.`
60			`// Methods of SpecialCase customize (by overriding) the standard mappings.`
61			`type SpecialCase []CaseRange`
62
63			`//BUG(r): Provide a mechanism for full case folding (those that involve`
64			`// multiple runes in the input or output).`
65
66			`// Indices into the Delta arrays inside CaseRanges for case mapping.`
67			`const (`
68			`UpperCase = iota`
69			`LowerCase`
70			`TitleCase`
71			`MaxCase`
72			`)`
73
74			`type d [MaxCase]rune // to make the CaseRanges text shorter`
75
76			`// If the Delta field of a CaseRange is UpperLower or LowerUpper, it means`
77			`// this CaseRange represents a sequence of the form (say)`
78			`// Upper Lower Upper Lower.`
79			`const (`
80			`UpperLower = MaxRune + 1 // (Cannot be a valid delta.)`
81			`)`
82
83			`// is16 uses binary search to test whether rune is in the specified slice of 16-bit ranges.`
84			`func is16(ranges []Range16, r uint16) bool {`
85			`// binary search over ranges`
86			`lo := 0`
87			`hi := len(ranges)`
88			`for lo < hi {`
89			`m := lo + (hi-lo)/2`
90			`range_ := ranges[m]`
91			`if range_.Lo <= r && r <= range_.Hi {`
92			`return (r-range_.Lo)%range_.Stride == 0`
93			`}`
94			`if r < range_.Lo {`
95			`hi = m`
96			`} else {`
97			`lo = m + 1`
98			`}`
99			`}`
100			`return false`
101			`}`
102
103			`// is32 uses binary search to test whether rune is in the specified slice of 32-bit ranges.`
104			`func is32(ranges []Range32, r uint32) bool {`
105			`// binary search over ranges`
106			`lo := 0`
107			`hi := len(ranges)`
108			`for lo < hi {`
109			`m := lo + (hi-lo)/2`
110			`range_ := ranges[m]`
111			`if range_.Lo <= r && r <= range_.Hi {`
112			`return (r-range_.Lo)%range_.Stride == 0`
113			`}`
114			`if r < range_.Lo {`
115			`hi = m`
116			`} else {`
117			`lo = m + 1`
118			`}`
119			`}`
120			`return false`
121			`}`
122
123			`// Is tests whether rune is in the specified table of ranges.`
124			`func Is(rangeTab *RangeTable, r rune) bool {`
125			`// common case: rune is ASCII or Latin-1.`
126			`if uint32(r) <= MaxLatin1 {`
127			`// Only need to check R16, since R32 is always >= 1<<16.`
128			`r16 := uint16(r)`
129			`for _, r := range rangeTab.R16 {`
130			`if r16 > r.Hi {`
131			`continue`
132			`}`
133			`if r16 < r.Lo {`
134			`return false`
135			`}`
136			`return (r16-r.Lo)%r.Stride == 0`
137			`}`
138			`return false`
139			`}`
140			`r16 := rangeTab.R16`
141			`if len(r16) > 0 && r <= rune(r16[len(r16)-1].Hi) {`
142			`return is16(r16, uint16(r))`
143			`}`
144			`r32 := rangeTab.R32`
145			`if len(r32) > 0 && r >= rune(r32[0].Lo) {`
146			`return is32(r32, uint32(r))`
147			`}`
148			`return false`
149			`}`
150
151			`// IsUpper reports whether the rune is an upper case letter.`
152			`func IsUpper(r rune) bool {`
153			`// See comment in IsGraphic.`
154			`if uint32(r) <= MaxLatin1 {`
155			`return properties[uint8(r)]&pLu != 0`
156			`}`
157			`return Is(Upper, r)`
158			`}`
159
160			`// IsLower reports whether the rune is a lower case letter.`
161			`func IsLower(r rune) bool {`
162			`// See comment in IsGraphic.`
163			`if uint32(r) <= MaxLatin1 {`
164			`return properties[uint8(r)]&pLl != 0`
165			`}`
166			`return Is(Lower, r)`
167			`}`
168
169			`// IsTitle reports whether the rune is a title case letter.`
170			`func IsTitle(r rune) bool {`
171			`if r <= MaxLatin1 {`
172			`return false`
173			`}`
174			`return Is(Title, r)`
175			`}`
176
177			`// to maps the rune using the specified case mapping.`
178			`func to(_case int, r rune, caseRange []CaseRange) rune {`
179			`if _case < 0 \|\| MaxCase <= _case {`
180			`return ReplacementChar // as reasonable an error as any`
181			`}`
182			`// binary search over ranges`
183			`lo := 0`
184			`hi := len(caseRange)`
185			`for lo < hi {`
186			`m := lo + (hi-lo)/2`
187			`cr := caseRange[m]`
188			`if rune(cr.Lo) <= r && r <= rune(cr.Hi) {`
189			`delta := rune(cr.Delta[_case])`
190			`if delta > MaxRune {`
191			`// In an Upper-Lower sequence, which always starts with`
192			`// an UpperCase letter, the real deltas always look like:`
193			`// {0, 1, 0} UpperCase (Lower is next)`
194			`// {-1, 0, -1} LowerCase (Upper, Title are previous)`
195			`// The characters at even offsets from the beginning of the`
196			`// sequence are upper case; the ones at odd offsets are lower.`
197			`// The correct mapping can be done by clearing or setting the low`
198			`// bit in the sequence offset.`
199			`// The constants UpperCase and TitleCase are even while LowerCase`
200			`// is odd so we take the low bit from _case.`
201			`return rune(cr.Lo) + ((r-rune(cr.Lo))&^1 \| rune(_case&1))`
202			`}`
203			`return r + delta`
204			`}`
205			`if r < rune(cr.Lo) {`
206			`hi = m`
207			`} else {`
208			`lo = m + 1`
209			`}`
210			`}`
211			`return r`
212			`}`
213
214			`// To maps the rune to the specified case: UpperCase, LowerCase, or TitleCase.`
215			`func To(_case int, r rune) rune {`
216			`return to(_case, r, CaseRanges)`
217			`}`
218
219			`// ToUpper maps the rune to upper case.`
220			`func ToUpper(r rune) rune {`
221			`if r <= MaxASCII {`
222			`if 'a' <= r && r <= 'z' {`
223			`r -= 'a' - 'A'`
224			`}`
225			`return r`
226			`}`
227			`return To(UpperCase, r)`
228			`}`
229
230			`// ToLower maps the rune to lower case.`
231			`func ToLower(r rune) rune {`
232			`if r <= MaxASCII {`
233			`if 'A' <= r && r <= 'Z' {`
234			`r += 'a' - 'A'`
235			`}`
236			`return r`
237			`}`
238			`return To(LowerCase, r)`
239			`}`
240
241			`// ToTitle maps the rune to title case.`
242			`func ToTitle(r rune) rune {`
243			`if r <= MaxASCII {`
244			`if 'a' <= r && r <= 'z' { // title case is upper case for ASCII`
245			`r -= 'a' - 'A'`
246			`}`
247			`return r`
248			`}`
249			`return To(TitleCase, r)`
250			`}`
251
252			`// ToUpper maps the rune to upper case giving priority to the special mapping.`
253			`func (special SpecialCase) ToUpper(r rune) rune {`
254			`r1 := to(UpperCase, r, []CaseRange(special))`
255			`if r1 == r {`
256			`r1 = ToUpper(r)`
257			`}`
258			`return r1`
259			`}`
260
261			`// ToTitle maps the rune to title case giving priority to the special mapping.`
262			`func (special SpecialCase) ToTitle(r rune) rune {`
263			`r1 := to(TitleCase, r, []CaseRange(special))`
264			`if r1 == r {`
265			`r1 = ToTitle(r)`
266			`}`
267			`return r1`
268			`}`
269
270			`// ToLower maps the rune to lower case giving priority to the special mapping.`
271			`func (special SpecialCase) ToLower(r rune) rune {`
272			`r1 := to(LowerCase, r, []CaseRange(special))`
273			`if r1 == r {`
274			`r1 = ToLower(r)`
275			`}`
276			`return r1`
277			`}`
278
279			`// caseOrbit is defined in tables.go as []foldPair. Right now all the`
280			`// entries fit in uint16, so use uint16. If that changes, compilation`
281			`// will fail (the constants in the composite literal will not fit in uint16)`
282			`// and the types here can change to uint32.`
283			`type foldPair struct {`
284			`From uint16`
285			`To uint16`
286			`}`
287
288			`// SimpleFold iterates over Unicode code points equivalent under`
289			`// the Unicode-defined simple case folding. Among the code points`
290			`// equivalent to rune (including rune itself), SimpleFold returns the`
291			`// smallest r >= rune if one exists, or else the smallest r >= 0.`
292			`//`
293			`// For example:`
294			`// SimpleFold('A') = 'a'`
295			`// SimpleFold('a') = 'A'`
296			`//`
297			`// SimpleFold('K') = 'k'`
298			`// SimpleFold('k') = '\u212A' (Kelvin symbol, K)`
299			`// SimpleFold('\u212A') = 'K'`
300			`//`
301			`// SimpleFold('1') = '1'`
302			`//`
303			`func SimpleFold(r rune) rune {`
304			`// Consult caseOrbit table for special cases.`
305			`lo := 0`
306			`hi := len(caseOrbit)`
307			`for lo < hi {`
308			`m := lo + (hi-lo)/2`
309			`if rune(caseOrbit[m].From) < r {`
310			`lo = m + 1`
311			`} else {`
312			`hi = m`
313			`}`
314			`}`
315			`if lo < len(caseOrbit) && rune(caseOrbit[lo].From) == r {`
316			`return rune(caseOrbit[lo].To)`
317			`}`
318
319			`// No folding specified. This is a one- or two-element`
320			`// equivalence class containing rune and ToLower(rune)`
321			`// and ToUpper(rune) if they are different from rune.`
322			`if l := ToLower(r); l != r {`
323			`return l`
324			`}`
325			`return ToUpper(r)`
326			`}`