fold.go

Documentation: encoding/json

		 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 'K' 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