| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908 |
- // Copyright 2020 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 json
- import (
- "bytes"
- "cmp"
- "encoding"
- "encoding/base32"
- "encoding/base64"
- "encoding/hex"
- "errors"
- "fmt"
- "math"
- "reflect"
- "slices"
- "strconv"
- "strings"
- "sync"
- "github.com/go-json-experiment/json/internal"
- "github.com/go-json-experiment/json/internal/jsonflags"
- "github.com/go-json-experiment/json/internal/jsonopts"
- "github.com/go-json-experiment/json/internal/jsonwire"
- "github.com/go-json-experiment/json/jsontext"
- )
- // optimizeCommon specifies whether to use optimizations targeted for certain
- // common patterns, rather than using the slower, but more general logic.
- // All tests should pass regardless of whether this is true or not.
- const optimizeCommon = true
- var (
- // Most natural Go type that correspond with each JSON type.
- anyType = reflect.TypeFor[any]() // JSON value
- boolType = reflect.TypeFor[bool]() // JSON bool
- stringType = reflect.TypeFor[string]() // JSON string
- float64Type = reflect.TypeFor[float64]() // JSON number
- mapStringAnyType = reflect.TypeFor[map[string]any]() // JSON object
- sliceAnyType = reflect.TypeFor[[]any]() // JSON array
- bytesType = reflect.TypeFor[[]byte]()
- emptyStructType = reflect.TypeFor[struct{}]()
- )
- const startDetectingCyclesAfter = 1000
- type seenPointers = map[any]struct{}
- type typedPointer struct {
- typ reflect.Type
- ptr any // always stores unsafe.Pointer, but avoids depending on unsafe
- len int // remember slice length to avoid false positives
- }
- // visitPointer visits pointer p of type t, reporting an error if seen before.
- // If successfully visited, then the caller must eventually call leave.
- func visitPointer(m *seenPointers, v reflect.Value) error {
- p := typedPointer{v.Type(), v.UnsafePointer(), sliceLen(v)}
- if _, ok := (*m)[p]; ok {
- return internal.ErrCycle
- }
- if *m == nil {
- *m = make(seenPointers)
- }
- (*m)[p] = struct{}{}
- return nil
- }
- func leavePointer(m *seenPointers, v reflect.Value) {
- p := typedPointer{v.Type(), v.UnsafePointer(), sliceLen(v)}
- delete(*m, p)
- }
- func sliceLen(v reflect.Value) int {
- if v.Kind() == reflect.Slice {
- return v.Len()
- }
- return 0
- }
- func len64[Bytes ~[]byte | ~string](in Bytes) int64 {
- return int64(len(in))
- }
- func makeDefaultArshaler(t reflect.Type) *arshaler {
- switch t.Kind() {
- case reflect.Bool:
- return makeBoolArshaler(t)
- case reflect.String:
- return makeStringArshaler(t)
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- return makeIntArshaler(t)
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- return makeUintArshaler(t)
- case reflect.Float32, reflect.Float64:
- return makeFloatArshaler(t)
- case reflect.Map:
- return makeMapArshaler(t)
- case reflect.Struct:
- return makeStructArshaler(t)
- case reflect.Slice:
- fncs := makeSliceArshaler(t)
- if t.Elem().Kind() == reflect.Uint8 {
- return makeBytesArshaler(t, fncs)
- }
- return fncs
- case reflect.Array:
- fncs := makeArrayArshaler(t)
- if t.Elem().Kind() == reflect.Uint8 {
- return makeBytesArshaler(t, fncs)
- }
- return fncs
- case reflect.Pointer:
- return makePointerArshaler(t)
- case reflect.Interface:
- return makeInterfaceArshaler(t)
- default:
- return makeInvalidArshaler(t)
- }
- }
- func makeBoolArshaler(t reflect.Type) *arshaler {
- var fncs arshaler
- fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
- xe := export.Encoder(enc)
- if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
- return newInvalidFormatError(enc, t, mo)
- }
- // Optimize for marshaling without preceding whitespace.
- if optimizeCommon && !mo.Flags.Get(jsonflags.AnyWhitespace|jsonflags.StringifyBoolsAndStrings) && !xe.Tokens.Last.NeedObjectName() {
- xe.Buf = strconv.AppendBool(xe.Tokens.MayAppendDelim(xe.Buf, 't'), va.Bool())
- xe.Tokens.Last.Increment()
- if xe.NeedFlush() {
- return xe.Flush()
- }
- return nil
- }
- if mo.Flags.Get(jsonflags.StringifyBoolsAndStrings) {
- if va.Bool() {
- return enc.WriteToken(jsontext.String("true"))
- } else {
- return enc.WriteToken(jsontext.String("false"))
- }
- }
- return enc.WriteToken(jsontext.Bool(va.Bool()))
- }
- fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
- xd := export.Decoder(dec)
- if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
- return newInvalidFormatError(dec, t, uo)
- }
- tok, err := dec.ReadToken()
- if err != nil {
- return err
- }
- k := tok.Kind()
- switch k {
- case 'n':
- if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
- va.SetBool(false)
- }
- return nil
- case 't', 'f':
- if !uo.Flags.Get(jsonflags.StringifyBoolsAndStrings) {
- va.SetBool(tok.Bool())
- return nil
- }
- case '"':
- if uo.Flags.Get(jsonflags.StringifyBoolsAndStrings) {
- switch tok.String() {
- case "true":
- va.SetBool(true)
- case "false":
- va.SetBool(false)
- default:
- if uo.Flags.Get(jsonflags.StringifyWithLegacySemantics) && tok.String() == "null" {
- if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
- va.SetBool(false)
- }
- return nil
- }
- return newUnmarshalErrorAfterWithValue(dec, t, strconv.ErrSyntax)
- }
- return nil
- }
- }
- return newUnmarshalErrorAfterWithSkipping(dec, uo, t, nil)
- }
- return &fncs
- }
- func makeStringArshaler(t reflect.Type) *arshaler {
- var fncs arshaler
- fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
- xe := export.Encoder(enc)
- if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
- return newInvalidFormatError(enc, t, mo)
- }
- // Optimize for marshaling without preceding whitespace.
- s := va.String()
- if optimizeCommon && !mo.Flags.Get(jsonflags.AnyWhitespace|jsonflags.StringifyBoolsAndStrings) && !xe.Tokens.Last.NeedObjectName() {
- b := xe.Buf
- b = xe.Tokens.MayAppendDelim(b, '"')
- b, err := jsonwire.AppendQuote(b, s, &mo.Flags)
- if err == nil {
- xe.Buf = b
- xe.Tokens.Last.Increment()
- if xe.NeedFlush() {
- return xe.Flush()
- }
- return nil
- }
- // Otherwise, the string contains invalid UTF-8,
- // so let the logic below construct the proper error.
- }
- if mo.Flags.Get(jsonflags.StringifyBoolsAndStrings) {
- b, err := jsonwire.AppendQuote(nil, s, &mo.Flags)
- if err != nil {
- return newMarshalErrorBefore(enc, t, &jsontext.SyntacticError{Err: err})
- }
- q, err := jsontext.AppendQuote(nil, b)
- if err != nil {
- panic("BUG: second AppendQuote should never fail: " + err.Error())
- }
- return enc.WriteValue(q)
- }
- return enc.WriteToken(jsontext.String(s))
- }
- fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
- xd := export.Decoder(dec)
- if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
- return newInvalidFormatError(dec, t, uo)
- }
- var flags jsonwire.ValueFlags
- val, err := xd.ReadValue(&flags)
- if err != nil {
- return err
- }
- k := val.Kind()
- switch k {
- case 'n':
- if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
- va.SetString("")
- }
- return nil
- case '"':
- val = jsonwire.UnquoteMayCopy(val, flags.IsVerbatim())
- if uo.Flags.Get(jsonflags.StringifyBoolsAndStrings) {
- val, err = jsontext.AppendUnquote(nil, val)
- if err != nil {
- return newUnmarshalErrorAfter(dec, t, err)
- }
- if uo.Flags.Get(jsonflags.StringifyWithLegacySemantics) && string(val) == "null" {
- if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
- va.SetString("")
- }
- return nil
- }
- }
- if xd.StringCache == nil {
- xd.StringCache = new(stringCache)
- }
- str := makeString(xd.StringCache, val)
- va.SetString(str)
- return nil
- }
- return newUnmarshalErrorAfter(dec, t, nil)
- }
- return &fncs
- }
- var (
- appendEncodeBase16 = hex.AppendEncode
- appendEncodeBase32 = base32.StdEncoding.AppendEncode
- appendEncodeBase32Hex = base32.HexEncoding.AppendEncode
- appendEncodeBase64 = base64.StdEncoding.AppendEncode
- appendEncodeBase64URL = base64.URLEncoding.AppendEncode
- encodedLenBase16 = hex.EncodedLen
- encodedLenBase32 = base32.StdEncoding.EncodedLen
- encodedLenBase32Hex = base32.HexEncoding.EncodedLen
- encodedLenBase64 = base64.StdEncoding.EncodedLen
- encodedLenBase64URL = base64.URLEncoding.EncodedLen
- appendDecodeBase16 = hex.AppendDecode
- appendDecodeBase32 = base32.StdEncoding.AppendDecode
- appendDecodeBase32Hex = base32.HexEncoding.AppendDecode
- appendDecodeBase64 = base64.StdEncoding.AppendDecode
- appendDecodeBase64URL = base64.URLEncoding.AppendDecode
- )
- func makeBytesArshaler(t reflect.Type, fncs *arshaler) *arshaler {
- // NOTE: This handles both []~byte and [N]~byte.
- // The v2 default is to treat a []namedByte as equivalent to []T
- // since being able to convert []namedByte to []byte relies on
- // dubious Go reflection behavior (see https://go.dev/issue/24746).
- // For v1 emulation, we use jsonflags.FormatBytesWithLegacySemantics
- // to forcibly treat []namedByte as a []byte.
- marshalArray := fncs.marshal
- isNamedByte := t.Elem().PkgPath() != ""
- hasMarshaler := implementsAny(t.Elem(), allMarshalerTypes...)
- fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
- if !mo.Flags.Get(jsonflags.FormatBytesWithLegacySemantics) && isNamedByte {
- return marshalArray(enc, va, mo) // treat as []T or [N]T
- }
- xe := export.Encoder(enc)
- appendEncode := appendEncodeBase64
- if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
- switch mo.Format {
- case "base64":
- appendEncode = appendEncodeBase64
- case "base64url":
- appendEncode = appendEncodeBase64URL
- case "base32":
- appendEncode = appendEncodeBase32
- case "base32hex":
- appendEncode = appendEncodeBase32Hex
- case "base16", "hex":
- appendEncode = appendEncodeBase16
- case "array":
- mo.Format = ""
- return marshalArray(enc, va, mo)
- default:
- return newInvalidFormatError(enc, t, mo)
- }
- } else if mo.Flags.Get(jsonflags.FormatBytesWithLegacySemantics) &&
- (va.Kind() == reflect.Array || hasMarshaler) {
- return marshalArray(enc, va, mo)
- }
- if mo.Flags.Get(jsonflags.FormatNilSliceAsNull) && va.Kind() == reflect.Slice && va.IsNil() {
- // TODO: Provide a "emitempty" format override?
- return enc.WriteToken(jsontext.Null)
- }
- return xe.AppendRaw('"', true, func(b []byte) ([]byte, error) {
- return appendEncode(b, va.Bytes()), nil
- })
- }
- unmarshalArray := fncs.unmarshal
- fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
- if !uo.Flags.Get(jsonflags.FormatBytesWithLegacySemantics) && isNamedByte {
- return unmarshalArray(dec, va, uo) // treat as []T or [N]T
- }
- xd := export.Decoder(dec)
- appendDecode, encodedLen := appendDecodeBase64, encodedLenBase64
- if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
- switch uo.Format {
- case "base64":
- appendDecode, encodedLen = appendDecodeBase64, encodedLenBase64
- case "base64url":
- appendDecode, encodedLen = appendDecodeBase64URL, encodedLenBase64URL
- case "base32":
- appendDecode, encodedLen = appendDecodeBase32, encodedLenBase32
- case "base32hex":
- appendDecode, encodedLen = appendDecodeBase32Hex, encodedLenBase32Hex
- case "base16", "hex":
- appendDecode, encodedLen = appendDecodeBase16, encodedLenBase16
- case "array":
- uo.Format = ""
- return unmarshalArray(dec, va, uo)
- default:
- return newInvalidFormatError(dec, t, uo)
- }
- } else if uo.Flags.Get(jsonflags.FormatBytesWithLegacySemantics) &&
- (va.Kind() == reflect.Array || dec.PeekKind() == '[') {
- return unmarshalArray(dec, va, uo)
- }
- var flags jsonwire.ValueFlags
- val, err := xd.ReadValue(&flags)
- if err != nil {
- return err
- }
- k := val.Kind()
- switch k {
- case 'n':
- if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) || va.Kind() != reflect.Array {
- va.SetZero()
- }
- return nil
- case '"':
- // NOTE: The v2 default is to strictly comply with RFC 4648.
- // Section 3.2 specifies that padding is required.
- // Section 3.3 specifies that non-alphabet characters
- // (e.g., '\r' or '\n') must be rejected.
- // Section 3.5 specifies that unnecessary non-zero bits in
- // the last quantum may be rejected. Since this is optional,
- // we do not reject such inputs.
- val = jsonwire.UnquoteMayCopy(val, flags.IsVerbatim())
- b, err := appendDecode(va.Bytes()[:0], val)
- if err != nil {
- return newUnmarshalErrorAfter(dec, t, err)
- }
- if len(val) != encodedLen(len(b)) && !uo.Flags.Get(jsonflags.FormatBytesWithLegacySemantics) {
- // TODO(https://go.dev/issue/53845): RFC 4648, section 3.3,
- // specifies that non-alphabet characters must be rejected.
- // Unfortunately, the "base32" and "base64" packages allow
- // '\r' and '\n' characters by default.
- i := bytes.IndexAny(val, "\r\n")
- err := fmt.Errorf("illegal character %s at offset %d", jsonwire.QuoteRune(val[i:]), i)
- return newUnmarshalErrorAfter(dec, t, err)
- }
- if va.Kind() == reflect.Array {
- dst := va.Bytes()
- clear(dst[copy(dst, b):]) // noop if len(b) <= len(dst)
- if len(b) != len(dst) && !uo.Flags.Get(jsonflags.UnmarshalArrayFromAnyLength) {
- err := fmt.Errorf("decoded length of %d mismatches array length of %d", len(b), len(dst))
- return newUnmarshalErrorAfter(dec, t, err)
- }
- } else {
- if b == nil {
- b = []byte{}
- }
- va.SetBytes(b)
- }
- return nil
- }
- return newUnmarshalErrorAfter(dec, t, nil)
- }
- return fncs
- }
- func makeIntArshaler(t reflect.Type) *arshaler {
- var fncs arshaler
- bits := t.Bits()
- fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
- xe := export.Encoder(enc)
- if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
- return newInvalidFormatError(enc, t, mo)
- }
- // Optimize for marshaling without preceding whitespace or string escaping.
- if optimizeCommon && !mo.Flags.Get(jsonflags.AnyWhitespace|jsonflags.StringifyNumbers) && !xe.Tokens.Last.NeedObjectName() {
- xe.Buf = strconv.AppendInt(xe.Tokens.MayAppendDelim(xe.Buf, '0'), va.Int(), 10)
- xe.Tokens.Last.Increment()
- if xe.NeedFlush() {
- return xe.Flush()
- }
- return nil
- }
- k := stringOrNumberKind(xe.Tokens.Last.NeedObjectName() || mo.Flags.Get(jsonflags.StringifyNumbers))
- return xe.AppendRaw(k, true, func(b []byte) ([]byte, error) {
- return strconv.AppendInt(b, va.Int(), 10), nil
- })
- }
- fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
- xd := export.Decoder(dec)
- if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
- return newInvalidFormatError(dec, t, uo)
- }
- stringify := xd.Tokens.Last.NeedObjectName() || uo.Flags.Get(jsonflags.StringifyNumbers)
- var flags jsonwire.ValueFlags
- val, err := xd.ReadValue(&flags)
- if err != nil {
- return err
- }
- k := val.Kind()
- switch k {
- case 'n':
- if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
- va.SetInt(0)
- }
- return nil
- case '"':
- if !stringify {
- break
- }
- val = jsonwire.UnquoteMayCopy(val, flags.IsVerbatim())
- if uo.Flags.Get(jsonflags.StringifyWithLegacySemantics) && string(val) == "null" {
- if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
- va.SetInt(0)
- }
- return nil
- }
- fallthrough
- case '0':
- if stringify && k == '0' {
- break
- }
- var negOffset int
- neg := len(val) > 0 && val[0] == '-'
- if neg {
- negOffset = 1
- }
- n, ok := jsonwire.ParseUint(val[negOffset:])
- maxInt := uint64(1) << (bits - 1)
- overflow := (neg && n > maxInt) || (!neg && n > maxInt-1)
- if !ok {
- if n != math.MaxUint64 {
- return newUnmarshalErrorAfterWithValue(dec, t, strconv.ErrSyntax)
- }
- overflow = true
- }
- if overflow {
- return newUnmarshalErrorAfterWithValue(dec, t, strconv.ErrRange)
- }
- if neg {
- va.SetInt(int64(-n))
- } else {
- va.SetInt(int64(+n))
- }
- return nil
- }
- return newUnmarshalErrorAfter(dec, t, nil)
- }
- return &fncs
- }
- func makeUintArshaler(t reflect.Type) *arshaler {
- var fncs arshaler
- bits := t.Bits()
- fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
- xe := export.Encoder(enc)
- if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
- return newInvalidFormatError(enc, t, mo)
- }
- // Optimize for marshaling without preceding whitespace or string escaping.
- if optimizeCommon && !mo.Flags.Get(jsonflags.AnyWhitespace|jsonflags.StringifyNumbers) && !xe.Tokens.Last.NeedObjectName() {
- xe.Buf = strconv.AppendUint(xe.Tokens.MayAppendDelim(xe.Buf, '0'), va.Uint(), 10)
- xe.Tokens.Last.Increment()
- if xe.NeedFlush() {
- return xe.Flush()
- }
- return nil
- }
- k := stringOrNumberKind(xe.Tokens.Last.NeedObjectName() || mo.Flags.Get(jsonflags.StringifyNumbers))
- return xe.AppendRaw(k, true, func(b []byte) ([]byte, error) {
- return strconv.AppendUint(b, va.Uint(), 10), nil
- })
- }
- fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
- xd := export.Decoder(dec)
- if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
- return newInvalidFormatError(dec, t, uo)
- }
- stringify := xd.Tokens.Last.NeedObjectName() || uo.Flags.Get(jsonflags.StringifyNumbers)
- var flags jsonwire.ValueFlags
- val, err := xd.ReadValue(&flags)
- if err != nil {
- return err
- }
- k := val.Kind()
- switch k {
- case 'n':
- if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
- va.SetUint(0)
- }
- return nil
- case '"':
- if !stringify {
- break
- }
- val = jsonwire.UnquoteMayCopy(val, flags.IsVerbatim())
- if uo.Flags.Get(jsonflags.StringifyWithLegacySemantics) && string(val) == "null" {
- if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
- va.SetUint(0)
- }
- return nil
- }
- fallthrough
- case '0':
- if stringify && k == '0' {
- break
- }
- n, ok := jsonwire.ParseUint(val)
- maxUint := uint64(1) << bits
- overflow := n > maxUint-1
- if !ok {
- if n != math.MaxUint64 {
- return newUnmarshalErrorAfterWithValue(dec, t, strconv.ErrSyntax)
- }
- overflow = true
- }
- if overflow {
- return newUnmarshalErrorAfterWithValue(dec, t, strconv.ErrRange)
- }
- va.SetUint(n)
- return nil
- }
- return newUnmarshalErrorAfter(dec, t, nil)
- }
- return &fncs
- }
- func makeFloatArshaler(t reflect.Type) *arshaler {
- var fncs arshaler
- bits := t.Bits()
- fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
- xe := export.Encoder(enc)
- var allowNonFinite bool
- if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
- if mo.Format == "nonfinite" {
- allowNonFinite = true
- } else {
- return newInvalidFormatError(enc, t, mo)
- }
- }
- fv := va.Float()
- if math.IsNaN(fv) || math.IsInf(fv, 0) {
- if !allowNonFinite {
- err := fmt.Errorf("unsupported value: %v", fv)
- return newMarshalErrorBefore(enc, t, err)
- }
- return enc.WriteToken(jsontext.Float(fv))
- }
- // Optimize for marshaling without preceding whitespace or string escaping.
- if optimizeCommon && !mo.Flags.Get(jsonflags.AnyWhitespace|jsonflags.StringifyNumbers) && !xe.Tokens.Last.NeedObjectName() {
- xe.Buf = jsonwire.AppendFloat(xe.Tokens.MayAppendDelim(xe.Buf, '0'), fv, bits)
- xe.Tokens.Last.Increment()
- if xe.NeedFlush() {
- return xe.Flush()
- }
- return nil
- }
- k := stringOrNumberKind(xe.Tokens.Last.NeedObjectName() || mo.Flags.Get(jsonflags.StringifyNumbers))
- return xe.AppendRaw(k, true, func(b []byte) ([]byte, error) {
- return jsonwire.AppendFloat(b, va.Float(), bits), nil
- })
- }
- fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
- xd := export.Decoder(dec)
- var allowNonFinite bool
- if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
- if uo.Format == "nonfinite" {
- allowNonFinite = true
- } else {
- return newInvalidFormatError(dec, t, uo)
- }
- }
- stringify := xd.Tokens.Last.NeedObjectName() || uo.Flags.Get(jsonflags.StringifyNumbers)
- var flags jsonwire.ValueFlags
- val, err := xd.ReadValue(&flags)
- if err != nil {
- return err
- }
- k := val.Kind()
- switch k {
- case 'n':
- if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
- va.SetFloat(0)
- }
- return nil
- case '"':
- val = jsonwire.UnquoteMayCopy(val, flags.IsVerbatim())
- if allowNonFinite {
- switch string(val) {
- case "NaN":
- va.SetFloat(math.NaN())
- return nil
- case "Infinity":
- va.SetFloat(math.Inf(+1))
- return nil
- case "-Infinity":
- va.SetFloat(math.Inf(-1))
- return nil
- }
- }
- if !stringify {
- break
- }
- if uo.Flags.Get(jsonflags.StringifyWithLegacySemantics) && string(val) == "null" {
- if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
- va.SetFloat(0)
- }
- return nil
- }
- if n, err := jsonwire.ConsumeNumber(val); n != len(val) || err != nil {
- return newUnmarshalErrorAfterWithValue(dec, t, strconv.ErrSyntax)
- }
- fallthrough
- case '0':
- if stringify && k == '0' {
- break
- }
- fv, ok := jsonwire.ParseFloat(val, bits)
- va.SetFloat(fv)
- if !ok {
- return newUnmarshalErrorAfterWithValue(dec, t, strconv.ErrRange)
- }
- return nil
- }
- return newUnmarshalErrorAfter(dec, t, nil)
- }
- return &fncs
- }
- func makeMapArshaler(t reflect.Type) *arshaler {
- // NOTE: The logic below disables namespaces for tracking duplicate names
- // when handling map keys with a unique representation.
- // NOTE: Values retrieved from a map are not addressable,
- // so we shallow copy the values to make them addressable and
- // store them back into the map afterwards.
- var fncs arshaler
- var (
- once sync.Once
- keyFncs *arshaler
- valFncs *arshaler
- )
- init := func() {
- keyFncs = lookupArshaler(t.Key())
- valFncs = lookupArshaler(t.Elem())
- }
- nillableLegacyKey := t.Key().Kind() == reflect.Pointer &&
- implementsAny(t.Key(), textMarshalerType, textAppenderType)
- fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
- // Check for cycles.
- xe := export.Encoder(enc)
- if xe.Tokens.Depth() > startDetectingCyclesAfter {
- if err := visitPointer(&xe.SeenPointers, va.Value); err != nil {
- return newMarshalErrorBefore(enc, t, err)
- }
- defer leavePointer(&xe.SeenPointers, va.Value)
- }
- emitNull := mo.Flags.Get(jsonflags.FormatNilMapAsNull)
- if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
- switch mo.Format {
- case "emitnull":
- emitNull = true
- mo.Format = ""
- case "emitempty":
- emitNull = false
- mo.Format = ""
- default:
- return newInvalidFormatError(enc, t, mo)
- }
- }
- // Handle empty maps.
- n := va.Len()
- if n == 0 {
- if emitNull && va.IsNil() {
- return enc.WriteToken(jsontext.Null)
- }
- // Optimize for marshaling an empty map without any preceding whitespace.
- if optimizeCommon && !mo.Flags.Get(jsonflags.AnyWhitespace) && !xe.Tokens.Last.NeedObjectName() {
- xe.Buf = append(xe.Tokens.MayAppendDelim(xe.Buf, '{'), "{}"...)
- xe.Tokens.Last.Increment()
- if xe.NeedFlush() {
- return xe.Flush()
- }
- return nil
- }
- }
- once.Do(init)
- if err := enc.WriteToken(jsontext.ObjectStart); err != nil {
- return err
- }
- if n > 0 {
- nonDefaultKey := keyFncs.nonDefault
- marshalKey := keyFncs.marshal
- marshalVal := valFncs.marshal
- if mo.Marshalers != nil {
- var ok bool
- marshalKey, ok = mo.Marshalers.(*Marshalers).lookup(marshalKey, t.Key())
- marshalVal, _ = mo.Marshalers.(*Marshalers).lookup(marshalVal, t.Elem())
- nonDefaultKey = nonDefaultKey || ok
- }
- k := newAddressableValue(t.Key())
- v := newAddressableValue(t.Elem())
- // A Go map guarantees that each entry has a unique key.
- // As such, disable the expensive duplicate name check if we know
- // that every Go key will serialize as a unique JSON string.
- if !nonDefaultKey && mapKeyWithUniqueRepresentation(k.Kind(), mo.Flags.Get(jsonflags.AllowInvalidUTF8)) {
- xe.Tokens.Last.DisableNamespace()
- }
- switch {
- case !mo.Flags.Get(jsonflags.Deterministic) || n <= 1:
- for iter := va.Value.MapRange(); iter.Next(); {
- k.SetIterKey(iter)
- err := marshalKey(enc, k, mo)
- if err != nil {
- if mo.Flags.Get(jsonflags.CallMethodsWithLegacySemantics) &&
- errors.Is(err, jsontext.ErrNonStringName) && nillableLegacyKey && k.IsNil() {
- err = enc.WriteToken(jsontext.String(""))
- }
- if err != nil {
- if serr, ok := err.(*jsontext.SyntacticError); ok && serr.Err == jsontext.ErrNonStringName {
- err = newMarshalErrorBefore(enc, k.Type(), err)
- }
- return err
- }
- }
- v.SetIterValue(iter)
- if err := marshalVal(enc, v, mo); err != nil {
- return err
- }
- }
- case !nonDefaultKey && t.Key().Kind() == reflect.String:
- names := getStrings(n)
- for i, iter := 0, va.Value.MapRange(); i < n && iter.Next(); i++ {
- k.SetIterKey(iter)
- (*names)[i] = k.String()
- }
- names.Sort()
- for _, name := range *names {
- if err := enc.WriteToken(jsontext.String(name)); err != nil {
- return err
- }
- // TODO(https://go.dev/issue/57061): Use v.SetMapIndexOf.
- k.SetString(name)
- v.Set(va.MapIndex(k.Value))
- if err := marshalVal(enc, v, mo); err != nil {
- return err
- }
- }
- putStrings(names)
- default:
- type member struct {
- name string // unquoted name
- key addressableValue
- val addressableValue
- }
- members := make([]member, n)
- keys := reflect.MakeSlice(reflect.SliceOf(t.Key()), n, n)
- vals := reflect.MakeSlice(reflect.SliceOf(t.Elem()), n, n)
- for i, iter := 0, va.Value.MapRange(); i < n && iter.Next(); i++ {
- // Marshal the member name.
- k := addressableValue{keys.Index(i), true} // indexed slice element is always addressable
- k.SetIterKey(iter)
- v := addressableValue{vals.Index(i), true} // indexed slice element is always addressable
- v.SetIterValue(iter)
- err := marshalKey(enc, k, mo)
- if err != nil {
- if mo.Flags.Get(jsonflags.CallMethodsWithLegacySemantics) &&
- errors.Is(err, jsontext.ErrNonStringName) && nillableLegacyKey && k.IsNil() {
- err = enc.WriteToken(jsontext.String(""))
- }
- if err != nil {
- if serr, ok := err.(*jsontext.SyntacticError); ok && serr.Err == jsontext.ErrNonStringName {
- err = newMarshalErrorBefore(enc, k.Type(), err)
- }
- return err
- }
- }
- name := xe.UnwriteOnlyObjectMemberName()
- members[i] = member{name, k, v}
- }
- // TODO: If AllowDuplicateNames is enabled, then sort according
- // to reflect.Value as well if the names are equal.
- // See internal/fmtsort.
- slices.SortFunc(members, func(x, y member) int {
- return strings.Compare(x.name, y.name)
- })
- for _, member := range members {
- if err := enc.WriteToken(jsontext.String(member.name)); err != nil {
- return err
- }
- if err := marshalVal(enc, member.val, mo); err != nil {
- return err
- }
- }
- }
- }
- if err := enc.WriteToken(jsontext.ObjectEnd); err != nil {
- return err
- }
- return nil
- }
- fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
- xd := export.Decoder(dec)
- if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
- switch uo.Format {
- case "emitnull", "emitempty":
- uo.Format = "" // only relevant for marshaling
- default:
- return newInvalidFormatError(dec, t, uo)
- }
- }
- tok, err := dec.ReadToken()
- if err != nil {
- return err
- }
- k := tok.Kind()
- switch k {
- case 'n':
- va.SetZero()
- return nil
- case '{':
- once.Do(init)
- if va.IsNil() {
- va.Set(reflect.MakeMap(t))
- }
- nonDefaultKey := keyFncs.nonDefault
- unmarshalKey := keyFncs.unmarshal
- unmarshalVal := valFncs.unmarshal
- if uo.Unmarshalers != nil {
- var ok bool
- unmarshalKey, ok = uo.Unmarshalers.(*Unmarshalers).lookup(unmarshalKey, t.Key())
- unmarshalVal, _ = uo.Unmarshalers.(*Unmarshalers).lookup(unmarshalVal, t.Elem())
- nonDefaultKey = nonDefaultKey || ok
- }
- k := newAddressableValue(t.Key())
- v := newAddressableValue(t.Elem())
- // Manually check for duplicate entries by virtue of whether the
- // unmarshaled key already exists in the destination Go map.
- // Consequently, syntactically different names (e.g., "0" and "-0")
- // will be rejected as duplicates since they semantically refer
- // to the same Go value. This is an unusual interaction
- // between syntax and semantics, but is more correct.
- if !nonDefaultKey && mapKeyWithUniqueRepresentation(k.Kind(), uo.Flags.Get(jsonflags.AllowInvalidUTF8)) {
- xd.Tokens.Last.DisableNamespace()
- }
- // In the rare case where the map is not already empty,
- // then we need to manually track which keys we already saw
- // since existing presence alone is insufficient to indicate
- // whether the input had a duplicate name.
- var seen reflect.Value
- if !uo.Flags.Get(jsonflags.AllowDuplicateNames) && va.Len() > 0 {
- seen = reflect.MakeMap(reflect.MapOf(k.Type(), emptyStructType))
- }
- var errUnmarshal error
- for dec.PeekKind() != '}' {
- // Unmarshal the map entry key.
- k.SetZero()
- err := unmarshalKey(dec, k, uo)
- if err != nil {
- if isFatalError(err, uo.Flags) {
- return err
- }
- if err := dec.SkipValue(); err != nil {
- return err
- }
- errUnmarshal = cmp.Or(errUnmarshal, err)
- continue
- }
- if k.Kind() == reflect.Interface && !k.IsNil() && !k.Elem().Type().Comparable() {
- err := newUnmarshalErrorAfter(dec, t, fmt.Errorf("invalid incomparable key type %v", k.Elem().Type()))
- if !uo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
- return err
- }
- if err2 := dec.SkipValue(); err2 != nil {
- return err2
- }
- errUnmarshal = cmp.Or(errUnmarshal, err)
- continue
- }
- // Check if a pre-existing map entry value exists for this key.
- if v2 := va.MapIndex(k.Value); v2.IsValid() {
- if !uo.Flags.Get(jsonflags.AllowDuplicateNames) && (!seen.IsValid() || seen.MapIndex(k.Value).IsValid()) {
- // TODO: Unread the object name.
- name := xd.PreviousTokenOrValue()
- return newDuplicateNameError(dec.StackPointer(), nil, dec.InputOffset()-len64(name))
- }
- if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
- v.Set(v2)
- } else {
- v.SetZero()
- }
- } else {
- v.SetZero()
- }
- // Unmarshal the map entry value.
- err = unmarshalVal(dec, v, uo)
- va.SetMapIndex(k.Value, v.Value)
- if seen.IsValid() {
- seen.SetMapIndex(k.Value, reflect.Zero(emptyStructType))
- }
- if err != nil {
- if isFatalError(err, uo.Flags) {
- return err
- }
- errUnmarshal = cmp.Or(errUnmarshal, err)
- }
- }
- if _, err := dec.ReadToken(); err != nil {
- return err
- }
- return errUnmarshal
- }
- return newUnmarshalErrorAfterWithSkipping(dec, uo, t, nil)
- }
- return &fncs
- }
- // mapKeyWithUniqueRepresentation reports whether all possible values of k
- // marshal to a different JSON value, and whether all possible JSON values
- // that can unmarshal into k unmarshal to different Go values.
- // In other words, the representation must be a bijective.
- func mapKeyWithUniqueRepresentation(k reflect.Kind, allowInvalidUTF8 bool) bool {
- switch k {
- case reflect.Bool,
- reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
- reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- return true
- case reflect.String:
- // For strings, we have to be careful since names with invalid UTF-8
- // maybe unescape to the same Go string value.
- return !allowInvalidUTF8
- default:
- // Floating-point kinds are not listed above since NaNs
- // can appear multiple times and all serialize as "NaN".
- return false
- }
- }
- var errNilField = errors.New("cannot set embedded pointer to unexported struct type")
- func makeStructArshaler(t reflect.Type) *arshaler {
- // NOTE: The logic below disables namespaces for tracking duplicate names
- // and does the tracking locally with an efficient bit-set based on which
- // Go struct fields were seen.
- var fncs arshaler
- var (
- once sync.Once
- fields structFields
- errInit *SemanticError
- )
- init := func() {
- fields, errInit = makeStructFields(t)
- }
- fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
- xe := export.Encoder(enc)
- if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
- return newInvalidFormatError(enc, t, mo)
- }
- once.Do(init)
- if errInit != nil && !mo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
- return newMarshalErrorBefore(enc, errInit.GoType, errInit.Err)
- }
- if err := enc.WriteToken(jsontext.ObjectStart); err != nil {
- return err
- }
- var seenIdxs uintSet
- prevIdx := -1
- xe.Tokens.Last.DisableNamespace() // we manually ensure unique names below
- for i := range fields.flattened {
- f := &fields.flattened[i]
- v := addressableValue{va.Field(f.index0), va.forcedAddr} // addressable if struct value is addressable
- if len(f.index) > 0 {
- v = v.fieldByIndex(f.index, false)
- if !v.IsValid() {
- continue // implies a nil inlined field
- }
- }
- // OmitZero skips the field if the Go value is zero,
- // which we can determine up front without calling the marshaler.
- if (f.omitzero || mo.Flags.Get(jsonflags.OmitZeroStructFields)) &&
- ((f.isZero == nil && v.IsZero()) || (f.isZero != nil && f.isZero(v))) {
- continue
- }
- // Check for the legacy definition of omitempty.
- if f.omitempty && mo.Flags.Get(jsonflags.OmitEmptyWithLegacyDefinition) && isLegacyEmpty(v) {
- continue
- }
- marshal := f.fncs.marshal
- nonDefault := f.fncs.nonDefault
- if mo.Marshalers != nil {
- var ok bool
- marshal, ok = mo.Marshalers.(*Marshalers).lookup(marshal, f.typ)
- nonDefault = nonDefault || ok
- }
- // OmitEmpty skips the field if the marshaled JSON value is empty,
- // which we can know up front if there are no custom marshalers,
- // otherwise we must marshal the value and unwrite it if empty.
- if f.omitempty && !mo.Flags.Get(jsonflags.OmitEmptyWithLegacyDefinition) &&
- !nonDefault && f.isEmpty != nil && f.isEmpty(v) {
- continue // fast path for omitempty
- }
- // Write the object member name.
- //
- // The logic below is semantically equivalent to:
- // enc.WriteToken(String(f.name))
- // but specialized and simplified because:
- // 1. The Encoder must be expecting an object name.
- // 2. The object namespace is guaranteed to be disabled.
- // 3. The object name is guaranteed to be valid and pre-escaped.
- // 4. There is no need to flush the buffer (for unwrite purposes).
- // 5. There is no possibility of an error occurring.
- if optimizeCommon {
- // Append any delimiters or optional whitespace.
- b := xe.Buf
- if xe.Tokens.Last.Length() > 0 {
- b = append(b, ',')
- if mo.Flags.Get(jsonflags.SpaceAfterComma) {
- b = append(b, ' ')
- }
- }
- if mo.Flags.Get(jsonflags.Multiline) {
- b = xe.AppendIndent(b, xe.Tokens.NeedIndent('"'))
- }
- // Append the token to the output and to the state machine.
- n0 := len(b) // offset before calling AppendQuote
- if !f.nameNeedEscape {
- b = append(b, f.quotedName...)
- } else {
- b, _ = jsonwire.AppendQuote(b, f.name, &mo.Flags)
- }
- xe.Buf = b
- xe.Names.ReplaceLastQuotedOffset(n0)
- xe.Tokens.Last.Increment()
- } else {
- if err := enc.WriteToken(jsontext.String(f.name)); err != nil {
- return err
- }
- }
- // Write the object member value.
- flagsOriginal := mo.Flags
- if f.string {
- if !mo.Flags.Get(jsonflags.StringifyWithLegacySemantics) {
- mo.Flags.Set(jsonflags.StringifyNumbers | 1)
- } else if canLegacyStringify(f.typ) {
- mo.Flags.Set(jsonflags.StringifyNumbers | jsonflags.StringifyBoolsAndStrings | 1)
- }
- }
- if f.format != "" {
- mo.FormatDepth = xe.Tokens.Depth()
- mo.Format = f.format
- }
- err := marshal(enc, v, mo)
- mo.Flags = flagsOriginal
- mo.Format = ""
- if err != nil {
- return err
- }
- // Try unwriting the member if empty (slow path for omitempty).
- if f.omitempty && !mo.Flags.Get(jsonflags.OmitEmptyWithLegacyDefinition) {
- var prevName *string
- if prevIdx >= 0 {
- prevName = &fields.flattened[prevIdx].name
- }
- if xe.UnwriteEmptyObjectMember(prevName) {
- continue
- }
- }
- // Remember the previous written object member.
- // The set of seen fields only needs to be updated to detect
- // duplicate names with those from the inlined fallback.
- if !mo.Flags.Get(jsonflags.AllowDuplicateNames) && fields.inlinedFallback != nil {
- seenIdxs.insert(uint(f.id))
- }
- prevIdx = f.id
- }
- if fields.inlinedFallback != nil && !(mo.Flags.Get(jsonflags.DiscardUnknownMembers) && fields.inlinedFallback.unknown) {
- var insertUnquotedName func([]byte) bool
- if !mo.Flags.Get(jsonflags.AllowDuplicateNames) {
- insertUnquotedName = func(name []byte) bool {
- // Check that the name from inlined fallback does not match
- // one of the previously marshaled names from known fields.
- if foldedFields := fields.lookupByFoldedName(name); len(foldedFields) > 0 {
- if f := fields.byActualName[string(name)]; f != nil {
- return seenIdxs.insert(uint(f.id))
- }
- for _, f := range foldedFields {
- if f.matchFoldedName(name, &mo.Flags) {
- return seenIdxs.insert(uint(f.id))
- }
- }
- }
- // Check that the name does not match any other name
- // previously marshaled from the inlined fallback.
- return xe.Namespaces.Last().InsertUnquoted(name)
- }
- }
- if err := marshalInlinedFallbackAll(enc, va, mo, fields.inlinedFallback, insertUnquotedName); err != nil {
- return err
- }
- }
- if err := enc.WriteToken(jsontext.ObjectEnd); err != nil {
- return err
- }
- return nil
- }
- fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
- xd := export.Decoder(dec)
- if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
- return newInvalidFormatError(dec, t, uo)
- }
- tok, err := dec.ReadToken()
- if err != nil {
- return err
- }
- k := tok.Kind()
- switch k {
- case 'n':
- if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
- va.SetZero()
- }
- return nil
- case '{':
- once.Do(init)
- if errInit != nil && !uo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
- return newUnmarshalErrorAfter(dec, errInit.GoType, errInit.Err)
- }
- var seenIdxs uintSet
- xd.Tokens.Last.DisableNamespace()
- var errUnmarshal error
- for dec.PeekKind() != '}' {
- // Process the object member name.
- var flags jsonwire.ValueFlags
- val, err := xd.ReadValue(&flags)
- if err != nil {
- return err
- }
- name := jsonwire.UnquoteMayCopy(val, flags.IsVerbatim())
- f := fields.byActualName[string(name)]
- if f == nil {
- for _, f2 := range fields.lookupByFoldedName(name) {
- if f2.matchFoldedName(name, &uo.Flags) {
- f = f2
- break
- }
- }
- if f == nil {
- if uo.Flags.Get(jsonflags.RejectUnknownMembers) && (fields.inlinedFallback == nil || fields.inlinedFallback.unknown) {
- err := newUnmarshalErrorAfter(dec, t, ErrUnknownName)
- if !uo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
- return err
- }
- errUnmarshal = cmp.Or(errUnmarshal, err)
- }
- if !uo.Flags.Get(jsonflags.AllowDuplicateNames) && !xd.Namespaces.Last().InsertUnquoted(name) {
- // TODO: Unread the object name.
- return newDuplicateNameError(dec.StackPointer(), nil, dec.InputOffset()-len64(val))
- }
- if fields.inlinedFallback == nil {
- // Skip unknown value since we have no place to store it.
- if err := dec.SkipValue(); err != nil {
- return err
- }
- } else {
- // Marshal into value capable of storing arbitrary object members.
- if err := unmarshalInlinedFallbackNext(dec, va, uo, fields.inlinedFallback, val, name); err != nil {
- if isFatalError(err, uo.Flags) {
- return err
- }
- errUnmarshal = cmp.Or(errUnmarshal, err)
- }
- }
- continue
- }
- }
- if !uo.Flags.Get(jsonflags.AllowDuplicateNames) && !seenIdxs.insert(uint(f.id)) {
- // TODO: Unread the object name.
- return newDuplicateNameError(dec.StackPointer(), nil, dec.InputOffset()-len64(val))
- }
- // Process the object member value.
- unmarshal := f.fncs.unmarshal
- if uo.Unmarshalers != nil {
- unmarshal, _ = uo.Unmarshalers.(*Unmarshalers).lookup(unmarshal, f.typ)
- }
- flagsOriginal := uo.Flags
- if f.string {
- if !uo.Flags.Get(jsonflags.StringifyWithLegacySemantics) {
- uo.Flags.Set(jsonflags.StringifyNumbers | 1)
- } else if canLegacyStringify(f.typ) {
- uo.Flags.Set(jsonflags.StringifyNumbers | jsonflags.StringifyBoolsAndStrings | 1)
- }
- }
- if f.format != "" {
- uo.FormatDepth = xd.Tokens.Depth()
- uo.Format = f.format
- }
- v := addressableValue{va.Field(f.index0), va.forcedAddr} // addressable if struct value is addressable
- if len(f.index) > 0 {
- v = v.fieldByIndex(f.index, true)
- if !v.IsValid() {
- err := newUnmarshalErrorBefore(dec, t, errNilField)
- if !uo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
- return err
- }
- errUnmarshal = cmp.Or(errUnmarshal, err)
- unmarshal = func(dec *jsontext.Decoder, _ addressableValue, _ *jsonopts.Struct) error {
- return dec.SkipValue()
- }
- }
- }
- err = unmarshal(dec, v, uo)
- uo.Flags = flagsOriginal
- uo.Format = ""
- if err != nil {
- if isFatalError(err, uo.Flags) {
- return err
- }
- errUnmarshal = cmp.Or(errUnmarshal, err)
- }
- }
- if _, err := dec.ReadToken(); err != nil {
- return err
- }
- return errUnmarshal
- }
- return newUnmarshalErrorAfterWithSkipping(dec, uo, t, nil)
- }
- return &fncs
- }
- func (va addressableValue) fieldByIndex(index []int, mayAlloc bool) addressableValue {
- for _, i := range index {
- va = va.indirect(mayAlloc)
- if !va.IsValid() {
- return va
- }
- va = addressableValue{va.Field(i), va.forcedAddr} // addressable if struct value is addressable
- }
- return va
- }
- func (va addressableValue) indirect(mayAlloc bool) addressableValue {
- if va.Kind() == reflect.Pointer {
- if va.IsNil() {
- if !mayAlloc || !va.CanSet() {
- return addressableValue{}
- }
- va.Set(reflect.New(va.Type().Elem()))
- }
- va = addressableValue{va.Elem(), false} // dereferenced pointer is always addressable
- }
- return va
- }
- // isLegacyEmpty reports whether a value is empty according to the v1 definition.
- func isLegacyEmpty(v addressableValue) bool {
- // Equivalent to encoding/json.isEmptyValue@v1.21.0.
- switch v.Kind() {
- case reflect.Bool:
- return v.Bool() == false
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- return v.Int() == 0
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- return v.Uint() == 0
- case reflect.Float32, reflect.Float64:
- return v.Float() == 0
- case reflect.String, reflect.Map, reflect.Slice, reflect.Array:
- return v.Len() == 0
- case reflect.Pointer, reflect.Interface:
- return v.IsNil()
- }
- return false
- }
- // canLegacyStringify reports whether t can be stringified according to v1,
- // where t is a bool, string, or number (or unnamed pointer to such).
- // In v1, the `string` option does not apply recursively to nested types within
- // a composite Go type (e.g., an array, slice, struct, map, or interface).
- func canLegacyStringify(t reflect.Type) bool {
- // Based on encoding/json.typeFields#L1126-L1143@v1.23.0
- if t.Name() == "" && t.Kind() == reflect.Ptr {
- t = t.Elem()
- }
- switch t.Kind() {
- case reflect.Bool, reflect.String,
- reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
- reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr,
- reflect.Float32, reflect.Float64:
- return true
- }
- return false
- }
- func makeSliceArshaler(t reflect.Type) *arshaler {
- var fncs arshaler
- var (
- once sync.Once
- valFncs *arshaler
- )
- init := func() {
- valFncs = lookupArshaler(t.Elem())
- }
- fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
- // Check for cycles.
- xe := export.Encoder(enc)
- if xe.Tokens.Depth() > startDetectingCyclesAfter {
- if err := visitPointer(&xe.SeenPointers, va.Value); err != nil {
- return newMarshalErrorBefore(enc, t, err)
- }
- defer leavePointer(&xe.SeenPointers, va.Value)
- }
- emitNull := mo.Flags.Get(jsonflags.FormatNilSliceAsNull)
- if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
- switch mo.Format {
- case "emitnull":
- emitNull = true
- mo.Format = ""
- case "emitempty":
- emitNull = false
- mo.Format = ""
- default:
- return newInvalidFormatError(enc, t, mo)
- }
- }
- // Handle empty slices.
- n := va.Len()
- if n == 0 {
- if emitNull && va.IsNil() {
- return enc.WriteToken(jsontext.Null)
- }
- // Optimize for marshaling an empty slice without any preceding whitespace.
- if optimizeCommon && !mo.Flags.Get(jsonflags.AnyWhitespace) && !xe.Tokens.Last.NeedObjectName() {
- xe.Buf = append(xe.Tokens.MayAppendDelim(xe.Buf, '['), "[]"...)
- xe.Tokens.Last.Increment()
- if xe.NeedFlush() {
- return xe.Flush()
- }
- return nil
- }
- }
- once.Do(init)
- if err := enc.WriteToken(jsontext.ArrayStart); err != nil {
- return err
- }
- marshal := valFncs.marshal
- if mo.Marshalers != nil {
- marshal, _ = mo.Marshalers.(*Marshalers).lookup(marshal, t.Elem())
- }
- for i := range n {
- v := addressableValue{va.Index(i), false} // indexed slice element is always addressable
- if err := marshal(enc, v, mo); err != nil {
- return err
- }
- }
- if err := enc.WriteToken(jsontext.ArrayEnd); err != nil {
- return err
- }
- return nil
- }
- emptySlice := reflect.MakeSlice(t, 0, 0)
- fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
- xd := export.Decoder(dec)
- if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
- switch uo.Format {
- case "emitnull", "emitempty":
- uo.Format = "" // only relevant for marshaling
- default:
- return newInvalidFormatError(dec, t, uo)
- }
- }
- tok, err := dec.ReadToken()
- if err != nil {
- return err
- }
- k := tok.Kind()
- switch k {
- case 'n':
- va.SetZero()
- return nil
- case '[':
- once.Do(init)
- unmarshal := valFncs.unmarshal
- if uo.Unmarshalers != nil {
- unmarshal, _ = uo.Unmarshalers.(*Unmarshalers).lookup(unmarshal, t.Elem())
- }
- mustZero := true // we do not know the cleanliness of unused capacity
- cap := va.Cap()
- if cap > 0 {
- va.SetLen(cap)
- }
- var i int
- var errUnmarshal error
- for dec.PeekKind() != ']' {
- if i == cap {
- va.Value.Grow(1)
- cap = va.Cap()
- va.SetLen(cap)
- mustZero = false // reflect.Value.Grow ensures new capacity is zero-initialized
- }
- v := addressableValue{va.Index(i), false} // indexed slice element is always addressable
- i++
- if mustZero && !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
- v.SetZero()
- }
- if err := unmarshal(dec, v, uo); err != nil {
- if isFatalError(err, uo.Flags) {
- va.SetLen(i)
- return err
- }
- errUnmarshal = cmp.Or(errUnmarshal, err)
- }
- }
- if i == 0 {
- va.Set(emptySlice)
- } else {
- va.SetLen(i)
- }
- if _, err := dec.ReadToken(); err != nil {
- return err
- }
- return errUnmarshal
- }
- return newUnmarshalErrorAfterWithSkipping(dec, uo, t, nil)
- }
- return &fncs
- }
- var errArrayUnderflow = errors.New("too few array elements")
- var errArrayOverflow = errors.New("too many array elements")
- func makeArrayArshaler(t reflect.Type) *arshaler {
- var fncs arshaler
- var (
- once sync.Once
- valFncs *arshaler
- )
- init := func() {
- valFncs = lookupArshaler(t.Elem())
- }
- n := t.Len()
- fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
- xe := export.Encoder(enc)
- if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
- return newInvalidFormatError(enc, t, mo)
- }
- once.Do(init)
- if err := enc.WriteToken(jsontext.ArrayStart); err != nil {
- return err
- }
- marshal := valFncs.marshal
- if mo.Marshalers != nil {
- marshal, _ = mo.Marshalers.(*Marshalers).lookup(marshal, t.Elem())
- }
- for i := range n {
- v := addressableValue{va.Index(i), va.forcedAddr} // indexed array element is addressable if array is addressable
- if err := marshal(enc, v, mo); err != nil {
- return err
- }
- }
- if err := enc.WriteToken(jsontext.ArrayEnd); err != nil {
- return err
- }
- return nil
- }
- fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
- xd := export.Decoder(dec)
- if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
- return newInvalidFormatError(dec, t, uo)
- }
- tok, err := dec.ReadToken()
- if err != nil {
- return err
- }
- k := tok.Kind()
- switch k {
- case 'n':
- if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
- va.SetZero()
- }
- return nil
- case '[':
- once.Do(init)
- unmarshal := valFncs.unmarshal
- if uo.Unmarshalers != nil {
- unmarshal, _ = uo.Unmarshalers.(*Unmarshalers).lookup(unmarshal, t.Elem())
- }
- var i int
- var errUnmarshal error
- for dec.PeekKind() != ']' {
- if i >= n {
- if err := dec.SkipValue(); err != nil {
- return err
- }
- err = errArrayOverflow
- continue
- }
- v := addressableValue{va.Index(i), va.forcedAddr} // indexed array element is addressable if array is addressable
- if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
- v.SetZero()
- }
- if err := unmarshal(dec, v, uo); err != nil {
- if isFatalError(err, uo.Flags) {
- return err
- }
- errUnmarshal = cmp.Or(errUnmarshal, err)
- }
- i++
- }
- for ; i < n; i++ {
- va.Index(i).SetZero()
- err = errArrayUnderflow
- }
- if _, err := dec.ReadToken(); err != nil {
- return err
- }
- if err != nil && !uo.Flags.Get(jsonflags.UnmarshalArrayFromAnyLength) {
- return newUnmarshalErrorAfter(dec, t, err)
- }
- return errUnmarshal
- }
- return newUnmarshalErrorAfterWithSkipping(dec, uo, t, nil)
- }
- return &fncs
- }
- func makePointerArshaler(t reflect.Type) *arshaler {
- var fncs arshaler
- var (
- once sync.Once
- valFncs *arshaler
- )
- init := func() {
- valFncs = lookupArshaler(t.Elem())
- }
- fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
- // Check for cycles.
- xe := export.Encoder(enc)
- if xe.Tokens.Depth() > startDetectingCyclesAfter {
- if err := visitPointer(&xe.SeenPointers, va.Value); err != nil {
- return newMarshalErrorBefore(enc, t, err)
- }
- defer leavePointer(&xe.SeenPointers, va.Value)
- }
- // NOTE: Struct.Format is forwarded to underlying marshal.
- if va.IsNil() {
- return enc.WriteToken(jsontext.Null)
- }
- once.Do(init)
- marshal := valFncs.marshal
- if mo.Marshalers != nil {
- marshal, _ = mo.Marshalers.(*Marshalers).lookup(marshal, t.Elem())
- }
- v := addressableValue{va.Elem(), false} // dereferenced pointer is always addressable
- return marshal(enc, v, mo)
- }
- fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
- // NOTE: Struct.Format is forwarded to underlying unmarshal.
- if dec.PeekKind() == 'n' {
- if _, err := dec.ReadToken(); err != nil {
- return err
- }
- va.SetZero()
- return nil
- }
- once.Do(init)
- unmarshal := valFncs.unmarshal
- if uo.Unmarshalers != nil {
- unmarshal, _ = uo.Unmarshalers.(*Unmarshalers).lookup(unmarshal, t.Elem())
- }
- if va.IsNil() {
- va.Set(reflect.New(t.Elem()))
- }
- v := addressableValue{va.Elem(), false} // dereferenced pointer is always addressable
- if err := unmarshal(dec, v, uo); err != nil {
- return err
- }
- if uo.Flags.Get(jsonflags.StringifyWithLegacySemantics) &&
- uo.Flags.Get(jsonflags.StringifyNumbers|jsonflags.StringifyBoolsAndStrings) {
- // A JSON null quoted within a JSON string should take effect
- // within the pointer value, rather than the indirect value.
- //
- // TODO: This does not correctly handle escaped nulls
- // (e.g., "\u006e\u0075\u006c\u006c"), but is good enough
- // for such an esoteric use case of the `string` option.
- if string(export.Decoder(dec).PreviousTokenOrValue()) == `"null"` {
- va.SetZero()
- }
- }
- return nil
- }
- return &fncs
- }
- var errNilInterface = errors.New("cannot derive concrete type for nil interface with finite type set")
- func makeInterfaceArshaler(t reflect.Type) *arshaler {
- // NOTE: Values retrieved from an interface are not addressable,
- // so we shallow copy the values to make them addressable and
- // store them back into the interface afterwards.
- var fncs arshaler
- var whichMarshaler reflect.Type
- for _, iface := range allMarshalerTypes {
- if t.Implements(iface) {
- whichMarshaler = t
- break
- }
- }
- fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
- xe := export.Encoder(enc)
- if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
- return newInvalidFormatError(enc, t, mo)
- }
- if va.IsNil() {
- return enc.WriteToken(jsontext.Null)
- } else if mo.Flags.Get(jsonflags.CallMethodsWithLegacySemantics) && whichMarshaler != nil {
- // The marshaler for a pointer never calls the method on a nil receiver.
- // Wrap the nil pointer within a struct type so that marshal
- // instead appears on a value receiver and may be called.
- if va.Elem().Kind() == reflect.Pointer && va.Elem().IsNil() {
- v2 := newAddressableValue(whichMarshaler)
- switch whichMarshaler {
- case jsonMarshalerToType:
- v2.Set(reflect.ValueOf(struct{ MarshalerTo }{va.Elem().Interface().(MarshalerTo)}))
- case jsonMarshalerType:
- v2.Set(reflect.ValueOf(struct{ Marshaler }{va.Elem().Interface().(Marshaler)}))
- case textAppenderType:
- v2.Set(reflect.ValueOf(struct{ encodingTextAppender }{va.Elem().Interface().(encodingTextAppender)}))
- case textMarshalerType:
- v2.Set(reflect.ValueOf(struct{ encoding.TextMarshaler }{va.Elem().Interface().(encoding.TextMarshaler)}))
- }
- va = v2
- }
- }
- v := newAddressableValue(va.Elem().Type())
- v.Set(va.Elem())
- marshal := lookupArshaler(v.Type()).marshal
- if mo.Marshalers != nil {
- marshal, _ = mo.Marshalers.(*Marshalers).lookup(marshal, v.Type())
- }
- // Optimize for the any type if there are no special options.
- if optimizeCommon &&
- t == anyType && !mo.Flags.Get(jsonflags.StringifyNumbers|jsonflags.StringifyBoolsAndStrings) && mo.Format == "" &&
- (mo.Marshalers == nil || !mo.Marshalers.(*Marshalers).fromAny) {
- return marshalValueAny(enc, va.Elem().Interface(), mo)
- }
- return marshal(enc, v, mo)
- }
- fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
- xd := export.Decoder(dec)
- if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
- return newInvalidFormatError(dec, t, uo)
- }
- if uo.Flags.Get(jsonflags.MergeWithLegacySemantics) && !va.IsNil() {
- // Legacy merge behavior is difficult to explain.
- // In general, it only merges for non-nil pointer kinds.
- // As a special case, unmarshaling a JSON null into a pointer
- // sets a concrete nil pointer of the underlying type
- // (rather than setting the interface value itself to nil).
- e := va.Elem()
- if e.Kind() == reflect.Pointer && !e.IsNil() {
- if dec.PeekKind() == 'n' && e.Elem().Kind() == reflect.Pointer {
- if _, err := dec.ReadToken(); err != nil {
- return err
- }
- va.Elem().Elem().SetZero()
- return nil
- }
- } else {
- va.SetZero()
- }
- }
- if dec.PeekKind() == 'n' {
- if _, err := dec.ReadToken(); err != nil {
- return err
- }
- va.SetZero()
- return nil
- }
- var v addressableValue
- if va.IsNil() {
- // Optimize for the any type if there are no special options.
- // We do not care about stringified numbers since JSON strings
- // are always unmarshaled into an any value as Go strings.
- // Duplicate name check must be enforced since unmarshalValueAny
- // does not implement merge semantics.
- if optimizeCommon &&
- t == anyType && !uo.Flags.Get(jsonflags.AllowDuplicateNames) && uo.Format == "" &&
- (uo.Unmarshalers == nil || !uo.Unmarshalers.(*Unmarshalers).fromAny) {
- v, err := unmarshalValueAny(dec, uo)
- // We must check for nil interface values up front.
- // See https://go.dev/issue/52310.
- if v != nil {
- va.Set(reflect.ValueOf(v))
- }
- return err
- }
- k := dec.PeekKind()
- if !isAnyType(t) {
- return newUnmarshalErrorBeforeWithSkipping(dec, uo, t, errNilInterface)
- }
- switch k {
- case 'f', 't':
- v = newAddressableValue(boolType)
- case '"':
- v = newAddressableValue(stringType)
- case '0':
- if uo.Flags.Get(jsonflags.UnmarshalAnyWithRawNumber) {
- v = addressableValue{reflect.ValueOf(internal.NewRawNumber()).Elem(), true}
- } else {
- v = newAddressableValue(float64Type)
- }
- case '{':
- v = newAddressableValue(mapStringAnyType)
- case '[':
- v = newAddressableValue(sliceAnyType)
- default:
- // If k is invalid (e.g., due to an I/O or syntax error), then
- // that will be cached by PeekKind and returned by ReadValue.
- // If k is '}' or ']', then ReadValue must error since
- // those are invalid kinds at the start of a JSON value.
- _, err := dec.ReadValue()
- return err
- }
- } else {
- // Shallow copy the existing value to keep it addressable.
- // Any mutations at the top-level of the value will be observable
- // since we always store this value back into the interface value.
- v = newAddressableValue(va.Elem().Type())
- v.Set(va.Elem())
- }
- unmarshal := lookupArshaler(v.Type()).unmarshal
- if uo.Unmarshalers != nil {
- unmarshal, _ = uo.Unmarshalers.(*Unmarshalers).lookup(unmarshal, v.Type())
- }
- err := unmarshal(dec, v, uo)
- va.Set(v.Value)
- return err
- }
- return &fncs
- }
- // isAnyType reports wether t is equivalent to the any interface type.
- func isAnyType(t reflect.Type) bool {
- // This is forward compatible if the Go language permits type sets within
- // ordinary interfaces where an interface with zero methods does not
- // necessarily mean it can hold every possible Go type.
- // See https://go.dev/issue/45346.
- return t == anyType || anyType.Implements(t)
- }
- func makeInvalidArshaler(t reflect.Type) *arshaler {
- var fncs arshaler
- fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
- return newMarshalErrorBefore(enc, t, nil)
- }
- fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
- return newUnmarshalErrorBefore(dec, t, nil)
- }
- return &fncs
- }
- func stringOrNumberKind(isString bool) jsontext.Kind {
- if isString {
- return '"'
- } else {
- return '0'
- }
- }
- type uintSet64 uint64
- func (s uintSet64) has(i uint) bool { return s&(1<<i) > 0 }
- func (s *uintSet64) set(i uint) { *s |= 1 << i }
- // uintSet is a set of unsigned integers.
- // It is optimized for most integers being close to zero.
- type uintSet struct {
- lo uintSet64
- hi []uintSet64
- }
- // has reports whether i is in the set.
- func (s *uintSet) has(i uint) bool {
- if i < 64 {
- return s.lo.has(i)
- } else {
- i -= 64
- iHi, iLo := int(i/64), i%64
- return iHi < len(s.hi) && s.hi[iHi].has(iLo)
- }
- }
- // insert inserts i into the set and reports whether it was the first insertion.
- func (s *uintSet) insert(i uint) bool {
- // TODO: Make this inlinable at least for the lower 64-bit case.
- if i < 64 {
- has := s.lo.has(i)
- s.lo.set(i)
- return !has
- } else {
- i -= 64
- iHi, iLo := int(i/64), i%64
- if iHi >= len(s.hi) {
- s.hi = append(s.hi, make([]uintSet64, iHi+1-len(s.hi))...)
- s.hi = s.hi[:cap(s.hi)]
- }
- has := s.hi[iHi].has(iLo)
- s.hi[iHi].set(iLo)
- return !has
- }
- }
|