gofront 1.8.0 → 1.9.0

package/stdlib/internal/jsonrt/dec.go

@@ -51,12 +51,6 @@ func (e *InvalidUnmarshalError) Error() string {
 	return "json: Unmarshal(nil " + e.Type + ")"
 }
 
-var (
-	OptEscapeHTML            = true
-	OptUseNumber             bool
-	OptDisallowUnknownFields bool
-)
-
 // Dec is the state of one Unmarshal call. The input has been checked to be
 // valid JSON, so the readers below do not look for syntax errors.
 type Dec struct {
@@ -64,8 +58,9 @@ type Dec struct {
 	pos                   int
 	Err                   error
 	fatal                 bool
-	structs               []string
-	fields                []string
+	structs               []string // stack of struct names, depth entries live
+	fields                []string // stack of field names, depth entries live
+	depth                 int
 	key                   string
 	UseNumber             bool
 	DisallowUnknownFields bool
@@ -77,11 +72,7 @@ func NewDec(data []byte) (*Dec, error) {
 	if err := CheckValid(data); err != nil {
 		return nil, err
 	}
-	return &Dec{
-		data:                  data,
-		UseNumber:             OptUseNumber,
-		DisallowUnknownFields: OptDisallowUnknownFields,
-	}, nil
+	return &Dec{data: data}, nil
 }
 
 // UnknownField records an error when an unknown struct field is encountered with DisallowUnknownFields.
@@ -117,15 +108,21 @@ func (d *Dec) Failed() bool {
 }
 
 // Enter and Leave track the struct field being decoded for error messages.
+// The stacks keep their entries and move an index, so no slice is resliced
+// or copied per struct.
 func (d *Dec) Enter(structName, field string) {
-	d.structs = append(d.structs, structName)
-	d.fields = append(d.fields, field)
+	if d.depth < len(d.fields) {
+		d.structs[d.depth] = structName
+		d.fields[d.depth] = field
+	} else {
+		d.structs = append(d.structs, structName)
+		d.fields = append(d.fields, field)
+	}
+	d.depth++
 }
 
 func (d *Dec) Leave() {
-	n := len(d.fields) - 1
-	d.structs = d.structs[:n]
-	d.fields = d.fields[:n]
+	d.depth--
 }
 
 func (d *Dec) ws() {
@@ -169,9 +166,9 @@ func (d *Dec) typeErr(value, typ string) {
 		return
 	}
 	e := &UnmarshalTypeError{Value: value, Type: typ, Offset: int64(d.pos)}
-	if len(d.fields) > 0 {
-		e.Struct = d.structs[len(d.structs)-1]
-		e.Field = strings.Join(d.fields, ".")
+	if d.depth > 0 {
+		e.Struct = d.structs[d.depth-1]
+		e.Field = strings.Join(d.fields[:d.depth], ".")
 	}
 	d.Err = e
 }
@@ -239,12 +236,18 @@ func (d *Dec) Unquote(typ, kind string) *Dec {
 		d.Skip()
 		return nil
 	}
-	s := d.readString()
+	s := readStr(d)
 	b := []byte(s)
 	if s == "null" {
 		return nil
 	}
 	ok := len(b) > 0 && CheckValid(b) == nil
+	// A number that starts like one but is not valid fails like any other
+	// malformed number.
+	if !ok && kind == "number" && len(b) > 0 && (b[0] == '-' || (b[0] >= '0' && b[0] <= '9')) {
+		d.typeErr("number "+s, typ)
+		return nil
+	}
 	if ok {
 		c := b[0]
 		switch kind {
@@ -260,7 +263,7 @@ func (d *Dec) Unquote(typ, kind string) *Dec {
 		d.Save(errors.New("json: invalid use of ,string struct tag, trying to unmarshal " + strconv.Quote(s) + " into " + typ))
 		return nil
 	}
-	return &Dec{data: b, structs: d.structs, fields: d.fields}
+	return &Dec{data: b, structs: d.structs, fields: d.fields, depth: d.depth}
 }
 
 // Merge takes over the first error of a decoder made by Unquote.
@@ -364,7 +367,10 @@ func (d *Dec) Offset() int {
 	return d.pos
 }
 
-func (d *Dec) readNumber() string {
+// readNum consumes the number literal at the current position.
+//
+//gofront:native jsonrt.readNum
+func readNum(d *Dec) string {
 	start := d.pos
 	for d.pos < len(d.data) {
 		c := d.data[d.pos]
@@ -383,18 +389,20 @@ func (d *Dec) Number(typ string) (string, bool) {
 		return "", false
 	}
 	if d.peek() == '"' {
+		start := d.pos
 		s, ok := d.String(typ)
 		if !ok {
 			return "", false
 		}
 		if !isValidNumber(s) {
-			d.Save(fmt.Errorf("json: invalid number literal, trying to unmarshal %q into Number", s))
+			// Go quotes the whole JSON literal and stops decoding.
+			d.Fatal(fmt.Errorf("json: invalid number literal, trying to unmarshal %q into Number", string(d.data[start:d.pos])))
 			return "", false
 		}
 		return s, true
 	}
 	if d.kind() == "number" {
-		return d.readNumber(), true
+		return readNum(d), true
 	}
 	d.Mismatch(typ)
 	return "", false
@@ -432,7 +440,119 @@ func (d *Dec) String(typ string) (v string, ok bool) {
 		d.typeErr(k, typ)
 		return "", false
 	}
-	return d.readString(), true
+	return readStr(d), true
+}
+
+// plainInt consumes a decimal integer of at most 15 digits, with no fraction
+// or exponent, that fits in bits bits (and is not negative unless signed), and
+// returns it. It leaves the input alone and reports false for anything else,
+// which the caller then parses and reports from its text. The value stays in
+// an int, which is a plain number in JavaScript.
+func (d *Dec) plainInt(bits int, signed bool) (int, bool) {
+	data := d.data
+	end := len(data)
+	i := d.pos
+	neg := false
+	if i < end && data[i] == '-' {
+		if !signed {
+			return 0, false
+		}
+		neg = true
+		i++
+	}
+	start := i
+	v := 0
+	for i < end {
+		c := data[i]
+		if c < '0' || c > '9' {
+			break
+		}
+		if i-start == 15 {
+			return 0, false
+		}
+		v = v*10 + int(c-'0')
+		i++
+	}
+	if i == start {
+		return 0, false
+	}
+	if i < end {
+		if c := data[i]; c == '.' || c == 'e' || c == 'E' || c == '+' || c == '-' {
+			return 0, false
+		}
+	}
+	if neg {
+		v = -v
+	}
+	if bits < 53 {
+		lim := 1 << (bits - 1)
+		if !signed {
+			lim = 1 << bits
+			if v >= lim {
+				return 0, false
+			}
+		} else if v >= lim || v < -lim {
+			return 0, false
+		}
+	}
+	d.pos = i
+	return v, true
+}
+
+var pow10 = [...]float64{1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15}
+
+// plainFloat consumes a decimal number of at most 15 digits with no exponent.
+// Such a number is a mantissa that a float64 holds exactly divided by a power
+// of ten that it holds exactly, so one division rounds it correctly. It
+// leaves the input alone and reports false for anything else.
+func (d *Dec) plainFloat() (float64, bool) {
+	data := d.data
+	end := len(data)
+	i := d.pos
+	neg := false
+	if i < end && data[i] == '-' {
+		neg = true
+		i++
+	}
+	start := i
+	digits := 0
+	frac := 0
+	v := 0
+	seenDot := false
+	for i < end {
+		c := data[i]
+		if c == '.' && !seenDot {
+			seenDot = true
+			i++
+			continue
+		}
+		if c < '0' || c > '9' {
+			break
+		}
+		if digits == 15 {
+			return 0, false
+		}
+		v = v*10 + int(c-'0')
+		digits++
+		if seenDot {
+			frac++
+		}
+		i++
+	}
+	if digits == 0 || i-start == 0 {
+		return 0, false
+	}
+	if i < end {
+		if c := data[i]; c == 'e' || c == 'E' || c == '+' || c == '-' {
+			return 0, false
+		}
+	}
+	f := float64(v) / pow10[frac]
+	if neg {
+		f = -f
+	}
+	d.pos = i
+	return f, true
 }
 
 // Int decodes an integer that must fit in bits bits.
@@ -440,13 +560,16 @@ func (d *Dec) Int(bits int, typ string) (v int64, ok bool) {
 	if d.fatal || d.Null() {
 		return 0, false
 	}
-	if d.peek() == '"' || d.peek() == '{' || d.peek() == '[' || d.peek() == 't' || d.peek() == 'f' {
+	if c := d.peek(); c == '"' || c == '{' || c == '[' || c == 't' || c == 'f' {
 		k := d.kind()
 		d.Skip()
 		d.typeErr(k, typ)
 		return 0, false
 	}
-	s := d.readNumber()
+	if n, ok := d.plainInt(bits, true); ok {
+		return int64(n), true
+	}
+	s := readNum(d)
 	n, err := strconv.ParseInt(s, 10, bits)
 	if err != nil {
 		d.typeErr("number "+s, typ)
@@ -460,13 +583,16 @@ func (d *Dec) Uint(bits int, typ string) (v uint64, ok bool) {
 	if d.fatal || d.Null() {
 		return 0, false
 	}
-	if d.peek() == '"' || d.peek() == '{' || d.peek() == '[' || d.peek() == 't' || d.peek() == 'f' {
+	if c := d.peek(); c == '"' || c == '{' || c == '[' || c == 't' || c == 'f' {
 		k := d.kind()
 		d.Skip()
 		d.typeErr(k, typ)
 		return 0, false
 	}
-	s := d.readNumber()
+	if n, ok := d.plainInt(bits, false); ok {
+		return uint64(n), true
+	}
+	s := readNum(d)
 	n, err := strconv.ParseUint(s, 10, bits)
 	if err != nil {
 		d.typeErr("number "+s, typ)
@@ -480,13 +606,18 @@ func (d *Dec) Float(bits int, typ string) (v float64, ok bool) {
 	if d.fatal || d.Null() {
 		return 0, false
 	}
-	if d.peek() == '"' || d.peek() == '{' || d.peek() == '[' || d.peek() == 't' || d.peek() == 'f' {
+	if c := d.peek(); c == '"' || c == '{' || c == '[' || c == 't' || c == 'f' {
 		k := d.kind()
 		d.Skip()
 		d.typeErr(k, typ)
 		return 0, false
 	}
-	s := d.readNumber()
+	if bits == 64 {
+		if f, ok := d.plainFloat(); ok {
+			return f, true
+		}
+	}
+	s := readNum(d)
 	n, err := strconv.ParseFloat(s, bits)
 	if bits == 32 {
 		// Round to float32 here: the number may be out of float32 range.
@@ -530,7 +661,7 @@ func (d *Dec) NextKey() bool {
 		d.pos++
 	}
 	d.ws()
-	d.key = d.readString()
+	d.key = readStr(d)
 	d.ws()
 	d.pos++ // the colon
 	return true
@@ -577,8 +708,10 @@ func EqualFold(a, b string) bool {
 	return strings.EqualFold(a, b)
 }
 
-// readString consumes the string at the current position.
-func (d *Dec) readString() string {
+// readStr consumes the string at the current position.
+//
+//gofront:native jsonrt.readStr
+func readStr(d *Dec) string {
 	d.pos++ // opening quote
 	start := d.pos
 	plain := true
@@ -714,7 +847,7 @@ func (d *Dec) Any() any {
 		}
 		return a
 	case '"':
-		return d.readString()
+		return readStr(d)
 	case 't':
 		d.pos += 4
 		return true
@@ -725,7 +858,7 @@ func (d *Dec) Any() any {
 		d.pos += 4
 		return nil
 	}
-	s := d.readNumber()
+	s := readNum(d)
 	if d.UseNumber {
 		return Number(s)
 	}

package/stdlib/internal/jsonrt/enc.go

@@ -56,15 +56,19 @@ func (e *MarshalerError) Unwrap() error { return e.Err }
 
 // Enc is the state of one Marshal call: the output so far and the first
 // error. After an error every method does nothing.
+//
+// The output is buf[:n]; the rest of buf is room to grow into, so appending
+// a byte is an index write rather than a new slice header.
 type Enc struct {
-	B          []byte
+	buf        []byte
+	n          int
 	Err        error
 	EscapeHTML bool
 }
 
 // NewEnc returns an encoder that escapes <, > and & like json.Marshal.
 func NewEnc() *Enc {
-	return &Enc{EscapeHTML: OptEscapeHTML}
+	return &Enc{buf: make([]byte, 256), EscapeHTML: true}
 }
 
 // Result returns the encoded bytes, or the first error.
@@ -72,7 +76,114 @@ func (e *Enc) Result() ([]byte, error) {
 	if e.Err != nil {
 		return nil, e.Err
 	}
-	return e.B, nil
+	return e.buf[:e.n], nil
+}
+
+// room makes sure k more bytes fit after the output.
+func (e *Enc) room(k int) {
+	if e.n+k <= len(e.buf) {
+		return
+	}
+	nb := make([]byte, 2*len(e.buf)+k)
+	copy(nb, e.buf[:e.n])
+	e.buf = nb
+}
+
+// putBytes appends b to the output.
+func (e *Enc) putBytes(b []byte) {
+	e.room(len(b))
+	copy(e.buf[e.n:], b)
+	e.n += len(b)
+}
+
+// putString appends the bytes of s to the output.
+//
+//gofront:native jsonrt.putString
+func putString(e *Enc, s string) {
+	n := len(s)
+	e.room(n)
+	for i := 0; i < n; i++ {
+		e.buf[e.n+i] = s[i]
+	}
+	e.n += n
+}
+
+// putInt appends the decimal form of v.
+//
+//gofront:native jsonrt.putInt
+func putInt(e *Enc, v int64) {
+	if v < 0 {
+		e.Byte('-')
+		putUint(e, uint64(-v))
+		return
+	}
+	putUint(e, uint64(v))
+}
+
+// putUint appends the decimal form of v.
+//
+//gofront:native jsonrt.putUint
+func putUint(e *Enc, v uint64) {
+	n := 1
+	for t := v; t >= 10; t /= 10 {
+		n++
+	}
+	e.room(n)
+	for i := e.n + n - 1; i >= e.n; i-- {
+		e.buf[i] = byte('0' + v%10)
+		v /= 10
+	}
+	e.n += n
+}
+
+// putFloat appends a finite f in the format encoding/json uses: shortest
+// digits that read back as a float of the given size, as if by ES6 number to
+// string conversion (an exponent only below 1e-6 and from 1e21).
+//
+//gofront:native jsonrt.putFloat
+func putFloat(e *Enc, f float64, bits int) {
+	var tmp [64]byte
+	b := tmp[:0]
+	format := floatFormat(f, bits)
+	if bits == 32 {
+		f = shortest32(f)
+	}
+	b = strconv.AppendFloat(b, f, format, -1, 64)
+	if format == 'e' {
+		b = cleanExponent(b)
+	}
+	e.putBytes(b)
+}
+
+// LooksFloat32 reports whether f, found in an interface, is more likely a
+// float32 than a float64. Where a float32 and a float64 share one run-time
+// representation (JavaScript numbers) a float64 that a float32 holds exactly
+// is taken for one; elsewhere the interface tells them apart.
+//
+//gofront:native jsonrt.LooksFloat32
+func LooksFloat32(f float64) bool {
+	return false
+}
+
+// putQuoted appends s as a quoted JSON string.
+//
+//gofront:native jsonrt.putQuoted
+func putQuoted(e *Enc, s string) {
+	n := len(s)
+	for i := 0; i < n; i++ {
+		c := s[i]
+		if c < 0x20 || c >= utf8.RuneSelf || c == '"' || c == '\\' || (e.EscapeHTML && (c == '<' || c == '>' || c == '&')) {
+			e.putBytes(AppendString(nil, []byte(s), e.EscapeHTML))
+			return
+		}
+	}
+	e.room(n + 2)
+	e.buf[e.n] = '"'
+	for i := 0; i < n; i++ {
+		e.buf[e.n+1+i] = s[i]
+	}
+	e.buf[e.n+n+1] = '"'
+	e.n += n + 2
 }
 
 // Fail records the first error.
@@ -87,19 +198,51 @@ func (e *Enc) FailType(typ string) {
 	e.Fail(&UnsupportedTypeError{typ})
 }
 
+// encoders are the dynamic encoders every package with generated codecs
+// registers at start-up: each encodes the values of its own package's types
+// and reports whether it knew the value.
+type encoderList struct {
+	fns []func(*Enc, any) bool
+}
+
+var encoders = &encoderList{}
+
+// RegisterEncoder adds a package's dynamic encoder. Each target fills its own
+// list from the package initializers it runs, so the list is built through a local.
+func RegisterEncoder(f func(*Enc, any) bool) bool {
+	list := encoders
+	list.fns = append(list.fns, f)
+	return true
+}
+
+// EncodeDynamic encodes v with the first registered encoder that knows its
+// type, and fails the encoding when none does.
+func (e *Enc) EncodeDynamic(v any) {
+	for _, f := range encoders.fns {
+		if f(e, v) {
+			return
+		}
+	}
+	e.FailType("unsupported dynamic type")
+}
+
 // Lit appends s, which is already valid JSON text.
 func (e *Enc) Lit(s string) {
-	e.B = appendStr(e.B, s)
+	putString(e, s)
 }
 
 // Byte appends one byte of JSON punctuation.
 func (e *Enc) Byte(c byte) {
-	e.B = append(e.B, c)
+	if e.n == len(e.buf) {
+		e.room(1)
+	}
+	e.buf[e.n] = c
+	e.n++
 }
 
 // Null appends null.
 func (e *Enc) Null() {
-	e.B = appendStr(e.B, "null")
+	putString(e, "null")
 }
 
 // Number appends the literal representation of a Number.
@@ -108,14 +251,14 @@ func (e *Enc) Number(v string) {
 		return
 	}
 	if v == "" {
-		e.B = append(e.B, '0')
+		e.Byte('0')
 		return
 	}
 	if !isValidNumber(v) {
 		e.Fail(fmt.Errorf("json: invalid number literal %q", v))
 		return
 	}
-	e.B = appendStr(e.B, v)
+	putString(e, v)
 }
 
 func isValidNumber(s string) bool {
@@ -132,20 +275,20 @@ func isValidNumber(s string) bool {
 // Bool appends true or false.
 func (e *Enc) Bool(v bool) {
 	if v {
-		e.B = appendStr(e.B, "true")
+		putString(e, "true")
 	} else {
-		e.B = appendStr(e.B, "false")
+		putString(e, "false")
 	}
 }
 
 // Int appends a signed integer.
 func (e *Enc) Int(v int64) {
-	e.B = strconv.AppendInt(e.B, v, 10)
+	putInt(e, v)
 }
 
 // Uint appends an unsigned integer.
 func (e *Enc) Uint(v uint64) {
-	e.B = strconv.AppendUint(e.B, v, 10)
+	putUint(e, v)
 }
 
 // Float appends a floating-point number in the format encoding/json uses.
@@ -158,21 +301,14 @@ func (e *Enc) Float(f float64, bits int) {
 		return
 	}
 	if f == 0 && math.Signbit(f) {
-		e.B = append(e.B, "-0"...)
+		putString(e, "-0")
 		return
 	}
-	format := floatFormat(f, bits)
-	if bits == 32 {
-		f = shortest32(f)
-	}
-	e.B = strconv.AppendFloat(e.B, f, format, -1, 64)
-	if format == 'e' {
-		e.B = cleanExponent(e.B)
-	}
+	putFloat(e, f, bits)
 }
 
 // floatFormat picks 'e' or 'f' as if by ES6 number to string conversion.
-func floatFormat(f float64, bits int) int {
+func floatFormat(f float64, bits int) byte {
 	abs := math.Abs(f)
 	if abs == 0 {
 		return 'f'
@@ -210,34 +346,35 @@ func shortest32(f float64) float64 {
 
 // Str appends a quoted, escaped string.
 func (e *Enc) Str(s string) {
-	e.B = AppendString(e.B, []byte(s), e.EscapeHTML)
+	putQuoted(e, s)
 }
 
 // QStr appends a string for the ,string tag option: the quoted form of the
 // quoted form.
 func (e *Enc) QStr(s string) {
 	inner := AppendString(nil, []byte(s), e.EscapeHTML)
-	e.B = AppendString(e.B, inner, false)
+	e.putBytes(AppendString(nil, inner, false))
 }
 
 // Key appends the separator for member n of an object (a comma when n > 0)
 // and the member name, a plain name that needs no escaping.
 func (e *Enc) Key(n int, name string) {
 	if n > 0 {
-		e.B = append(e.B, ',')
+		e.Byte(',')
 	}
-	e.B = append(e.B, '"')
-	e.B = appendStr(e.B, name)
-	e.B = append(e.B, '"', ':')
+	e.Byte('"')
+	putString(e, name)
+	e.Byte('"')
+	e.Byte(':')
 }
 
 // KeyStr is Key for a member name that may need escaping.
 func (e *Enc) KeyStr(n int, name string) {
 	if n > 0 {
-		e.B = append(e.B, ',')
+		e.Byte(',')
 	}
-	e.B = AppendString(e.B, []byte(name), e.EscapeHTML)
-	e.B = append(e.B, ':')
+	putQuoted(e, name)
+	e.Byte(':')
 }
 
 // Bytes appends a []byte as a base64 string, or null for a nil slice.
@@ -246,9 +383,9 @@ func (e *Enc) Bytes(v []byte) {
 		e.Null()
 		return
 	}
-	e.B = append(e.B, '"')
-	e.B = appendStr(e.B, base64.StdEncoding.EncodeToString(v))
-	e.B = append(e.B, '"')
+	e.Byte('"')
+	putString(e, base64.StdEncoding.EncodeToString(v))
+	e.Byte('"')
 }
 
 // Raw appends a json.RawMessage: validated and compacted, null when empty.
@@ -268,15 +405,28 @@ func (e *Enc) Marshaled(out []byte, err error, typ string) {
 	}
 	if err == nil {
 		var b []byte
-		b, err = AppendCompact(e.B, out, e.EscapeHTML)
+		b, err = AppendCompact(nil, out, e.EscapeHTML)
 		if err == nil {
-			e.B = b
+			e.putBytes(b)
 			return
 		}
 	}
 	e.Fail(&MarshalerError{typ, err, "MarshalJSON"})
 }
 
+// TextMarshaled appends the result of a MarshalText call as a JSON string, or
+// the call's error wrapped like Go does.
+func (e *Enc) TextMarshaled(out []byte, err error, typ string) {
+	if e.Err != nil {
+		return
+	}
+	if err != nil {
+		e.Fail(&MarshalerError{typ, err, "MarshalText"})
+		return
+	}
+	e.Str(string(out))
+}
+
 // SortStrings sorts map keys.
 func SortStrings(a []string) {
 	sort.Strings(a)