go-json/decode_struct.go

package json

import (
	"fmt"
	"math"
	"sort"
	"strings"
	"unsafe"
)

type structFieldSet struct {
	dec         decoder
	offset      uintptr
	isTaggedKey bool
}

type structDecoder struct {
	fieldMap              map[string]*structFieldSet
	keyDecoder            *stringDecoder
	structName            string
	fieldName             string
	isTriedOptimize       bool
	isOptimizedKeyDecoder bool
	keyBitMap             [][256]int16
	sortedFieldSets       []*structFieldSet
}

var (
	bitHashTable      [64]int
	largeToSmallTable [256]byte
)

func init() {
	hash := uint64(0x03F566ED27179461)
	for i := 0; i < 64; i++ {
		bitHashTable[hash>>58] = i
		hash <<= 1
	}
	for i := 0; i < 256; i++ {
		c := i
		if 'A' <= c && c <= 'Z' {
			c += 'a' - 'A'
		}
		largeToSmallTable[i] = byte(c)
	}
}

func newStructDecoder(structName, fieldName string, fieldMap map[string]*structFieldSet) *structDecoder {
	return &structDecoder{
		fieldMap:   fieldMap,
		keyDecoder: newStringDecoder(structName, fieldName),
		structName: structName,
		fieldName:  fieldName,
	}
}

const (
	allowOptimizeMaxKeyLen   = 64
	allowOptimizeMaxFieldLen = 16
)

func (d *structDecoder) tryOptimize() {
	if d.isTriedOptimize {
		return
	}
	fieldMap := map[string]*structFieldSet{}
	for k, v := range d.fieldMap {
		k := strings.ToLower(k)
		fieldMap[k] = v
	}

	if len(fieldMap) > allowOptimizeMaxFieldLen {
		d.isTriedOptimize = true
		return
	}

	var maxKeyLen int
	sortedKeys := []string{}
	for key := range fieldMap {
		keyLen := len(key)
		if keyLen > allowOptimizeMaxKeyLen {
			d.isTriedOptimize = true
			return
		}
		if maxKeyLen < keyLen {
			maxKeyLen = keyLen
		}
		sortedKeys = append(sortedKeys, key)
	}
	sort.Strings(sortedKeys)
	keyBitMap := make([][256]int16, maxKeyLen)
	for i, key := range sortedKeys {
		for j := 0; j < len(key); j++ {
			c := key[j]
			keyBitMap[j][c] |= (1 << uint(i))
		}
		d.sortedFieldSets = append(d.sortedFieldSets, fieldMap[key])
	}
	d.keyBitMap = keyBitMap
	d.isOptimizedKeyDecoder = true
}

func (d *structDecoder) decodeKeyOptimized(buf []byte, cursor int64) (int64, *structFieldSet, error) {
	var (
		field  *structFieldSet
		curBit int16 = math.MaxInt16
	)
	for {
		switch buf[cursor] {
		case ' ', '\n', '\t', '\r':
			cursor++
		case '"':
			cursor++
			keyIdx := 0
			c := buf[cursor]
			switch c {
			case '"':
				cursor++
				goto KEY_END
			case nul:
				return 0, nil, errUnexpectedEndOfJSON("string", cursor)
			}
			curBit &= d.keyBitMap[0][largeToSmallTable[c]]
			if curBit == 0 {
				for {
					cursor++
					switch buf[cursor] {
					case '"':
						cursor++
						goto KEY_END
					case '\\':
						cursor++
						if buf[cursor] == nul {
							return 0, nil, errUnexpectedEndOfJSON("string", cursor)
						}
					case nul:
						return 0, nil, errUnexpectedEndOfJSON("string", cursor)
					}
				}
			}
			for {
				c := buf[cursor]
				switch c {
				case '"':
					x := uint64(curBit & -curBit)
					fieldSetIndex := bitHashTable[(x*0x03F566ED27179461)>>58]
					field = d.sortedFieldSets[fieldSetIndex]
					cursor++
					goto KEY_END
				case nul:
					return 0, nil, errUnexpectedEndOfJSON("string", cursor)
				default:
					if keyIdx >= len(d.keyBitMap) {
						for {
							cursor++
							switch buf[cursor] {
							case '"':
								cursor++
								goto KEY_END
							case '\\':
								cursor++
								if buf[cursor] == nul {
									return 0, nil, errUnexpectedEndOfJSON("string", cursor)
								}
							case nul:
								return 0, nil, errUnexpectedEndOfJSON("string", cursor)
							}
						}
					}
					curBit &= d.keyBitMap[keyIdx][largeToSmallTable[c]]
					if curBit == 0 {
						for {
							cursor++
							switch buf[cursor] {
							case '"':
								cursor++
								goto KEY_END
							case '\\':
								cursor++
								if buf[cursor] == nul {
									return 0, nil, errUnexpectedEndOfJSON("string", cursor)
								}
							case nul:
								return 0, nil, errUnexpectedEndOfJSON("string", cursor)
							}
						}
					}
					keyIdx++
				}
				cursor++
			}
		default:
			return cursor, nil, errNotAtBeginningOfValue(cursor)
		}
	}
KEY_END:
	cursor = skipWhiteSpace(buf, cursor)
	if buf[cursor] != ':' {
		return 0, nil, errExpected("colon after object key", cursor)
	}
	cursor++
	if cursor >= int64(len(buf)) {
		return 0, nil, errExpected("object value after colon", cursor)
	}
	return cursor, field, nil
}

