forked from vikunja/vikunja
144 lines
3.4 KiB
Go
144 lines
3.4 KiB
Go
// Copyright 2013 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 json
|
||
|
||
import (
|
||
"bytes"
|
||
"unicode/utf8"
|
||
)
|
||
|
||
const (
|
||
caseMask = ^byte(0x20) // Mask to ignore case in ASCII.
|
||
kelvin = '\u212a'
|
||
smallLongEss = '\u017f'
|
||
)
|
||
|
||
// foldFunc returns one of four different case folding equivalence
|
||
// functions, from most general (and slow) to fastest:
|
||
//
|
||
// 1) bytes.EqualFold, if the key s contains any non-ASCII UTF-8
|
||
// 2) equalFoldRight, if s contains special folding ASCII ('k', 'K', 's', 'S')
|
||
// 3) asciiEqualFold, no special, but includes non-letters (including _)
|
||
// 4) simpleLetterEqualFold, no specials, no non-letters.
|
||
//
|
||
// The letters S and K are special because they map to 3 runes, not just 2:
|
||
// * S maps to s and to U+017F 'ſ' Latin small letter long s
|
||
// * k maps to K and to U+212A 'K' Kelvin sign
|
||
// See https://play.golang.org/p/tTxjOc0OGo
|
||
//
|
||
// The returned function is specialized for matching against s and
|
||
// should only be given s. It's not curried for performance reasons.
|
||
func foldFunc(s []byte) func(s, t []byte) bool {
|
||
nonLetter := false
|
||
special := false // special letter
|
||
for _, b := range s {
|
||
if b >= utf8.RuneSelf {
|
||
return bytes.EqualFold
|
||
}
|
||
upper := b & caseMask
|
||
if upper < 'A' || upper > 'Z' {
|
||
nonLetter = true
|
||
} else if upper == 'K' || upper == 'S' {
|
||
// See above for why these letters are special.
|
||
special = true
|
||
}
|
||
}
|
||
if special {
|
||
return equalFoldRight
|
||
}
|
||
if nonLetter {
|
||
return asciiEqualFold
|
||
}
|
||
return simpleLetterEqualFold
|
||
}
|
||
|
||
// equalFoldRight is a specialization of bytes.EqualFold when s is
|
||
// known to be all ASCII (including punctuation), but contains an 's',
|
||
// 'S', 'k', or 'K', requiring a Unicode fold on the bytes in t.
|
||
// See comments on foldFunc.
|
||
func equalFoldRight(s, t []byte) bool {
|
||
for _, sb := range s {
|
||
if len(t) == 0 {
|
||
return false
|
||
}
|
||
tb := t[0]
|
||
if tb < utf8.RuneSelf {
|
||
if sb != tb {
|
||
sbUpper := sb & caseMask
|
||
if 'A' <= sbUpper && sbUpper <= 'Z' {
|
||
if sbUpper != tb&caseMask {
|
||
return false
|
||
}
|
||
} else {
|
||
return false
|
||
}
|
||
}
|
||
t = t[1:]
|
||
continue
|
||
}
|
||
// sb is ASCII and t is not. t must be either kelvin
|
||
// sign or long s; sb must be s, S, k, or K.
|
||
tr, size := utf8.DecodeRune(t)
|
||
switch sb {
|
||
case 's', 'S':
|
||
if tr != smallLongEss {
|
||
return false
|
||
}
|
||
case 'k', 'K':
|
||
if tr != kelvin {
|
||
return false
|
||
}
|
||
default:
|
||
return false
|
||
}
|
||
t = t[size:]
|
||
|
||
}
|
||
if len(t) > 0 {
|
||
return false
|
||
}
|
||
return true
|
||
}
|
||
|
||
// asciiEqualFold is a specialization of bytes.EqualFold for use when
|
||
// s is all ASCII (but may contain non-letters) and contains no
|
||
// special-folding letters.
|
||
// See comments on foldFunc.
|
||
func asciiEqualFold(s, t []byte) bool {
|
||
if len(s) != len(t) {
|
||
return false
|
||
}
|
||
for i, sb := range s {
|
||
tb := t[i]
|
||
if sb == tb {
|
||
continue
|
||
}
|
||
if ('a' <= sb && sb <= 'z') || ('A' <= sb && sb <= 'Z') {
|
||
if sb&caseMask != tb&caseMask {
|
||
return false
|
||
}
|
||
} else {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
|
||
// simpleLetterEqualFold is a specialization of bytes.EqualFold for
|
||
// use when s is all ASCII letters (no underscores, etc) and also
|
||
// doesn't contain 'k', 'K', 's', or 'S'.
|
||
// See comments on foldFunc.
|
||
func simpleLetterEqualFold(s, t []byte) bool {
|
||
if len(s) != len(t) {
|
||
return false
|
||
}
|
||
for i, b := range s {
|
||
if b&caseMask != t[i]&caseMask {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
}
|