vendor/github.com/ghodss/yaml/fields.go - bbsim - Gitiles

 // 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 yaml

 import (
 	"bytes"
 	"encoding"
 	"encoding/json"
 	"reflect"
 	"sort"
 	"strings"
 	"sync"
 	"unicode"
 	"unicode/utf8"
 )

 // indirect walks down v allocating pointers as needed,
 // until it gets to a non-pointer.
 // if it encounters an Unmarshaler, indirect stops and returns that.
 // if decodingNull is true, indirect stops at the last pointer so it can be set to nil.
 func indirect(v reflect.Value, decodingNull bool) (json.Unmarshaler, encoding.TextUnmarshaler, reflect.Value) {
 	// If v is a named type and is addressable,
 	// start with its address, so that if the type has pointer methods,
 	// we find them.
 	if v.Kind() != reflect.Ptr && v.Type().Name() != "" && v.CanAddr() {
 		v = v.Addr()
 	}
 	for {
 		// Load value from interface, but only if the result will be
 		// usefully addressable.
 		if v.Kind() == reflect.Interface && !v.IsNil() {
 			e := v.Elem()
 			if e.Kind() == reflect.Ptr && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Ptr) {
 				v = e
 				continue
 			}
 		}

 		if v.Kind() != reflect.Ptr {
 			break
 		}

 		if v.Elem().Kind() != reflect.Ptr && decodingNull && v.CanSet() {
 			break
 		}
 		if v.IsNil() {
 			if v.CanSet() {
 				v.Set(reflect.New(v.Type().Elem()))
 			} else {
 				v = reflect.New(v.Type().Elem())
 			}
 		}
 		if v.Type().NumMethod() > 0 {
 			if u, ok := v.Interface().(json.Unmarshaler); ok {
 				return u, nil, reflect.Value{}
 			}
 			if u, ok := v.Interface().(encoding.TextUnmarshaler); ok {
 				return nil, u, reflect.Value{}
 			}
 		}
 		v = v.Elem()
 	}
 	return nil, nil, v
 }

 // A field represents a single field found in a struct.
 type field struct {
 	name      string
 	nameBytes []byte                 // []byte(name)
 	equalFold func(s, t []byte) bool // bytes.EqualFold or equivalent

 	tag       bool
 	index     []int
 	typ       reflect.Type
 	omitEmpty bool
 	quoted    bool
 }

 func fillField(f field) field {
 	f.nameBytes = []byte(f.name)
 	f.equalFold = foldFunc(f.nameBytes)
 	return f
 }

 // byName sorts field by name, breaking ties with depth,
 // then breaking ties with "name came from json tag", then
 // breaking ties with index sequence.
 type byName []field

 func (x byName) Len() int { return len(x) }

 func (x byName) Swap(i, j int) { x[i], x[j] = x[j], x[i] }

 func (x byName) Less(i, j int) bool {
 	if x[i].name != x[j].name {
 		return x[i].name < x[j].name
 	}
 	if len(x[i].index) != len(x[j].index) {
 		return len(x[i].index) < len(x[j].index)
 	}
 	if x[i].tag != x[j].tag {
 		return x[i].tag
 	}
 	return byIndex(x).Less(i, j)
 }

 // byIndex sorts field by index sequence.
 type byIndex []field

 func (x byIndex) Len() int { return len(x) }

 func (x byIndex) Swap(i, j int) { x[i], x[j] = x[j], x[i] }

 func (x byIndex) Less(i, j int) bool {
 	for k, xik := range x[i].index {
 		if k >= len(x[j].index) {
 			return false
 		}
 		if xik != x[j].index[k] {
 			return xik < x[j].index[k]
 		}
 	}
 	return len(x[i].index) < len(x[j].index)
 }

 // typeFields returns a list of fields that JSON should recognize for the given type.
 // The algorithm is breadth-first search over the set of structs to include - the top struct
 // and then any reachable anonymous structs.
 func typeFields(t reflect.Type) []field {
 	// Anonymous fields to explore at the current level and the next.
 	current := []field{}
 	next := []field{{typ: t}}

 	// Count of queued names for current level and the next.
 	count := map[reflect.Type]int{}
 	nextCount := map[reflect.Type]int{}

 	// Types already visited at an earlier level.
 	visited := map[reflect.Type]bool{}

 	// Fields found.
 	var fields []field

 	for len(next) > 0 {
 		current, next = next, current[:0]
 		count, nextCount = nextCount, map[reflect.Type]int{}

 		for _, f := range current {
 			if visited[f.typ] {
 				continue
 			}
 			visited[f.typ] = true

 			// Scan f.typ for fields to include.
 			for i := 0; i < f.typ.NumField(); i++ {
 				sf := f.typ.Field(i)
 				if sf.PkgPath != "" { // unexported
 					continue
 				}
 				tag := sf.Tag.Get("json")
 				if tag == "-" {
 					continue
 				}
 				name, opts := parseTag(tag)
 				if !isValidTag(name) {
 					name = ""
 				}
 				index := make([]int, len(f.index)+1)
 				copy(index, f.index)
 				index[len(f.index)] = i

 				ft := sf.Type
 				if ft.Name() == "" && ft.Kind() == reflect.Ptr {
 					// Follow pointer.
 					ft = ft.Elem()
 				}

 				// Record found field and index sequence.
 				if name != "" || !sf.Anonymous || ft.Kind() != reflect.Struct {
 					tagged := name != ""
 					if name == "" {
 						name = sf.Name
 					}
 					fields = append(fields, fillField(field{
 						name:      name,
 						tag:       tagged,
 						index:     index,
 						typ:       ft,
 						omitEmpty: opts.Contains("omitempty"),
 						quoted:    opts.Contains("string"),
 					}))
 					if count[f.typ] > 1 {
 						// If there were multiple instances, add a second,
 						// so that the annihilation code will see a duplicate.
 						// It only cares about the distinction between 1 or 2,
 						// so don't bother generating any more copies.
 						fields = append(fields, fields[len(fields)-1])
 					}
 					continue
 				}

 				// Record new anonymous struct to explore in next round.
 				nextCount[ft]++
 				if nextCount[ft] == 1 {
 					next = append(next, fillField(field{name: ft.Name(), index: index, typ: ft}))
 				}
 			}
 		}
 	}

 	sort.Sort(byName(fields))

 	// Delete all fields that are hidden by the Go rules for embedded fields,
 	// except that fields with JSON tags are promoted.

 	// The fields are sorted in primary order of name, secondary order
 	// of field index length. Loop over names; for each name, delete
 	// hidden fields by choosing the one dominant field that survives.
 	out := fields[:0]
 	for advance, i := 0, 0; i < len(fields); i += advance {
 		// One iteration per name.
 		// Find the sequence of fields with the name of this first field.
 		fi := fields[i]
 		name := fi.name
 		for advance = 1; i+advance < len(fields); advance++ {
 			fj := fields[i+advance]
 			if fj.name != name {
 				break
 			}
 		}
 		if advance == 1 { // Only one field with this name
 			out = append(out, fi)
 			continue
 		}
 		dominant, ok := dominantField(fields[i : i+advance])
 		if ok {
 			out = append(out, dominant)
 		}
 	}

 	fields = out
 	sort.Sort(byIndex(fields))

 	return fields
 }

 // dominantField looks through the fields, all of which are known to
 // have the same name, to find the single field that dominates the
 // others using Go's embedding rules, modified by the presence of
 // JSON tags. If there are multiple top-level fields, the boolean
 // will be false: This condition is an error in Go and we skip all
 // the fields.
 func dominantField(fields []field) (field, bool) {
 	// The fields are sorted in increasing index-length order. The winner
 	// must therefore be one with the shortest index length. Drop all
 	// longer entries, which is easy: just truncate the slice.
 	length := len(fields[0].index)
 	tagged := -1 // Index of first tagged field.
 	for i, f := range fields {
 		if len(f.index) > length {
 			fields = fields[:i]
 			break
 		}
 		if f.tag {
 			if tagged >= 0 {
 				// Multiple tagged fields at the same level: conflict.
 				// Return no field.
 				return field{}, false
 			}
 			tagged = i
 		}
 	}
 	if tagged >= 0 {
 		return fields[tagged], true
 	}
 	// All remaining fields have the same length. If there's more than one,
 	// we have a conflict (two fields named "X" at the same level) and we
 	// return no field.
 	if len(fields) > 1 {
 		return field{}, false
 	}
 	return fields[0], true
 }

 var fieldCache struct {
 	sync.RWMutex
 	m map[reflect.Type][]field
 }

 // cachedTypeFields is like typeFields but uses a cache to avoid repeated work.
 func cachedTypeFields(t reflect.Type) []field {
 	fieldCache.RLock()
 	f := fieldCache.m[t]
 	fieldCache.RUnlock()
 	if f != nil {
 		return f
 	}

 	// Compute fields without lock.
 	// Might duplicate effort but won't hold other computations back.
 	f = typeFields(t)
 	if f == nil {
 		f = []field{}
 	}

 	fieldCache.Lock()
 	if fieldCache.m == nil {
 		fieldCache.m = map[reflect.Type][]field{}
 	}
 	fieldCache.m[t] = f
 	fieldCache.Unlock()
 	return f
 }

 func isValidTag(s string) bool {
 	if s == "" {
 		return false
 	}
 	for _, c := range s {
 		switch {
 		case strings.ContainsRune("!#$%&()*+-./:<=>?@[]^_{|}~ ", c):
 			// Backslash and quote chars are reserved, but
 			// otherwise any punctuation chars are allowed
 			// in a tag name.
 		default:
 			if !unicode.IsLetter(c) && !unicode.IsDigit(c) {
 				return false
 			}
 		}
 	}
 	return true
 }

 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 'K' Kelvin sign
 // See http://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
 }

 // tagOptions is the string following a comma in a struct field's "json"
 // tag, or the empty string. It does not include the leading comma.
 type tagOptions string

 // parseTag splits a struct field's json tag into its name and
 // comma-separated options.
 func parseTag(tag string) (string, tagOptions) {
 	if idx := strings.Index(tag, ","); idx != -1 {
 		return tag[:idx], tagOptions(tag[idx+1:])
 	}
 	return tag, tagOptions("")
 }

 // Contains reports whether a comma-separated list of options
 // contains a particular substr flag. substr must be surrounded by a
 // string boundary or commas.
 func (o tagOptions) Contains(optionName string) bool {
 	if len(o) == 0 {
 		return false
 	}
 	s := string(o)
 	for s != "" {
 		var next string
 		i := strings.Index(s, ",")
 		if i >= 0 {
 			s, next = s[:i], s[i+1:]
 		}
 		if s == optionName {
 			return true
 		}
 		s = next
 	}
 	return false
 }
	// 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 yaml

	import (
	"bytes"
	"encoding"
	"encoding/json"
	"reflect"
	"sort"
	"strings"
	"sync"
	"unicode"
	"unicode/utf8"
	)

	// indirect walks down v allocating pointers as needed,
	// until it gets to a non-pointer.
	// if it encounters an Unmarshaler, indirect stops and returns that.
	// if decodingNull is true, indirect stops at the last pointer so it can be set to nil.
	func indirect(v reflect.Value, decodingNull bool) (json.Unmarshaler, encoding.TextUnmarshaler, reflect.Value) {
	// If v is a named type and is addressable,
	// start with its address, so that if the type has pointer methods,
	// we find them.
	if v.Kind() != reflect.Ptr && v.Type().Name() != "" && v.CanAddr() {
	v = v.Addr()
	}
	for {
	// Load value from interface, but only if the result will be
	// usefully addressable.
	if v.Kind() == reflect.Interface && !v.IsNil() {
	e := v.Elem()
	if e.Kind() == reflect.Ptr && !e.IsNil() && (!decodingNull \|\| e.Elem().Kind() == reflect.Ptr) {
	v = e
	continue
	}
	}

	if v.Kind() != reflect.Ptr {
	break
	}

	if v.Elem().Kind() != reflect.Ptr && decodingNull && v.CanSet() {
	break
	}
	if v.IsNil() {
	if v.CanSet() {
	v.Set(reflect.New(v.Type().Elem()))
	} else {
	v = reflect.New(v.Type().Elem())
	}
	}
	if v.Type().NumMethod() > 0 {
	if u, ok := v.Interface().(json.Unmarshaler); ok {
	return u, nil, reflect.Value{}
	}
	if u, ok := v.Interface().(encoding.TextUnmarshaler); ok {
	return nil, u, reflect.Value{}
	}
	}
	v = v.Elem()
	}
	return nil, nil, v
	}

	// A field represents a single field found in a struct.
	type field struct {
	name string
	nameBytes []byte // []byte(name)
	equalFold func(s, t []byte) bool // bytes.EqualFold or equivalent

	tag bool
	index []int
	typ reflect.Type
	omitEmpty bool
	quoted bool
	}

	func fillField(f field) field {
	f.nameBytes = []byte(f.name)
	f.equalFold = foldFunc(f.nameBytes)
	return f
	}

	// byName sorts field by name, breaking ties with depth,
	// then breaking ties with "name came from json tag", then
	// breaking ties with index sequence.
	type byName []field

	func (x byName) Len() int { return len(x) }

	func (x byName) Swap(i, j int) { x[i], x[j] = x[j], x[i] }

	func (x byName) Less(i, j int) bool {
	if x[i].name != x[j].name {
	return x[i].name < x[j].name
	}
	if len(x[i].index) != len(x[j].index) {
	return len(x[i].index) < len(x[j].index)
	}
	if x[i].tag != x[j].tag {
	return x[i].tag
	}
	return byIndex(x).Less(i, j)
	}

	// byIndex sorts field by index sequence.
	type byIndex []field

	func (x byIndex) Len() int { return len(x) }

	func (x byIndex) Swap(i, j int) { x[i], x[j] = x[j], x[i] }

	func (x byIndex) Less(i, j int) bool {
	for k, xik := range x[i].index {
	if k >= len(x[j].index) {
	return false
	}
	if xik != x[j].index[k] {
	return xik < x[j].index[k]
	}
	}
	return len(x[i].index) < len(x[j].index)
	}

	// typeFields returns a list of fields that JSON should recognize for the given type.
	// The algorithm is breadth-first search over the set of structs to include - the top struct
	// and then any reachable anonymous structs.
	func typeFields(t reflect.Type) []field {
	// Anonymous fields to explore at the current level and the next.
	current := []field{}
	next := []field{{typ: t}}

	// Count of queued names for current level and the next.
	count := map[reflect.Type]int{}
	nextCount := map[reflect.Type]int{}

	// Types already visited at an earlier level.
	visited := map[reflect.Type]bool{}

	// Fields found.
	var fields []field

	for len(next) > 0 {
	current, next = next, current[:0]
	count, nextCount = nextCount, map[reflect.Type]int{}

	for _, f := range current {
	if visited[f.typ] {
	continue
	}
	visited[f.typ] = true

	// Scan f.typ for fields to include.
	for i := 0; i < f.typ.NumField(); i++ {
	sf := f.typ.Field(i)
	if sf.PkgPath != "" { // unexported
	continue
	}
	tag := sf.Tag.Get("json")
	if tag == "-" {
	continue
	}
	name, opts := parseTag(tag)
	if !isValidTag(name) {
	name = ""
	}
	index := make([]int, len(f.index)+1)
	copy(index, f.index)
	index[len(f.index)] = i

	ft := sf.Type
	if ft.Name() == "" && ft.Kind() == reflect.Ptr {
	// Follow pointer.
	ft = ft.Elem()
	}

	// Record found field and index sequence.
	if name != "" \|\| !sf.Anonymous \|\| ft.Kind() != reflect.Struct {
	tagged := name != ""
	if name == "" {
	name = sf.Name
	}
	fields = append(fields, fillField(field{
	name: name,
	tag: tagged,
	index: index,
	typ: ft,
	omitEmpty: opts.Contains("omitempty"),
	quoted: opts.Contains("string"),
	}))
	if count[f.typ] > 1 {
	// If there were multiple instances, add a second,
	// so that the annihilation code will see a duplicate.
	// It only cares about the distinction between 1 or 2,
	// so don't bother generating any more copies.
	fields = append(fields, fields[len(fields)-1])
	}
	continue
	}

	// Record new anonymous struct to explore in next round.
	nextCount[ft]++
	if nextCount[ft] == 1 {
	next = append(next, fillField(field{name: ft.Name(), index: index, typ: ft}))
	}
	}
	}
	}

	sort.Sort(byName(fields))

	// Delete all fields that are hidden by the Go rules for embedded fields,
	// except that fields with JSON tags are promoted.

	// The fields are sorted in primary order of name, secondary order
	// of field index length. Loop over names; for each name, delete
	// hidden fields by choosing the one dominant field that survives.
	out := fields[:0]
	for advance, i := 0, 0; i < len(fields); i += advance {
	// One iteration per name.
	// Find the sequence of fields with the name of this first field.
	fi := fields[i]
	name := fi.name
	for advance = 1; i+advance < len(fields); advance++ {
	fj := fields[i+advance]
	if fj.name != name {
	break
	}
	}
	if advance == 1 { // Only one field with this name
	out = append(out, fi)
	continue
	}
	dominant, ok := dominantField(fields[i : i+advance])
	if ok {
	out = append(out, dominant)
	}
	}

	fields = out
	sort.Sort(byIndex(fields))

	return fields
	}

	// dominantField looks through the fields, all of which are known to
	// have the same name, to find the single field that dominates the
	// others using Go's embedding rules, modified by the presence of
	// JSON tags. If there are multiple top-level fields, the boolean
	// will be false: This condition is an error in Go and we skip all
	// the fields.
	func dominantField(fields []field) (field, bool) {
	// The fields are sorted in increasing index-length order. The winner
	// must therefore be one with the shortest index length. Drop all
	// longer entries, which is easy: just truncate the slice.
	length := len(fields[0].index)
	tagged := -1 // Index of first tagged field.
	for i, f := range fields {
	if len(f.index) > length {
	fields = fields[:i]
	break
	}
	if f.tag {
	if tagged >= 0 {
	// Multiple tagged fields at the same level: conflict.
	// Return no field.
	return field{}, false
	}
	tagged = i
	}
	}
	if tagged >= 0 {
	return fields[tagged], true
	}
	// All remaining fields have the same length. If there's more than one,
	// we have a conflict (two fields named "X" at the same level) and we
	// return no field.
	if len(fields) > 1 {
	return field{}, false
	}
	return fields[0], true
	}

	var fieldCache struct {
	sync.RWMutex
	m map[reflect.Type][]field
	}

	// cachedTypeFields is like typeFields but uses a cache to avoid repeated work.
	func cachedTypeFields(t reflect.Type) []field {
	fieldCache.RLock()
	f := fieldCache.m[t]
	fieldCache.RUnlock()
	if f != nil {
	return f
	}

	// Compute fields without lock.
	// Might duplicate effort but won't hold other computations back.
	f = typeFields(t)
	if f == nil {
	f = []field{}
	}

	fieldCache.Lock()
	if fieldCache.m == nil {
	fieldCache.m = map[reflect.Type][]field{}
	}
	fieldCache.m[t] = f
	fieldCache.Unlock()
	return f
	}

	func isValidTag(s string) bool {
	if s == "" {
	return false
	}
	for _, c := range s {
	switch {
	case strings.ContainsRune("!#$%&()*+-./:<=>?@[]^_{\|}~ ", c):
	// Backslash and quote chars are reserved, but
	// otherwise any punctuation chars are allowed
	// in a tag name.
	default:
	if !unicode.IsLetter(c) && !unicode.IsDigit(c) {
	return false
	}
	}
	}
	return true
	}

	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 'K' Kelvin sign
	// See http://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
	}

	// tagOptions is the string following a comma in a struct field's "json"
	// tag, or the empty string. It does not include the leading comma.
	type tagOptions string

	// parseTag splits a struct field's json tag into its name and
	// comma-separated options.
	func parseTag(tag string) (string, tagOptions) {
	if idx := strings.Index(tag, ","); idx != -1 {
	return tag[:idx], tagOptions(tag[idx+1:])
	}
	return tag, tagOptions("")
	}

	// Contains reports whether a comma-separated list of options
	// contains a particular substr flag. substr must be surrounded by a
	// string boundary or commas.
	func (o tagOptions) Contains(optionName string) bool {
	if len(o) == 0 {
	return false
	}
	s := string(o)
	for s != "" {
	var next string
	i := strings.Index(s, ",")
	if i >= 0 {
	s, next = s[:i], s[i+1:]
	}
	if s == optionName {
	return true
	}
	s = next
	}
	return false
	}