func (d *structDecoder) decodeStream(s *stream, p unsafe.Pointer) error {
	s.skipWhiteSpace()
	switch s.char() {
	case 'n':
		if err := nullBytes(s); err != nil {
			return err
		}
		return nil
	case nul:
		s.read()
	default:
		if s.char() != '{' {
			return errNotAtBeginningOfValue(s.totalOffset())
		}
	}
	s.cursor++
	if s.char() == '}' {
		s.cursor++
		return nil
	}
	for {
		s.reset()
		key, err := d.keyDecoder.decodeStreamByte(s)
		if err != nil {
			return err
		}
		s.skipWhiteSpace()
		if s.char() == nul {
			s.read()
		}
		if s.char() != ':' {
			return errExpected("colon after object key", s.totalOffset())
		}
		s.cursor++
		if s.char() == nul {
			if !s.read() {
				return errExpected("object value after colon", s.totalOffset())
			}
		}
		k := *(*string)(unsafe.Pointer(&key))
		field, exists := d.fieldMap[k]
		if exists {
			if err := field.dec.decodeStream(s, unsafe.Pointer(uintptr(p)+field.offset)); err != nil {
				return err
			}
		} else if s.disallowUnknownFields {
			return fmt.Errorf("json: unknown field %q", k)
		} else {
			if err := s.skipValue(); err != nil {
				return err
			}
		}
		s.skipWhiteSpace()
		if s.char() == nul {
			s.read()
		}
		c := s.char()
		if c == '}' {
			s.cursor++
			return nil
		}
		if c != ',' {
			return errExpected("comma after object element", s.totalOffset())
		}
		s.cursor++
	}
}

func (d *structDecoder) decodeKey(buf []byte, cursor int64) (int64, *structFieldSet, error) {
	if d.isOptimizedKeyDecoder {
		return d.decodeKeyOptimized(buf, cursor)
	}
	key, c, err := d.keyDecoder.decodeByte(buf, cursor)
	if err != nil {
		return 0, nil, err
	}
	cursor = c
	cursor = skipWhiteSpace(buf, cursor)
	if buf[cursor] != ':' {
		return 0, nil, errExpected("colon after object key", cursor)
	}
	cursor++
	if cursor >= int64(len(buf)) {
		return 0, nil, errExpected("object value after colon", cursor)
	}
	k := *(*string)(unsafe.Pointer(&key))
	field, exists := d.fieldMap[k]
	if !exists {
		return cursor, nil, nil
	}
	return cursor, field, nil
}

func (d *structDecoder) decode(buf []byte, cursor int64, p unsafe.Pointer) (int64, error) {
	buflen := int64(len(buf))
	cursor = skipWhiteSpace(buf, cursor)
	switch buf[cursor] {
	case 'n':
		buflen := int64(len(buf))
		if cursor+3 >= buflen {
			return 0, errUnexpectedEndOfJSON("null", cursor)
		}
		if buf[cursor+1] != 'u' {
			return 0, errInvalidCharacter(buf[cursor+1], "null", cursor)
		}
		if buf[cursor+2] != 'l' {
			return 0, errInvalidCharacter(buf[cursor+2], "null", cursor)
		}
		if buf[cursor+3] != 'l' {
			return 0, errInvalidCharacter(buf[cursor+3], "null", cursor)
		}
		cursor += 4
		return cursor, nil
	case '{':
	default:
		return 0, errNotAtBeginningOfValue(cursor)
	}
	if buflen < 2 {
		return 0, errUnexpectedEndOfJSON("object", cursor)
	}
	cursor++
	for ; cursor < buflen; cursor++ {
		c, field, err := d.decodeKey(buf, cursor)
		if err != nil {
			return 0, err
		}
		cursor = c
		if field != nil {
			c, err := field.dec.decode(buf, cursor, unsafe.Pointer(uintptr(p)+field.offset))
			if err != nil {
				return 0, err
			}
			cursor = c
		} else {
			c, err := skipValue(buf, cursor)
			if err != nil {
				return 0, err
			}
			cursor = c
		}
		cursor = skipWhiteSpace(buf, cursor)
		if buf[cursor] == '}' {
			cursor++
			return cursor, nil
		}
		if buf[cursor] != ',' {
			return 0, errExpected("comma after object element", cursor)
		}
	}
	return cursor, nil
}