Fix skipWhiteSpace for stream decoder

internal/decoder/array.go

@@ -58,8 +58,7 @@ func (d *arrayDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) er
 					}
 				}
 				idx++
-				s.skipWhiteSpace()
+				switch s.skipWhiteSpace() {
-				switch s.char() {
 				case ']':
 					for idx < d.alen {
 						*(*unsafe.Pointer)(unsafe.Pointer(uintptr(p) + uintptr(idx)*d.size)) = d.zeroValue

internal/decoder/bool.go

@@ -16,9 +16,9 @@ func newBoolDecoder(structName, fieldName string) *boolDecoder {
 }
 
 func (d *boolDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
-	s.skipWhiteSpace()
+	c := s.skipWhiteSpace()
 	for {
-		switch s.char() {
+		switch c {
 		case 't':
 			if err := trueBytes(s); err != nil {
 				return err
@@ -38,6 +38,7 @@ func (d *boolDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) err
 			return nil
 		case nul:
 			if s.read() {
+				c = s.char()
 				continue
 			}
 			goto ERROR

internal/decoder/interface.go

@@ -176,9 +176,9 @@ func decodeTextUnmarshaler(buf []byte, cursor, depth int64, unmarshaler encoding
 }
 
 func (d *interfaceDecoder) decodeStreamEmptyInterface(s *Stream, depth int64, p unsafe.Pointer) error {
-	s.skipWhiteSpace()
+	c := s.skipWhiteSpace()
 	for {
-		switch s.char() {
+		switch c {
 		case '{':
 			var v map[string]interface{}
 			ptr := unsafe.Pointer(&v)
@@ -239,6 +239,7 @@ func (d *interfaceDecoder) decodeStreamEmptyInterface(s *Stream, depth int64, p
 			return nil
 		case nul:
 			if s.read() {
+				c = s.char()
 				continue
 			}
 		}
@@ -265,8 +266,7 @@ func (d *interfaceDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer
 		if u, ok := rv.Interface().(encoding.TextUnmarshaler); ok {
 			return decodeStreamTextUnmarshaler(s, depth, u, p)
 		}
-		s.skipWhiteSpace()
+		if s.skipWhiteSpace() == 'n' {
-		if s.char() == 'n' {
 			if err := nullBytes(s); err != nil {
 				return err
 			}
@@ -285,8 +285,7 @@ func (d *interfaceDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer
 	if typ.Kind() == reflect.Ptr && typ.Elem() == d.typ || typ.Kind() != reflect.Ptr {
 		return d.decodeStreamEmptyInterface(s, depth, p)
 	}
-	s.skipWhiteSpace()
+	if s.skipWhiteSpace() == 'n' {
-	if s.char() == 'n' {
 		if err := nullBytes(s); err != nil {
 			return err
 		}

internal/decoder/map.go

@@ -42,8 +42,7 @@ func (d *mapDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) erro
 		return errors.ErrExceededMaxDepth(s.char(), s.cursor)
 	}
 
-	s.skipWhiteSpace()
+	switch s.skipWhiteSpace() {
-	switch s.char() {
 	case 'n':
 		if err := nullBytes(s); err != nil {
 			return err
@@ -54,7 +53,6 @@ func (d *mapDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) erro
 	default:
 		return errors.ErrExpected("{ character for map value", s.totalOffset())
 	}
-	s.skipWhiteSpace()
 	mapValue := *(*unsafe.Pointer)(p)
 	if mapValue == nil {
 		mapValue = makemap(d.mapType, 0)

internal/decoder/ptr.go

@@ -35,8 +35,7 @@ func (d *ptrDecoder) contentDecoder() Decoder {
 func unsafe_New(*runtime.Type) unsafe.Pointer
 
 func (d *ptrDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
-	s.skipWhiteSpace()
+	if s.skipWhiteSpace() == nul {
-	if s.char() == nul {
 		s.read()
 	}
 	if s.char() == 'n' {

internal/decoder/slice.go

@@ -111,8 +111,7 @@ func (d *sliceDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) er
 			return nil
 		case '[':
 			s.cursor++
-			s.skipWhiteSpace()
+			if s.skipWhiteSpace() == ']' {
-			if s.char() == ']' {
 				dst := (*sliceHeader)(p)
 				if dst.data == nil {
 					dst.data = newArray(d.elemType, 0)

internal/decoder/stream.go

@@ -90,6 +90,10 @@ func (s *Stream) stat() ([]byte, int64, unsafe.Pointer) {
 	return s.buf, s.cursor, (*sliceHeader)(unsafe.Pointer(&s.buf)).data
 }
 
+func (s *Stream) bufptr() unsafe.Pointer {
+	return (*sliceHeader)(unsafe.Pointer(&s.buf)).data
+}
+
 func (s *Stream) statForRetry() ([]byte, int64, unsafe.Pointer) {
 	s.cursor-- // for retry ( because caller progress cursor position in each loop )
 	return s.buf, s.cursor, (*sliceHeader)(unsafe.Pointer(&s.buf)).data
@@ -219,17 +223,21 @@ func (s *Stream) read() bool {
 	return true
 }
 
-func (s *Stream) skipWhiteSpace() {
+func (s *Stream) skipWhiteSpace() byte {
+	p := s.bufptr()
 LOOP:
-	switch s.char() {
+	c := char(p, s.cursor)
+	switch c {
 	case ' ', '\n', '\t', '\r':
 		s.cursor++
 		goto LOOP
 	case nul:
 		if s.read() {
+			p = s.bufptr()
 			goto LOOP
 		}
 	}
+	return c
 }
 
 func (s *Stream) skipObject(depth int64) error {

internal/decoder/struct.go

@@ -627,23 +627,20 @@ func (d *structDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) e
 		return errors.ErrExceededMaxDepth(s.char(), s.cursor)
 	}
 
-	s.skipWhiteSpace()
+	c := s.skipWhiteSpace()
-	switch s.char() {
+	switch c {
 	case 'n':
 		if err := nullBytes(s); err != nil {
 			return err
 		}
 		return nil
-	case nul:
-		s.read()
 	default:
 		if s.char() != '{' {
 			return errors.ErrNotAtBeginningOfValue(s.totalOffset())
 		}
 	}
 	s.cursor++
-	s.skipWhiteSpace()
+	if s.skipWhiteSpace() == '}' {
-	if s.char() == '}' {
 		s.cursor++
 		return nil
 	}
@@ -653,16 +650,10 @@ func (d *structDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) e
 		if err != nil {
 			return err
 		}
-		s.skipWhiteSpace()
+		if s.skipWhiteSpace() != ':' {
-		if s.char() != ':' {
 			return errors.ErrExpected("colon after object key", s.totalOffset())
 		}
 		s.cursor++
-		if s.char() == nul {
-			if !s.read() {
-				return errors.ErrExpected("object value after colon", s.totalOffset())
-			}
-		}
 		if field != nil {
 			if field.err != nil {
 				return field.err
@@ -677,8 +668,7 @@ func (d *structDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) e
 				return err
 			}
 		}
-		s.skipWhiteSpace()
+		c := s.skipWhiteSpace()
-		c := s.char()
 		if c == '}' {
 			s.cursor++
 			return nil