...
Run Format

Source file src/encoding/json/fold.go

     1	// Copyright 2013 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 json
     6	
     7	import (
     8		"bytes"
     9		"unicode/utf8"
    10	)
    11	
    12	const (
    13		caseMask     = ^byte(0x20) // Mask to ignore case in ASCII.
    14		kelvin       = '\u212a'
    15		smallLongEss = '\u017f'
    16	)
    17	
    18	// foldFunc returns one of four different case folding equivalence
    19	// functions, from most general (and slow) to fastest:
    20	//
    21	// 1) bytes.EqualFold, if the key s contains any non-ASCII UTF-8
    22	// 2) equalFoldRight, if s contains special folding ASCII ('k', 'K', 's', 'S')
    23	// 3) asciiEqualFold, no special, but includes non-letters (including _)
    24	// 4) simpleLetterEqualFold, no specials, no non-letters.
    25	//
    26	// The letters S and K are special because they map to 3 runes, not just 2:
    27	//  * S maps to s and to U+017F 'ſ' Latin small letter long s
    28	//  * k maps to K and to U+212A 'K' Kelvin sign
    29	// See https://play.golang.org/p/tTxjOc0OGo
    30	//
    31	// The returned function is specialized for matching against s and
    32	// should only be given s. It's not curried for performance reasons.
    33	func foldFunc(s []byte) func(s, t []byte) bool {
    34		nonLetter := false
    35		special := false // special letter
    36		for _, b := range s {
    37			if b >= utf8.RuneSelf {
    38				return bytes.EqualFold
    39			}
    40			upper := b & caseMask
    41			if upper < 'A' || upper > 'Z' {
    42				nonLetter = true
    43			} else if upper == 'K' || upper == 'S' {
    44				// See above for why these letters are special.
    45				special = true
    46			}
    47		}
    48		if special {
    49			return equalFoldRight
    50		}
    51		if nonLetter {
    52			return asciiEqualFold
    53		}
    54		return simpleLetterEqualFold
    55	}
    56	
    57	// equalFoldRight is a specialization of bytes.EqualFold when s is
    58	// known to be all ASCII (including punctuation), but contains an 's',
    59	// 'S', 'k', or 'K', requiring a Unicode fold on the bytes in t.
    60	// See comments on foldFunc.
    61	func equalFoldRight(s, t []byte) bool {
    62		for _, sb := range s {
    63			if len(t) == 0 {
    64				return false
    65			}
    66			tb := t[0]
    67			if tb < utf8.RuneSelf {
    68				if sb != tb {
    69					sbUpper := sb & caseMask
    70					if 'A' <= sbUpper && sbUpper <= 'Z' {
    71						if sbUpper != tb&caseMask {
    72							return false
    73						}
    74					} else {
    75						return false
    76					}
    77				}
    78				t = t[1:]
    79				continue
    80			}
    81			// sb is ASCII and t is not. t must be either kelvin
    82			// sign or long s; sb must be s, S, k, or K.
    83			tr, size := utf8.DecodeRune(t)
    84			switch sb {
    85			case 's', 'S':
    86				if tr != smallLongEss {
    87					return false
    88				}
    89			case 'k', 'K':
    90				if tr != kelvin {
    91					return false
    92				}
    93			default:
    94				return false
    95			}
    96			t = t[size:]
    97	
    98		}
    99		if len(t) > 0 {
   100			return false
   101		}
   102		return true
   103	}
   104	
   105	// asciiEqualFold is a specialization of bytes.EqualFold for use when
   106	// s is all ASCII (but may contain non-letters) and contains no
   107	// special-folding letters.
   108	// See comments on foldFunc.
   109	func asciiEqualFold(s, t []byte) bool {
   110		if len(s) != len(t) {
   111			return false
   112		}
   113		for i, sb := range s {
   114			tb := t[i]
   115			if sb == tb {
   116				continue
   117			}
   118			if ('a' <= sb && sb <= 'z') || ('A' <= sb && sb <= 'Z') {
   119				if sb&caseMask != tb&caseMask {
   120					return false
   121				}
   122			} else {
   123				return false
   124			}
   125		}
   126		return true
   127	}
   128	
   129	// simpleLetterEqualFold is a specialization of bytes.EqualFold for
   130	// use when s is all ASCII letters (no underscores, etc) and also
   131	// doesn't contain 'k', 'K', 's', or 'S'.
   132	// See comments on foldFunc.
   133	func simpleLetterEqualFold(s, t []byte) bool {
   134		if len(s) != len(t) {
   135			return false
   136		}
   137		for i, b := range s {
   138			if b&caseMask != t[i]&caseMask {
   139				return false
   140			}
   141		}
   142		return true
   143	}
   144	

View as plain text