1 // Copyright 2010 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 // Package json implements encoding and decoding of JSON as defined in 6 // RFC 4627. The mapping between JSON and Go values is described 7 // in the documentation for the Marshal and Unmarshal functions. 8 // 9 // See "JSON and Go" for an introduction to this package: 10 // https://golang.org/doc/articles/json_and_go.html 11 package json 12 13 import ( 14 "bytes" 15 "encoding" 16 "encoding/base64" 17 "fmt" 18 "math" 19 "reflect" 20 "runtime" 21 "sort" 22 "strconv" 23 "strings" 24 "sync" 25 "sync/atomic" 26 "unicode" 27 "unicode/utf8" 28 ) 29 30 // Marshal returns the JSON encoding of v. 31 // 32 // Marshal traverses the value v recursively. 33 // If an encountered value implements the Marshaler interface 34 // and is not a nil pointer, Marshal calls its MarshalJSON method 35 // to produce JSON. If no MarshalJSON method is present but the 36 // value implements encoding.TextMarshaler instead, Marshal calls 37 // its MarshalText method and encodes the result as a JSON string. 38 // The nil pointer exception is not strictly necessary 39 // but mimics a similar, necessary exception in the behavior of 40 // UnmarshalJSON. 41 // 42 // Otherwise, Marshal uses the following type-dependent default encodings: 43 // 44 // Boolean values encode as JSON booleans. 45 // 46 // Floating point, integer, and Number values encode as JSON numbers. 47 // 48 // String values encode as JSON strings coerced to valid UTF-8, 49 // replacing invalid bytes with the Unicode replacement rune. 50 // The angle brackets "<" and ">" are escaped to "\u003c" and "\u003e" 51 // to keep some browsers from misinterpreting JSON output as HTML. 52 // Ampersand "&" is also escaped to "\u0026" for the same reason. 53 // This escaping can be disabled using an Encoder that had SetEscapeHTML(false) 54 // called on it. 55 // 56 // Array and slice values encode as JSON arrays, except that 57 // []byte encodes as a base64-encoded string, and a nil slice 58 // encodes as the null JSON value. 59 // 60 // Struct values encode as JSON objects. 61 // Each exported struct field becomes a member of the object, using the 62 // field name as the object key, unless the field is omitted for one of the 63 // reasons given below. 64 // 65 // The encoding of each struct field can be customized by the format string 66 // stored under the "json" key in the struct field's tag. 67 // The format string gives the name of the field, possibly followed by a 68 // comma-separated list of options. The name may be empty in order to 69 // specify options without overriding the default field name. 70 // 71 // The "omitempty" option specifies that the field should be omitted 72 // from the encoding if the field has an empty value, defined as 73 // false, 0, a nil pointer, a nil interface value, and any empty array, 74 // slice, map, or string. 75 // 76 // As a special case, if the field tag is "-", the field is always omitted. 77 // Note that a field with name "-" can still be generated using the tag "-,". 78 // 79 // Examples of struct field tags and their meanings: 80 // 81 // // Field appears in JSON as key "myName". 82 // Field int `json:"myName"` 83 // 84 // // Field appears in JSON as key "myName" and 85 // // the field is omitted from the object if its value is empty, 86 // // as defined above. 87 // Field int `json:"myName,omitempty"` 88 // 89 // // Field appears in JSON as key "Field" (the default), but 90 // // the field is skipped if empty. 91 // // Note the leading comma. 92 // Field int `json:",omitempty"` 93 // 94 // // Field is ignored by this package. 95 // Field int `json:"-"` 96 // 97 // // Field appears in JSON as key "-". 98 // Field int `json:"-,"` 99 // 100 // The "string" option signals that a field is stored as JSON inside a 101 // JSON-encoded string. It applies only to fields of string, floating point, 102 // integer, or boolean types. This extra level of encoding is sometimes used 103 // when communicating with JavaScript programs: 104 // 105 // Int64String int64 `json:",string"` 106 // 107 // The key name will be used if it's a non-empty string consisting of 108 // only Unicode letters, digits, and ASCII punctuation except quotation 109 // marks, backslash, and comma. 110 // 111 // Anonymous struct fields are usually marshaled as if their inner exported fields 112 // were fields in the outer struct, subject to the usual Go visibility rules amended 113 // as described in the next paragraph. 114 // An anonymous struct field with a name given in its JSON tag is treated as 115 // having that name, rather than being anonymous. 116 // An anonymous struct field of interface type is treated the same as having 117 // that type as its name, rather than being anonymous. 118 // 119 // The Go visibility rules for struct fields are amended for JSON when 120 // deciding which field to marshal or unmarshal. If there are 121 // multiple fields at the same level, and that level is the least 122 // nested (and would therefore be the nesting level selected by the 123 // usual Go rules), the following extra rules apply: 124 // 125 // 1) Of those fields, if any are JSON-tagged, only tagged fields are considered, 126 // even if there are multiple untagged fields that would otherwise conflict. 127 // 128 // 2) If there is exactly one field (tagged or not according to the first rule), that is selected. 129 // 130 // 3) Otherwise there are multiple fields, and all are ignored; no error occurs. 131 // 132 // Handling of anonymous struct fields is new in Go 1.1. 133 // Prior to Go 1.1, anonymous struct fields were ignored. To force ignoring of 134 // an anonymous struct field in both current and earlier versions, give the field 135 // a JSON tag of "-". 136 // 137 // Map values encode as JSON objects. The map's key type must either be a 138 // string, an integer type, or implement encoding.TextMarshaler. The map keys 139 // are sorted and used as JSON object keys by applying the following rules, 140 // subject to the UTF-8 coercion described for string values above: 141 // - string keys are used directly 142 // - encoding.TextMarshalers are marshaled 143 // - integer keys are converted to strings 144 // 145 // Pointer values encode as the value pointed to. 146 // A nil pointer encodes as the null JSON value. 147 // 148 // Interface values encode as the value contained in the interface. 149 // A nil interface value encodes as the null JSON value. 150 // 151 // Channel, complex, and function values cannot be encoded in JSON. 152 // Attempting to encode such a value causes Marshal to return 153 // an UnsupportedTypeError. 154 // 155 // JSON cannot represent cyclic data structures and Marshal does not 156 // handle them. Passing cyclic structures to Marshal will result in 157 // an infinite recursion. 158 // 159 func Marshal(v interface{}) ([]byte, error) { 160 e := &encodeState{} 161 err := e.marshal(v, encOpts{escapeHTML: true}) 162 if err != nil { 163 return nil, err 164 } 165 return e.Bytes(), nil 166 } 167 168 // MarshalIndent is like Marshal but applies Indent to format the output. 169 func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) { 170 b, err := Marshal(v) 171 if err != nil { 172 return nil, err 173 } 174 var buf bytes.Buffer 175 err = Indent(&buf, b, prefix, indent) 176 if err != nil { 177 return nil, err 178 } 179 return buf.Bytes(), nil 180 } 181 182 // HTMLEscape appends to dst the JSON-encoded src with <, >, &, U+2028 and U+2029 183 // characters inside string literals changed to \u003c, \u003e, \u0026, \u2028, \u2029 184 // so that the JSON will be safe to embed inside HTML <script> tags. 185 // For historical reasons, web browsers don't honor standard HTML 186 // escaping within <script> tags, so an alternative JSON encoding must 187 // be used. 188 func HTMLEscape(dst *bytes.Buffer, src []byte) { 189 // The characters can only appear in string literals, 190 // so just scan the string one byte at a time. 191 start := 0 192 for i, c := range src { 193 if c == '<' || c == '>' || c == '&' { 194 if start < i { 195 dst.Write(src[start:i]) 196 } 197 dst.WriteString(`\u00`) 198 dst.WriteByte(hex[c>>4]) 199 dst.WriteByte(hex[c&0xF]) 200 start = i + 1 201 } 202 // Convert U+2028 and U+2029 (E2 80 A8 and E2 80 A9). 203 if c == 0xE2 && i+2 < len(src) && src[i+1] == 0x80 && src[i+2]&^1 == 0xA8 { 204 if start < i { 205 dst.Write(src[start:i]) 206 } 207 dst.WriteString(`\u202`) 208 dst.WriteByte(hex[src[i+2]&0xF]) 209 start = i + 3 210 } 211 } 212 if start < len(src) { 213 dst.Write(src[start:]) 214 } 215 } 216 217 // Marshaler is the interface implemented by types that 218 // can marshal themselves into valid JSON. 219 type Marshaler interface { 220 MarshalJSON() ([]byte, error) 221 } 222 223 // An UnsupportedTypeError is returned by Marshal when attempting 224 // to encode an unsupported value type. 225 type UnsupportedTypeError struct { 226 Type reflect.Type 227 } 228 229 func (e *UnsupportedTypeError) Error() string { 230 return "json: unsupported type: " + e.Type.String() 231 } 232 233 type UnsupportedValueError struct { 234 Value reflect.Value 235 Str string 236 } 237 238 func (e *UnsupportedValueError) Error() string { 239 return "json: unsupported value: " + e.Str 240 } 241 242 // Before Go 1.2, an InvalidUTF8Error was returned by Marshal when 243 // attempting to encode a string value with invalid UTF-8 sequences. 244 // As of Go 1.2, Marshal instead coerces the string to valid UTF-8 by 245 // replacing invalid bytes with the Unicode replacement rune U+FFFD. 246 // This error is no longer generated but is kept for backwards compatibility 247 // with programs that might mention it. 248 type InvalidUTF8Error struct { 249 S string // the whole string value that caused the error 250 } 251 252 func (e *InvalidUTF8Error) Error() string { 253 return "json: invalid UTF-8 in string: " + strconv.Quote(e.S) 254 } 255 256 type MarshalerError struct { 257 Type reflect.Type 258 Err error 259 } 260 261 func (e *MarshalerError) Error() string { 262 return "json: error calling MarshalJSON for type " + e.Type.String() + ": " + e.Err.Error() 263 } 264 265 var hex = "0123456789abcdef" 266 267 // An encodeState encodes JSON into a bytes.Buffer. 268 type encodeState struct { 269 bytes.Buffer // accumulated output 270 scratch [64]byte 271 } 272 273 var encodeStatePool sync.Pool 274 275 func newEncodeState() *encodeState { 276 if v := encodeStatePool.Get(); v != nil { 277 e := v.(*encodeState) 278 e.Reset() 279 return e 280 } 281 return new(encodeState) 282 } 283 284 func (e *encodeState) marshal(v interface{}, opts encOpts) (err error) { 285 defer func() { 286 if r := recover(); r != nil { 287 if _, ok := r.(runtime.Error); ok { 288 panic(r) 289 } 290 if s, ok := r.(string); ok { 291 panic(s) 292 } 293 err = r.(error) 294 } 295 }() 296 e.reflectValue(reflect.ValueOf(v), opts) 297 return nil 298 } 299 300 func (e *encodeState) error(err error) { 301 panic(err) 302 } 303 304 func isEmptyValue(v reflect.Value) bool { 305 switch v.Kind() { 306 case reflect.Array, reflect.Map, reflect.Slice, reflect.String: 307 return v.Len() == 0 308 case reflect.Bool: 309 return !v.Bool() 310 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 311 return v.Int() == 0 312 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 313 return v.Uint() == 0 314 case reflect.Float32, reflect.Float64: 315 return v.Float() == 0 316 case reflect.Interface, reflect.Ptr: 317 return v.IsNil() 318 } 319 return false 320 } 321 322 func (e *encodeState) reflectValue(v reflect.Value, opts encOpts) { 323 valueEncoder(v)(e, v, opts) 324 } 325 326 type encOpts struct { 327 // quoted causes primitive fields to be encoded inside JSON strings. 328 quoted bool 329 // escapeHTML causes '<', '>', and '&' to be escaped in JSON strings. 330 escapeHTML bool 331 } 332 333 type encoderFunc func(e *encodeState, v reflect.Value, opts encOpts) 334 335 var encoderCache struct { 336 sync.RWMutex 337 m map[reflect.Type]encoderFunc 338 } 339 340 func valueEncoder(v reflect.Value) encoderFunc { 341 if !v.IsValid() { 342 return invalidValueEncoder 343 } 344 return typeEncoder(v.Type()) 345 } 346 347 func typeEncoder(t reflect.Type) encoderFunc { 348 encoderCache.RLock() 349 f := encoderCache.m[t] 350 encoderCache.RUnlock() 351 if f != nil { 352 return f 353 } 354 355 // To deal with recursive types, populate the map with an 356 // indirect func before we build it. This type waits on the 357 // real func (f) to be ready and then calls it. This indirect 358 // func is only used for recursive types. 359 encoderCache.Lock() 360 if encoderCache.m == nil { 361 encoderCache.m = make(map[reflect.Type]encoderFunc) 362 } 363 var wg sync.WaitGroup 364 wg.Add(1) 365 encoderCache.m[t] = func(e *encodeState, v reflect.Value, opts encOpts) { 366 wg.Wait() 367 f(e, v, opts) 368 } 369 encoderCache.Unlock() 370 371 // Compute fields without lock. 372 // Might duplicate effort but won't hold other computations back. 373 f = newTypeEncoder(t, true) 374 wg.Done() 375 encoderCache.Lock() 376 encoderCache.m[t] = f 377 encoderCache.Unlock() 378 return f 379 } 380 381 var ( 382 marshalerType = reflect.TypeOf(new(Marshaler)).Elem() 383 textMarshalerType = reflect.TypeOf(new(encoding.TextMarshaler)).Elem() 384 ) 385 386 // newTypeEncoder constructs an encoderFunc for a type. 387 // The returned encoder only checks CanAddr when allowAddr is true. 388 func newTypeEncoder(t reflect.Type, allowAddr bool) encoderFunc { 389 if t.Implements(marshalerType) { 390 return marshalerEncoder 391 } 392 if t.Kind() != reflect.Ptr && allowAddr { 393 if reflect.PtrTo(t).Implements(marshalerType) { 394 return newCondAddrEncoder(addrMarshalerEncoder, newTypeEncoder(t, false)) 395 } 396 } 397 398 if t.Implements(textMarshalerType) { 399 return textMarshalerEncoder 400 } 401 if t.Kind() != reflect.Ptr && allowAddr { 402 if reflect.PtrTo(t).Implements(textMarshalerType) { 403 return newCondAddrEncoder(addrTextMarshalerEncoder, newTypeEncoder(t, false)) 404 } 405 } 406 407 switch t.Kind() { 408 case reflect.Bool: 409 return boolEncoder 410 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 411 return intEncoder 412 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 413 return uintEncoder 414 case reflect.Float32: 415 return float32Encoder 416 case reflect.Float64: 417 return float64Encoder 418 case reflect.String: 419 return stringEncoder 420 case reflect.Interface: 421 return interfaceEncoder 422 case reflect.Struct: 423 return newStructEncoder(t) 424 case reflect.Map: 425 return newMapEncoder(t) 426 case reflect.Slice: 427 return newSliceEncoder(t) 428 case reflect.Array: 429 return newArrayEncoder(t) 430 case reflect.Ptr: 431 return newPtrEncoder(t) 432 default: 433 return unsupportedTypeEncoder 434 } 435 } 436 437 func invalidValueEncoder(e *encodeState, v reflect.Value, _ encOpts) { 438 e.WriteString("null") 439 } 440 441 func marshalerEncoder(e *encodeState, v reflect.Value, opts encOpts) { 442 if v.Kind() == reflect.Ptr && v.IsNil() { 443 e.WriteString("null") 444 return 445 } 446 m, ok := v.Interface().(Marshaler) 447 if !ok { 448 e.WriteString("null") 449 return 450 } 451 b, err := m.MarshalJSON() 452 if err == nil { 453 // copy JSON into buffer, checking validity. 454 err = compact(&e.Buffer, b, opts.escapeHTML) 455 } 456 if err != nil { 457 e.error(&MarshalerError{v.Type(), err}) 458 } 459 } 460 461 func addrMarshalerEncoder(e *encodeState, v reflect.Value, _ encOpts) { 462 va := v.Addr() 463 if va.IsNil() { 464 e.WriteString("null") 465 return 466 } 467 m := va.Interface().(Marshaler) 468 b, err := m.MarshalJSON() 469 if err == nil { 470 // copy JSON into buffer, checking validity. 471 err = compact(&e.Buffer, b, true) 472 } 473 if err != nil { 474 e.error(&MarshalerError{v.Type(), err}) 475 } 476 } 477 478 func textMarshalerEncoder(e *encodeState, v reflect.Value, opts encOpts) { 479 if v.Kind() == reflect.Ptr && v.IsNil() { 480 e.WriteString("null") 481 return 482 } 483 m := v.Interface().(encoding.TextMarshaler) 484 b, err := m.MarshalText() 485 if err != nil { 486 e.error(&MarshalerError{v.Type(), err}) 487 } 488 e.stringBytes(b, opts.escapeHTML) 489 } 490 491 func addrTextMarshalerEncoder(e *encodeState, v reflect.Value, opts encOpts) { 492 va := v.Addr() 493 if va.IsNil() { 494 e.WriteString("null") 495 return 496 } 497 m := va.Interface().(encoding.TextMarshaler) 498 b, err := m.MarshalText() 499 if err != nil { 500 e.error(&MarshalerError{v.Type(), err}) 501 } 502 e.stringBytes(b, opts.escapeHTML) 503 } 504 505 func boolEncoder(e *encodeState, v reflect.Value, opts encOpts) { 506 if opts.quoted { 507 e.WriteByte('"') 508 } 509 if v.Bool() { 510 e.WriteString("true") 511 } else { 512 e.WriteString("false") 513 } 514 if opts.quoted { 515 e.WriteByte('"') 516 } 517 } 518 519 func intEncoder(e *encodeState, v reflect.Value, opts encOpts) { 520 b := strconv.AppendInt(e.scratch[:0], v.Int(), 10) 521 if opts.quoted { 522 e.WriteByte('"') 523 } 524 e.Write(b) 525 if opts.quoted { 526 e.WriteByte('"') 527 } 528 } 529 530 func uintEncoder(e *encodeState, v reflect.Value, opts encOpts) { 531 b := strconv.AppendUint(e.scratch[:0], v.Uint(), 10) 532 if opts.quoted { 533 e.WriteByte('"') 534 } 535 e.Write(b) 536 if opts.quoted { 537 e.WriteByte('"') 538 } 539 } 540 541 type floatEncoder int // number of bits 542 543 func (bits floatEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) { 544 f := v.Float() 545 if math.IsInf(f, 0) || math.IsNaN(f) { 546 e.error(&UnsupportedValueError{v, strconv.FormatFloat(f, 'g', -1, int(bits))}) 547 } 548 549 // Convert as if by ES6 number to string conversion. 550 // This matches most other JSON generators. 551 // See golang.org/issue/6384 and golang.org/issue/14135. 552 // Like fmt %g, but the exponent cutoffs are different 553 // and exponents themselves are not padded to two digits. 554 b := e.scratch[:0] 555 abs := math.Abs(f) 556 fmt := byte('f') 557 // Note: Must use float32 comparisons for underlying float32 value to get precise cutoffs right. 558 if abs != 0 { 559 if bits == 64 && (abs < 1e-6 || abs >= 1e21) || bits == 32 && (float32(abs) < 1e-6 || float32(abs) >= 1e21) { 560 fmt = 'e' 561 } 562 } 563 b = strconv.AppendFloat(b, f, fmt, -1, int(bits)) 564 if fmt == 'e' { 565 // clean up e-09 to e-9 566 n := len(b) 567 if n >= 4 && b[n-4] == 'e' && b[n-3] == '-' && b[n-2] == '0' { 568 b[n-2] = b[n-1] 569 b = b[:n-1] 570 } 571 } 572 573 if opts.quoted { 574 e.WriteByte('"') 575 } 576 e.Write(b) 577 if opts.quoted { 578 e.WriteByte('"') 579 } 580 } 581 582 var ( 583 float32Encoder = (floatEncoder(32)).encode 584 float64Encoder = (floatEncoder(64)).encode 585 ) 586 587 func stringEncoder(e *encodeState, v reflect.Value, opts encOpts) { 588 if v.Type() == numberType { 589 numStr := v.String() 590 // In Go1.5 the empty string encodes to "0", while this is not a valid number literal 591 // we keep compatibility so check validity after this. 592 if numStr == "" { 593 numStr = "0" // Number's zero-val 594 } 595 if !isValidNumber(numStr) { 596 e.error(fmt.Errorf("json: invalid number literal %q", numStr)) 597 } 598 e.WriteString(numStr) 599 return 600 } 601 if opts.quoted { 602 sb, err := Marshal(v.String()) 603 if err != nil { 604 e.error(err) 605 } 606 e.string(string(sb), opts.escapeHTML) 607 } else { 608 e.string(v.String(), opts.escapeHTML) 609 } 610 } 611 612 func interfaceEncoder(e *encodeState, v reflect.Value, opts encOpts) { 613 if v.IsNil() { 614 e.WriteString("null") 615 return 616 } 617 e.reflectValue(v.Elem(), opts) 618 } 619 620 func unsupportedTypeEncoder(e *encodeState, v reflect.Value, _ encOpts) { 621 e.error(&UnsupportedTypeError{v.Type()}) 622 } 623 624 type structEncoder struct { 625 fields []field 626 fieldEncs []encoderFunc 627 } 628 629 func (se *structEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) { 630 e.WriteByte('{') 631 first := true 632 for i, f := range se.fields { 633 fv := fieldByIndex(v, f.index) 634 if !fv.IsValid() || f.omitEmpty && isEmptyValue(fv) { 635 continue 636 } 637 if first { 638 first = false 639 } else { 640 e.WriteByte(',') 641 } 642 e.string(f.name, opts.escapeHTML) 643 e.WriteByte(':') 644 opts.quoted = f.quoted 645 se.fieldEncs[i](e, fv, opts) 646 } 647 e.WriteByte('}') 648 } 649 650 func newStructEncoder(t reflect.Type) encoderFunc { 651 fields := cachedTypeFields(t) 652 se := &structEncoder{ 653 fields: fields, 654 fieldEncs: make([]encoderFunc, len(fields)), 655 } 656 for i, f := range fields { 657 se.fieldEncs[i] = typeEncoder(typeByIndex(t, f.index)) 658 } 659 return se.encode 660 } 661 662 type mapEncoder struct { 663 elemEnc encoderFunc 664 } 665 666 func (me *mapEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) { 667 if v.IsNil() { 668 e.WriteString("null") 669 return 670 } 671 e.WriteByte('{') 672 673 // Extract and sort the keys. 674 keys := v.MapKeys() 675 sv := make([]reflectWithString, len(keys)) 676 for i, v := range keys { 677 sv[i].v = v 678 if err := sv[i].resolve(); err != nil { 679 e.error(&MarshalerError{v.Type(), err}) 680 } 681 } 682 sort.Slice(sv, func(i, j int) bool { return sv[i].s < sv[j].s }) 683 684 for i, kv := range sv { 685 if i > 0 { 686 e.WriteByte(',') 687 } 688 e.string(kv.s, opts.escapeHTML) 689 e.WriteByte(':') 690 me.elemEnc(e, v.MapIndex(kv.v), opts) 691 } 692 e.WriteByte('}') 693 } 694 695 func newMapEncoder(t reflect.Type) encoderFunc { 696 switch t.Key().Kind() { 697 case reflect.String, 698 reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, 699 reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 700 default: 701 if !t.Key().Implements(textMarshalerType) { 702 return unsupportedTypeEncoder 703 } 704 } 705 me := &mapEncoder{typeEncoder(t.Elem())} 706 return me.encode 707 } 708 709 func encodeByteSlice(e *encodeState, v reflect.Value, _ encOpts) { 710 if v.IsNil() { 711 e.WriteString("null") 712 return 713 } 714 s := v.Bytes() 715 e.WriteByte('"') 716 if len(s) < 1024 { 717 // for small buffers, using Encode directly is much faster. 718 dst := make([]byte, base64.StdEncoding.EncodedLen(len(s))) 719 base64.StdEncoding.Encode(dst, s) 720 e.Write(dst) 721 } else { 722 // for large buffers, avoid unnecessary extra temporary 723 // buffer space. 724 enc := base64.NewEncoder(base64.StdEncoding, e) 725 enc.Write(s) 726 enc.Close() 727 } 728 e.WriteByte('"') 729 } 730 731 // sliceEncoder just wraps an arrayEncoder, checking to make sure the value isn't nil. 732 type sliceEncoder struct { 733 arrayEnc encoderFunc 734 } 735 736 func (se *sliceEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) { 737 if v.IsNil() { 738 e.WriteString("null") 739 return 740 } 741 se.arrayEnc(e, v, opts) 742 } 743 744 func newSliceEncoder(t reflect.Type) encoderFunc { 745 // Byte slices get special treatment; arrays don't. 746 if t.Elem().Kind() == reflect.Uint8 { 747 p := reflect.PtrTo(t.Elem()) 748 if !p.Implements(marshalerType) && !p.Implements(textMarshalerType) { 749 return encodeByteSlice 750 } 751 } 752 enc := &sliceEncoder{newArrayEncoder(t)} 753 return enc.encode 754 } 755 756 type arrayEncoder struct { 757 elemEnc encoderFunc 758 } 759 760 func (ae *arrayEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) { 761 e.WriteByte('[') 762 n := v.Len() 763 for i := 0; i < n; i++ { 764 if i > 0 { 765 e.WriteByte(',') 766 } 767 ae.elemEnc(e, v.Index(i), opts) 768 } 769 e.WriteByte(']') 770 } 771 772 func newArrayEncoder(t reflect.Type) encoderFunc { 773 enc := &arrayEncoder{typeEncoder(t.Elem())} 774 return enc.encode 775 } 776 777 type ptrEncoder struct { 778 elemEnc encoderFunc 779 } 780 781 func (pe *ptrEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) { 782 if v.IsNil() { 783 e.WriteString("null") 784 return 785 } 786 pe.elemEnc(e, v.Elem(), opts) 787 } 788 789 func newPtrEncoder(t reflect.Type) encoderFunc { 790 enc := &ptrEncoder{typeEncoder(t.Elem())} 791 return enc.encode 792 } 793 794 type condAddrEncoder struct { 795 canAddrEnc, elseEnc encoderFunc 796 } 797 798 func (ce *condAddrEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) { 799 if v.CanAddr() { 800 ce.canAddrEnc(e, v, opts) 801 } else { 802 ce.elseEnc(e, v, opts) 803 } 804 } 805 806 // newCondAddrEncoder returns an encoder that checks whether its value 807 // CanAddr and delegates to canAddrEnc if so, else to elseEnc. 808 func newCondAddrEncoder(canAddrEnc, elseEnc encoderFunc) encoderFunc { 809 enc := &condAddrEncoder{canAddrEnc: canAddrEnc, elseEnc: elseEnc} 810 return enc.encode 811 } 812 813 func isValidTag(s string) bool { 814 if s == "" { 815 return false 816 } 817 for _, c := range s { 818 switch { 819 case strings.ContainsRune("!#$%&()*+-./:<=>?@[]^_{|}~ ", c): 820 // Backslash and quote chars are reserved, but 821 // otherwise any punctuation chars are allowed 822 // in a tag name. 823 default: 824 if !unicode.IsLetter(c) && !unicode.IsDigit(c) { 825 return false 826 } 827 } 828 } 829 return true 830 } 831 832 func fieldByIndex(v reflect.Value, index []int) reflect.Value { 833 for _, i := range index { 834 if v.Kind() == reflect.Ptr { 835 if v.IsNil() { 836 return reflect.Value{} 837 } 838 v = v.Elem() 839 } 840 v = v.Field(i) 841 } 842 return v 843 } 844 845 func typeByIndex(t reflect.Type, index []int) reflect.Type { 846 for _, i := range index { 847 if t.Kind() == reflect.Ptr { 848 t = t.Elem() 849 } 850 t = t.Field(i).Type 851 } 852 return t 853 } 854 855 type reflectWithString struct { 856 v reflect.Value 857 s string 858 } 859 860 func (w *reflectWithString) resolve() error { 861 if w.v.Kind() == reflect.String { 862 w.s = w.v.String() 863 return nil 864 } 865 if tm, ok := w.v.Interface().(encoding.TextMarshaler); ok { 866 buf, err := tm.MarshalText() 867 w.s = string(buf) 868 return err 869 } 870 switch w.v.Kind() { 871 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 872 w.s = strconv.FormatInt(w.v.Int(), 10) 873 return nil 874 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 875 w.s = strconv.FormatUint(w.v.Uint(), 10) 876 return nil 877 } 878 panic("unexpected map key type") 879 } 880 881 // NOTE: keep in sync with stringBytes below. 882 func (e *encodeState) string(s string, escapeHTML bool) int { 883 len0 := e.Len() 884 e.WriteByte('"') 885 start := 0 886 for i := 0; i < len(s); { 887 if b := s[i]; b < utf8.RuneSelf { 888 if htmlSafeSet[b] || (!escapeHTML && safeSet[b]) { 889 i++ 890 continue 891 } 892 if start < i { 893 e.WriteString(s[start:i]) 894 } 895 switch b { 896 case '\\', '"': 897 e.WriteByte('\\') 898 e.WriteByte(b) 899 case '\n': 900 e.WriteByte('\\') 901 e.WriteByte('n') 902 case '\r': 903 e.WriteByte('\\') 904 e.WriteByte('r') 905 case '\t': 906 e.WriteByte('\\') 907 e.WriteByte('t') 908 default: 909 // This encodes bytes < 0x20 except for \t, \n and \r. 910 // If escapeHTML is set, it also escapes <, >, and & 911 // because they can lead to security holes when 912 // user-controlled strings are rendered into JSON 913 // and served to some browsers. 914 e.WriteString(`\u00`) 915 e.WriteByte(hex[b>>4]) 916 e.WriteByte(hex[b&0xF]) 917 } 918 i++ 919 start = i 920 continue 921 } 922 c, size := utf8.DecodeRuneInString(s[i:]) 923 if c == utf8.RuneError && size == 1 { 924 if start < i { 925 e.WriteString(s[start:i]) 926 } 927 e.WriteString(`\ufffd`) 928 i += size 929 start = i 930 continue 931 } 932 // U+2028 is LINE SEPARATOR. 933 // U+2029 is PARAGRAPH SEPARATOR. 934 // They are both technically valid characters in JSON strings, 935 // but don't work in JSONP, which has to be evaluated as JavaScript, 936 // and can lead to security holes there. It is valid JSON to 937 // escape them, so we do so unconditionally. 938 // See http://timelessrepo.com/json-isnt-a-javascript-subset for discussion. 939 if c == '\u2028' || c == '\u2029' { 940 if start < i { 941 e.WriteString(s[start:i]) 942 } 943 e.WriteString(`\u202`) 944 e.WriteByte(hex[c&0xF]) 945 i += size 946 start = i 947 continue 948 } 949 i += size 950 } 951 if start < len(s) { 952 e.WriteString(s[start:]) 953 } 954 e.WriteByte('"') 955 return e.Len() - len0 956 } 957 958 // NOTE: keep in sync with string above. 959 func (e *encodeState) stringBytes(s []byte, escapeHTML bool) int { 960 len0 := e.Len() 961 e.WriteByte('"') 962 start := 0 963 for i := 0; i < len(s); { 964 if b := s[i]; b < utf8.RuneSelf { 965 if htmlSafeSet[b] || (!escapeHTML && safeSet[b]) { 966 i++ 967 continue 968 } 969 if start < i { 970 e.Write(s[start:i]) 971 } 972 switch b { 973 case '\\', '"': 974 e.WriteByte('\\') 975 e.WriteByte(b) 976 case '\n': 977 e.WriteByte('\\') 978 e.WriteByte('n') 979 case '\r': 980 e.WriteByte('\\') 981 e.WriteByte('r') 982 case '\t': 983 e.WriteByte('\\') 984 e.WriteByte('t') 985 default: 986 // This encodes bytes < 0x20 except for \t, \n and \r. 987 // If escapeHTML is set, it also escapes <, >, and & 988 // because they can lead to security holes when 989 // user-controlled strings are rendered into JSON 990 // and served to some browsers. 991 e.WriteString(`\u00`) 992 e.WriteByte(hex[b>>4]) 993 e.WriteByte(hex[b&0xF]) 994 } 995 i++ 996 start = i 997 continue 998 } 999 c, size := utf8.DecodeRune(s[i:]) 1000 if c == utf8.RuneError && size == 1 { 1001 if start < i { 1002 e.Write(s[start:i]) 1003 } 1004 e.WriteString(`\ufffd`) 1005 i += size 1006 start = i 1007 continue 1008 } 1009 // U+2028 is LINE SEPARATOR. 1010 // U+2029 is PARAGRAPH SEPARATOR. 1011 // They are both technically valid characters in JSON strings, 1012 // but don't work in JSONP, which has to be evaluated as JavaScript, 1013 // and can lead to security holes there. It is valid JSON to 1014 // escape them, so we do so unconditionally. 1015 // See http://timelessrepo.com/json-isnt-a-javascript-subset for discussion. 1016 if c == '\u2028' || c == '\u2029' { 1017 if start < i { 1018 e.Write(s[start:i]) 1019 } 1020 e.WriteString(`\u202`) 1021 e.WriteByte(hex[c&0xF]) 1022 i += size 1023 start = i 1024 continue 1025 } 1026 i += size 1027 } 1028 if start < len(s) { 1029 e.Write(s[start:]) 1030 } 1031 e.WriteByte('"') 1032 return e.Len() - len0 1033 } 1034 1035 // A field represents a single field found in a struct. 1036 type field struct { 1037 name string 1038 nameBytes []byte // []byte(name) 1039 equalFold func(s, t []byte) bool // bytes.EqualFold or equivalent 1040 1041 tag bool 1042 index []int 1043 typ reflect.Type 1044 omitEmpty bool 1045 quoted bool 1046 } 1047 1048 func fillField(f field) field { 1049 f.nameBytes = []byte(f.name) 1050 f.equalFold = foldFunc(f.nameBytes) 1051 return f 1052 } 1053 1054 // byIndex sorts field by index sequence. 1055 type byIndex []field 1056 1057 func (x byIndex) Len() int { return len(x) } 1058 1059 func (x byIndex) Swap(i, j int) { x[i], x[j] = x[j], x[i] } 1060 1061 func (x byIndex) Less(i, j int) bool { 1062 for k, xik := range x[i].index { 1063 if k >= len(x[j].index) { 1064 return false 1065 } 1066 if xik != x[j].index[k] { 1067 return xik < x[j].index[k] 1068 } 1069 } 1070 return len(x[i].index) < len(x[j].index) 1071 } 1072 1073 // typeFields returns a list of fields that JSON should recognize for the given type. 1074 // The algorithm is breadth-first search over the set of structs to include - the top struct 1075 // and then any reachable anonymous structs. 1076 func typeFields(t reflect.Type) []field { 1077 // Anonymous fields to explore at the current level and the next. 1078 current := []field{} 1079 next := []field{{typ: t}} 1080 1081 // Count of queued names for current level and the next. 1082 count := map[reflect.Type]int{} 1083 nextCount := map[reflect.Type]int{} 1084 1085 // Types already visited at an earlier level. 1086 visited := map[reflect.Type]bool{} 1087 1088 // Fields found. 1089 var fields []field 1090 1091 for len(next) > 0 { 1092 current, next = next, current[:0] 1093 count, nextCount = nextCount, map[reflect.Type]int{} 1094 1095 for _, f := range current { 1096 if visited[f.typ] { 1097 continue 1098 } 1099 visited[f.typ] = true 1100 1101 // Scan f.typ for fields to include. 1102 for i := 0; i < f.typ.NumField(); i++ { 1103 sf := f.typ.Field(i) 1104 if sf.PkgPath != "" && !sf.Anonymous { // unexported 1105 continue 1106 } 1107 tag := sf.Tag.Get("json") 1108 if tag == "-" { 1109 continue 1110 } 1111 name, opts := parseTag(tag) 1112 if !isValidTag(name) { 1113 name = "" 1114 } 1115 index := make([]int, len(f.index)+1) 1116 copy(index, f.index) 1117 index[len(f.index)] = i 1118 1119 ft := sf.Type 1120 if ft.Name() == "" && ft.Kind() == reflect.Ptr { 1121 // Follow pointer. 1122 ft = ft.Elem() 1123 } 1124 1125 // Only strings, floats, integers, and booleans can be quoted. 1126 quoted := false 1127 if opts.Contains("string") { 1128 switch ft.Kind() { 1129 case reflect.Bool, 1130 reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, 1131 reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, 1132 reflect.Float32, reflect.Float64, 1133 reflect.String: 1134 quoted = true 1135 } 1136 } 1137 1138 // Record found field and index sequence. 1139 if name != "" || !sf.Anonymous || ft.Kind() != reflect.Struct { 1140 tagged := name != "" 1141 if name == "" { 1142 name = sf.Name 1143 } 1144 fields = append(fields, fillField(field{ 1145 name: name, 1146 tag: tagged, 1147 index: index, 1148 typ: ft, 1149 omitEmpty: opts.Contains("omitempty"), 1150 quoted: quoted, 1151 })) 1152 if count[f.typ] > 1 { 1153 // If there were multiple instances, add a second, 1154 // so that the annihilation code will see a duplicate. 1155 // It only cares about the distinction between 1 or 2, 1156 // so don't bother generating any more copies. 1157 fields = append(fields, fields[len(fields)-1]) 1158 } 1159 continue 1160 } 1161 1162 // Record new anonymous struct to explore in next round. 1163 nextCount[ft]++ 1164 if nextCount[ft] == 1 { 1165 next = append(next, fillField(field{name: ft.Name(), index: index, typ: ft})) 1166 } 1167 } 1168 } 1169 } 1170 1171 sort.Slice(fields, func(i, j int) bool { 1172 x := fields 1173 // sort field by name, breaking ties with depth, then 1174 // breaking ties with "name came from json tag", then 1175 // breaking ties with index sequence. 1176 if x[i].name != x[j].name { 1177 return x[i].name < x[j].name 1178 } 1179 if len(x[i].index) != len(x[j].index) { 1180 return len(x[i].index) < len(x[j].index) 1181 } 1182 if x[i].tag != x[j].tag { 1183 return x[i].tag 1184 } 1185 return byIndex(x).Less(i, j) 1186 }) 1187 1188 // Delete all fields that are hidden by the Go rules for embedded fields, 1189 // except that fields with JSON tags are promoted. 1190 1191 // The fields are sorted in primary order of name, secondary order 1192 // of field index length. Loop over names; for each name, delete 1193 // hidden fields by choosing the one dominant field that survives. 1194 out := fields[:0] 1195 for advance, i := 0, 0; i < len(fields); i += advance { 1196 // One iteration per name. 1197 // Find the sequence of fields with the name of this first field. 1198 fi := fields[i] 1199 name := fi.name 1200 for advance = 1; i+advance < len(fields); advance++ { 1201 fj := fields[i+advance] 1202 if fj.name != name { 1203 break 1204 } 1205 } 1206 if advance == 1 { // Only one field with this name 1207 out = append(out, fi) 1208 continue 1209 } 1210 dominant, ok := dominantField(fields[i : i+advance]) 1211 if ok { 1212 out = append(out, dominant) 1213 } 1214 } 1215 1216 fields = out 1217 sort.Sort(byIndex(fields)) 1218 1219 return fields 1220 } 1221 1222 // dominantField looks through the fields, all of which are known to 1223 // have the same name, to find the single field that dominates the 1224 // others using Go's embedding rules, modified by the presence of 1225 // JSON tags. If there are multiple top-level fields, the boolean 1226 // will be false: This condition is an error in Go and we skip all 1227 // the fields. 1228 func dominantField(fields []field) (field, bool) { 1229 // The fields are sorted in increasing index-length order. The winner 1230 // must therefore be one with the shortest index length. Drop all 1231 // longer entries, which is easy: just truncate the slice. 1232 length := len(fields[0].index) 1233 tagged := -1 // Index of first tagged field. 1234 for i, f := range fields { 1235 if len(f.index) > length { 1236 fields = fields[:i] 1237 break 1238 } 1239 if f.tag { 1240 if tagged >= 0 { 1241 // Multiple tagged fields at the same level: conflict. 1242 // Return no field. 1243 return field{}, false 1244 } 1245 tagged = i 1246 } 1247 } 1248 if tagged >= 0 { 1249 return fields[tagged], true 1250 } 1251 // All remaining fields have the same length. If there's more than one, 1252 // we have a conflict (two fields named "X" at the same level) and we 1253 // return no field. 1254 if len(fields) > 1 { 1255 return field{}, false 1256 } 1257 return fields[0], true 1258 } 1259 1260 var fieldCache struct { 1261 value atomic.Value // map[reflect.Type][]field 1262 mu sync.Mutex // used only by writers 1263 } 1264 1265 // cachedTypeFields is like typeFields but uses a cache to avoid repeated work. 1266 func cachedTypeFields(t reflect.Type) []field { 1267 m, _ := fieldCache.value.Load().(map[reflect.Type][]field) 1268 f := m[t] 1269 if f != nil { 1270 return f 1271 } 1272 1273 // Compute fields without lock. 1274 // Might duplicate effort but won't hold other computations back. 1275 f = typeFields(t) 1276 if f == nil { 1277 f = []field{} 1278 } 1279 1280 fieldCache.mu.Lock() 1281 m, _ = fieldCache.value.Load().(map[reflect.Type][]field) 1282 newM := make(map[reflect.Type][]field, len(m)+1) 1283 for k, v := range m { 1284 newM[k] = v 1285 } 1286 newM[t] = f 1287 fieldCache.value.Store(newM) 1288 fieldCache.mu.Unlock() 1289 return f 1290 } 1291