vendor/golang.org/x/text/unicode/norm/trie.go


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

// Copyright 2011 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 norm

type valueRange struct {
    value  uint16 // header: value:stride
    lo, hi byte   // header: lo:n
}

type sparseBlocks struct {
    values []valueRange
    offset []uint16
}

var nfcSparse = sparseBlocks{
    values: nfcSparseValues[:],
    offset: nfcSparseOffset[:],
}

var nfkcSparse = sparseBlocks{
    values: nfkcSparseValues[:],
    offset: nfkcSparseOffset[:],
}

var (
    nfcData  = newNfcTrie(0)
    nfkcData = newNfkcTrie(0)
)

// lookupValue determines the type of block n and looks up the value for b.
// For n < t.cutoff, the block is a simple lookup table. Otherwise, the block
// is a list of ranges with an accompanying value. Given a matching range r,
// the value for b is by r.value + (b - r.lo) * stride.
func (t *sparseBlocks) lookup(n uint32, b byte) uint16 {
    offset := t.offset[n]
    header := t.values[offset]
    lo := offset + 1
    hi := lo + uint16(header.lo)
    for lo < hi {
        m := lo + (hi-lo)/2
        r := t.values[m]
        if r.lo <= b && b <= r.hi {
            return r.value + uint16(b-r.lo)*header.value
        }
        if b < r.lo {
            hi = m
        } else {
            lo = m + 1
        }
    }
    return 0
}