decode.go 37 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153
  1. // Copyright 2020 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. package jsontext
  5. import (
  6. "bytes"
  7. "errors"
  8. "io"
  9. "github.com/go-json-experiment/json/internal/jsonflags"
  10. "github.com/go-json-experiment/json/internal/jsonopts"
  11. "github.com/go-json-experiment/json/internal/jsonwire"
  12. )
  13. // NOTE: The logic for decoding is complicated by the fact that reading from
  14. // an io.Reader into a temporary buffer means that the buffer may contain a
  15. // truncated portion of some valid input, requiring the need to fetch more data.
  16. //
  17. // This file is structured in the following way:
  18. //
  19. // - consumeXXX functions parse an exact JSON token from a []byte.
  20. // If the buffer appears truncated, then it returns io.ErrUnexpectedEOF.
  21. // The consumeSimpleXXX functions are so named because they only handle
  22. // a subset of the grammar for the JSON token being parsed.
  23. // They do not handle the full grammar to keep these functions inlinable.
  24. //
  25. // - Decoder.consumeXXX methods parse the next JSON token from Decoder.buf,
  26. // automatically fetching more input if necessary. These methods take
  27. // a position relative to the start of Decoder.buf as an argument and
  28. // return the end of the consumed JSON token as a position,
  29. // also relative to the start of Decoder.buf.
  30. //
  31. // - In the event of an I/O errors or state machine violations,
  32. // the implementation avoids mutating the state of Decoder
  33. // (aside from the book-keeping needed to implement Decoder.fetch).
  34. // For this reason, only Decoder.ReadToken and Decoder.ReadValue are
  35. // responsible for updated Decoder.prevStart and Decoder.prevEnd.
  36. //
  37. // - For performance, much of the implementation uses the pattern of calling
  38. // the inlinable consumeXXX functions first, and if more work is necessary,
  39. // then it calls the slower Decoder.consumeXXX methods.
  40. // TODO: Revisit this pattern if the Go compiler provides finer control
  41. // over exactly which calls are inlined or not.
  42. // Decoder is a streaming decoder for raw JSON tokens and values.
  43. // It is used to read a stream of top-level JSON values,
  44. // each separated by optional whitespace characters.
  45. //
  46. // [Decoder.ReadToken] and [Decoder.ReadValue] calls may be interleaved.
  47. // For example, the following JSON value:
  48. //
  49. // {"name":"value","array":[null,false,true,3.14159],"object":{"k":"v"}}
  50. //
  51. // can be parsed with the following calls (ignoring errors for brevity):
  52. //
  53. // d.ReadToken() // {
  54. // d.ReadToken() // "name"
  55. // d.ReadToken() // "value"
  56. // d.ReadValue() // "array"
  57. // d.ReadToken() // [
  58. // d.ReadToken() // null
  59. // d.ReadToken() // false
  60. // d.ReadValue() // true
  61. // d.ReadToken() // 3.14159
  62. // d.ReadToken() // ]
  63. // d.ReadValue() // "object"
  64. // d.ReadValue() // {"k":"v"}
  65. // d.ReadToken() // }
  66. //
  67. // The above is one of many possible sequence of calls and
  68. // may not represent the most sensible method to call for any given token/value.
  69. // For example, it is probably more common to call [Decoder.ReadToken] to obtain a
  70. // string token for object names.
  71. type Decoder struct {
  72. s decoderState
  73. }
  74. // decoderState is the low-level state of Decoder.
  75. // It has exported fields and method for use by the "json" package.
  76. type decoderState struct {
  77. state
  78. decodeBuffer
  79. jsonopts.Struct
  80. StringCache *[256]string // only used when unmarshaling; identical to json.stringCache
  81. }
  82. // decodeBuffer is a buffer split into 4 segments:
  83. //
  84. // - buf[0:prevEnd] // already read portion of the buffer
  85. // - buf[prevStart:prevEnd] // previously read value
  86. // - buf[prevEnd:len(buf)] // unread portion of the buffer
  87. // - buf[len(buf):cap(buf)] // unused portion of the buffer
  88. //
  89. // Invariants:
  90. //
  91. // 0 ≤ prevStart ≤ prevEnd ≤ len(buf) ≤ cap(buf)
  92. type decodeBuffer struct {
  93. peekPos int // non-zero if valid offset into buf for start of next token
  94. peekErr error // implies peekPos is -1
  95. buf []byte // may alias rd if it is a bytes.Buffer
  96. prevStart int
  97. prevEnd int
  98. // baseOffset is added to prevStart and prevEnd to obtain
  99. // the absolute offset relative to the start of io.Reader stream.
  100. baseOffset int64
  101. rd io.Reader
  102. }
  103. // NewDecoder constructs a new streaming decoder reading from r.
  104. //
  105. // If r is a [bytes.Buffer], then the decoder parses directly from the buffer
  106. // without first copying the contents to an intermediate buffer.
  107. // Additional writes to the buffer must not occur while the decoder is in use.
  108. func NewDecoder(r io.Reader, opts ...Options) *Decoder {
  109. d := new(Decoder)
  110. d.Reset(r, opts...)
  111. return d
  112. }
  113. // Reset resets a decoder such that it is reading afresh from r and
  114. // configured with the provided options. Reset must not be called on an
  115. // a Decoder passed to the [encoding/json/v2.UnmarshalerFrom.UnmarshalJSONFrom] method
  116. // or the [encoding/json/v2.UnmarshalFromFunc] function.
  117. func (d *Decoder) Reset(r io.Reader, opts ...Options) {
  118. switch {
  119. case d == nil:
  120. panic("jsontext: invalid nil Decoder")
  121. case r == nil:
  122. panic("jsontext: invalid nil io.Reader")
  123. case d.s.Flags.Get(jsonflags.WithinArshalCall):
  124. panic("jsontext: cannot reset Decoder passed to json.UnmarshalerFrom")
  125. }
  126. d.s.reset(nil, r, opts...)
  127. }
  128. func (d *decoderState) reset(b []byte, r io.Reader, opts ...Options) {
  129. d.state.reset()
  130. d.decodeBuffer = decodeBuffer{buf: b, rd: r}
  131. d.Struct = jsonopts.Struct{}
  132. d.Struct.Join(opts...)
  133. }
  134. var errBufferWriteAfterNext = errors.New("invalid bytes.Buffer.Write call after calling bytes.Buffer.Next")
  135. // fetch reads at least 1 byte from the underlying io.Reader.
  136. // It returns io.ErrUnexpectedEOF if zero bytes were read and io.EOF was seen.
  137. func (d *decoderState) fetch() error {
  138. if d.rd == nil {
  139. return io.ErrUnexpectedEOF
  140. }
  141. // Inform objectNameStack that we are about to fetch new buffer content.
  142. d.Names.copyQuotedBuffer(d.buf)
  143. // Specialize bytes.Buffer for better performance.
  144. if bb, ok := d.rd.(*bytes.Buffer); ok {
  145. switch {
  146. case bb.Len() == 0:
  147. return io.ErrUnexpectedEOF
  148. case len(d.buf) == 0:
  149. d.buf = bb.Next(bb.Len()) // "read" all data in the buffer
  150. return nil
  151. default:
  152. // This only occurs if a partially filled bytes.Buffer was provided
  153. // and more data is written to it while Decoder is reading from it.
  154. // This practice will lead to data corruption since future writes
  155. // may overwrite the contents of the current buffer.
  156. //
  157. // The user is trying to use a bytes.Buffer as a pipe,
  158. // but a bytes.Buffer is poor implementation of a pipe,
  159. // the purpose-built io.Pipe should be used instead.
  160. return &ioError{action: "read", err: errBufferWriteAfterNext}
  161. }
  162. }
  163. // Allocate initial buffer if empty.
  164. if cap(d.buf) == 0 {
  165. d.buf = make([]byte, 0, 64)
  166. }
  167. // Check whether to grow the buffer.
  168. const maxBufferSize = 4 << 10
  169. const growthSizeFactor = 2 // higher value is faster
  170. const growthRateFactor = 2 // higher value is slower
  171. // By default, grow if below the maximum buffer size.
  172. grow := cap(d.buf) <= maxBufferSize/growthSizeFactor
  173. // Growing can be expensive, so only grow
  174. // if a sufficient number of bytes have been processed.
  175. grow = grow && int64(cap(d.buf)) < d.previousOffsetEnd()/growthRateFactor
  176. // If prevStart==0, then fetch was called in order to fetch more data
  177. // to finish consuming a large JSON value contiguously.
  178. // Grow if less than 25% of the remaining capacity is available.
  179. // Note that this may cause the input buffer to exceed maxBufferSize.
  180. grow = grow || (d.prevStart == 0 && len(d.buf) >= 3*cap(d.buf)/4)
  181. if grow {
  182. // Allocate a new buffer and copy the contents of the old buffer over.
  183. // TODO: Provide a hard limit on the maximum internal buffer size?
  184. buf := make([]byte, 0, cap(d.buf)*growthSizeFactor)
  185. d.buf = append(buf, d.buf[d.prevStart:]...)
  186. } else {
  187. // Move unread portion of the data to the front.
  188. n := copy(d.buf[:cap(d.buf)], d.buf[d.prevStart:])
  189. d.buf = d.buf[:n]
  190. }
  191. d.baseOffset += int64(d.prevStart)
  192. d.prevEnd -= d.prevStart
  193. d.prevStart = 0
  194. // Read more data into the internal buffer.
  195. for {
  196. n, err := d.rd.Read(d.buf[len(d.buf):cap(d.buf)])
  197. switch {
  198. case n > 0:
  199. d.buf = d.buf[:len(d.buf)+n]
  200. return nil // ignore errors if any bytes are read
  201. case err == io.EOF:
  202. return io.ErrUnexpectedEOF
  203. case err != nil:
  204. return &ioError{action: "read", err: err}
  205. default:
  206. continue // Read returned (0, nil)
  207. }
  208. }
  209. }
  210. const invalidateBufferByte = '#' // invalid starting character for JSON grammar
  211. // invalidatePreviousRead invalidates buffers returned by Peek and Read calls
  212. // so that the first byte is an invalid character.
  213. // This Hyrum-proofs the API against faulty application code that assumes
  214. // values returned by ReadValue remain valid past subsequent Read calls.
  215. func (d *decodeBuffer) invalidatePreviousRead() {
  216. // Avoid mutating the buffer if d.rd is nil which implies that d.buf
  217. // is provided by the user code and may not expect mutations.
  218. isBytesBuffer := func(r io.Reader) bool {
  219. _, ok := r.(*bytes.Buffer)
  220. return ok
  221. }
  222. if d.rd != nil && !isBytesBuffer(d.rd) && d.prevStart < d.prevEnd && uint(d.prevStart) < uint(len(d.buf)) {
  223. d.buf[d.prevStart] = invalidateBufferByte
  224. d.prevStart = d.prevEnd
  225. }
  226. }
  227. // needMore reports whether there are no more unread bytes.
  228. func (d *decodeBuffer) needMore(pos int) bool {
  229. // NOTE: The arguments and logic are kept simple to keep this inlinable.
  230. return pos == len(d.buf)
  231. }
  232. func (d *decodeBuffer) offsetAt(pos int) int64 { return d.baseOffset + int64(pos) }
  233. func (d *decodeBuffer) previousOffsetStart() int64 { return d.baseOffset + int64(d.prevStart) }
  234. func (d *decodeBuffer) previousOffsetEnd() int64 { return d.baseOffset + int64(d.prevEnd) }
  235. func (d *decodeBuffer) previousBuffer() []byte { return d.buf[d.prevStart:d.prevEnd] }
  236. func (d *decodeBuffer) unreadBuffer() []byte { return d.buf[d.prevEnd:len(d.buf)] }
  237. // PreviousTokenOrValue returns the previously read token or value
  238. // unless it has been invalidated by a call to PeekKind.
  239. // If a token is just a delimiter, then this returns a 1-byte buffer.
  240. // This method is used for error reporting at the semantic layer.
  241. func (d *decodeBuffer) PreviousTokenOrValue() []byte {
  242. b := d.previousBuffer()
  243. // If peek was called, then the previous token or buffer is invalidated.
  244. if d.peekPos > 0 || len(b) > 0 && b[0] == invalidateBufferByte {
  245. return nil
  246. }
  247. // ReadToken does not preserve the buffer for null, bools, or delimiters.
  248. // Manually re-construct that buffer.
  249. if len(b) == 0 {
  250. b = d.buf[:d.prevEnd] // entirety of the previous buffer
  251. for _, tok := range []string{"null", "false", "true", "{", "}", "[", "]"} {
  252. if len(b) >= len(tok) && string(b[len(b)-len(tok):]) == tok {
  253. return b[len(b)-len(tok):]
  254. }
  255. }
  256. }
  257. return b
  258. }
  259. // PeekKind retrieves the next token kind, but does not advance the read offset.
  260. //
  261. // It returns 0 if an error occurs. Any such error is cached until
  262. // the next read call and it is the caller's responsibility to eventually
  263. // follow up a PeekKind call with a read call.
  264. func (d *Decoder) PeekKind() Kind {
  265. return d.s.PeekKind()
  266. }
  267. func (d *decoderState) PeekKind() Kind {
  268. // Check whether we have a cached peek result.
  269. if d.peekPos > 0 {
  270. return Kind(d.buf[d.peekPos]).normalize()
  271. }
  272. var err error
  273. d.invalidatePreviousRead()
  274. pos := d.prevEnd
  275. // Consume leading whitespace.
  276. pos += jsonwire.ConsumeWhitespace(d.buf[pos:])
  277. if d.needMore(pos) {
  278. if pos, err = d.consumeWhitespace(pos); err != nil {
  279. if err == io.ErrUnexpectedEOF && d.Tokens.Depth() == 1 {
  280. err = io.EOF // EOF possibly if no Tokens present after top-level value
  281. }
  282. d.peekPos, d.peekErr = -1, wrapSyntacticError(d, err, pos, 0)
  283. return invalidKind
  284. }
  285. }
  286. // Consume colon or comma.
  287. var delim byte
  288. if c := d.buf[pos]; c == ':' || c == ',' {
  289. delim = c
  290. pos += 1
  291. pos += jsonwire.ConsumeWhitespace(d.buf[pos:])
  292. if d.needMore(pos) {
  293. if pos, err = d.consumeWhitespace(pos); err != nil {
  294. err = wrapSyntacticError(d, err, pos, 0)
  295. d.peekPos, d.peekErr = -1, d.checkDelimBeforeIOError(delim, err)
  296. return invalidKind
  297. }
  298. }
  299. }
  300. next := Kind(d.buf[pos]).normalize()
  301. if d.Tokens.needDelim(next) != delim {
  302. d.peekPos, d.peekErr = -1, d.checkDelim(delim, next)
  303. return invalidKind
  304. }
  305. // This may set peekPos to zero, which is indistinguishable from
  306. // the uninitialized state. While a small hit to performance, it is correct
  307. // since ReadValue and ReadToken will disregard the cached result and
  308. // recompute the next kind.
  309. d.peekPos, d.peekErr = pos, nil
  310. return next
  311. }
  312. // checkDelimBeforeIOError checks whether the delim is even valid
  313. // before returning an IO error, which occurs after the delim.
  314. func (d *decoderState) checkDelimBeforeIOError(delim byte, err error) error {
  315. // Since an IO error occurred, we do not know what the next kind is.
  316. // However, knowing the next kind is necessary to validate
  317. // whether the current delim is at least potentially valid.
  318. // Since a JSON string is always valid as the next token,
  319. // conservatively assume that is the next kind for validation.
  320. const next = Kind('"')
  321. if d.Tokens.needDelim(next) != delim {
  322. err = d.checkDelim(delim, next)
  323. }
  324. return err
  325. }
  326. // CountNextDelimWhitespace counts the number of upcoming bytes of
  327. // delimiter or whitespace characters.
  328. // This method is used for error reporting at the semantic layer.
  329. func (d *decoderState) CountNextDelimWhitespace() int {
  330. d.PeekKind() // populate unreadBuffer
  331. return len(d.unreadBuffer()) - len(bytes.TrimLeft(d.unreadBuffer(), ",: \n\r\t"))
  332. }
  333. // checkDelim checks whether delim is valid for the given next kind.
  334. func (d *decoderState) checkDelim(delim byte, next Kind) error {
  335. where := "at start of value"
  336. switch d.Tokens.needDelim(next) {
  337. case delim:
  338. return nil
  339. case ':':
  340. where = "after object name (expecting ':')"
  341. case ',':
  342. if d.Tokens.Last.isObject() {
  343. where = "after object value (expecting ',' or '}')"
  344. } else {
  345. where = "after array element (expecting ',' or ']')"
  346. }
  347. }
  348. pos := d.prevEnd // restore position to right after leading whitespace
  349. pos += jsonwire.ConsumeWhitespace(d.buf[pos:])
  350. err := jsonwire.NewInvalidCharacterError(d.buf[pos:], where)
  351. return wrapSyntacticError(d, err, pos, 0)
  352. }
  353. // SkipValue is semantically equivalent to calling [Decoder.ReadValue] and discarding
  354. // the result except that memory is not wasted trying to hold the entire result.
  355. func (d *Decoder) SkipValue() error {
  356. return d.s.SkipValue()
  357. }
  358. func (d *decoderState) SkipValue() error {
  359. switch d.PeekKind() {
  360. case '{', '[':
  361. // For JSON objects and arrays, keep skipping all tokens
  362. // until the depth matches the starting depth.
  363. depth := d.Tokens.Depth()
  364. for {
  365. if _, err := d.ReadToken(); err != nil {
  366. return err
  367. }
  368. if depth >= d.Tokens.Depth() {
  369. return nil
  370. }
  371. }
  372. default:
  373. // Trying to skip a value when the next token is a '}' or ']'
  374. // will result in an error being returned here.
  375. var flags jsonwire.ValueFlags
  376. if _, err := d.ReadValue(&flags); err != nil {
  377. return err
  378. }
  379. return nil
  380. }
  381. }
  382. // SkipValueRemainder skips the remainder of a value
  383. // after reading a '{' or '[' token.
  384. func (d *decoderState) SkipValueRemainder() error {
  385. if d.Tokens.Depth()-1 > 0 && d.Tokens.Last.Length() == 0 {
  386. for n := d.Tokens.Depth(); d.Tokens.Depth() >= n; {
  387. if _, err := d.ReadToken(); err != nil {
  388. return err
  389. }
  390. }
  391. }
  392. return nil
  393. }
  394. // SkipUntil skips all tokens until the state machine
  395. // is at or past the specified depth and length.
  396. func (d *decoderState) SkipUntil(depth int, length int64) error {
  397. for d.Tokens.Depth() > depth || (d.Tokens.Depth() == depth && d.Tokens.Last.Length() < length) {
  398. if _, err := d.ReadToken(); err != nil {
  399. return err
  400. }
  401. }
  402. return nil
  403. }
  404. // ReadToken reads the next [Token], advancing the read offset.
  405. // The returned token is only valid until the next Peek, Read, or Skip call.
  406. // It returns [io.EOF] if there are no more tokens.
  407. func (d *Decoder) ReadToken() (Token, error) {
  408. return d.s.ReadToken()
  409. }
  410. func (d *decoderState) ReadToken() (Token, error) {
  411. // Determine the next kind.
  412. var err error
  413. var next Kind
  414. pos := d.peekPos
  415. if pos != 0 {
  416. // Use cached peek result.
  417. if d.peekErr != nil {
  418. err := d.peekErr
  419. d.peekPos, d.peekErr = 0, nil // possibly a transient I/O error
  420. return Token{}, err
  421. }
  422. next = Kind(d.buf[pos]).normalize()
  423. d.peekPos = 0 // reset cache
  424. } else {
  425. d.invalidatePreviousRead()
  426. pos = d.prevEnd
  427. // Consume leading whitespace.
  428. pos += jsonwire.ConsumeWhitespace(d.buf[pos:])
  429. if d.needMore(pos) {
  430. if pos, err = d.consumeWhitespace(pos); err != nil {
  431. if err == io.ErrUnexpectedEOF && d.Tokens.Depth() == 1 {
  432. err = io.EOF // EOF possibly if no Tokens present after top-level value
  433. }
  434. return Token{}, wrapSyntacticError(d, err, pos, 0)
  435. }
  436. }
  437. // Consume colon or comma.
  438. var delim byte
  439. if c := d.buf[pos]; c == ':' || c == ',' {
  440. delim = c
  441. pos += 1
  442. pos += jsonwire.ConsumeWhitespace(d.buf[pos:])
  443. if d.needMore(pos) {
  444. if pos, err = d.consumeWhitespace(pos); err != nil {
  445. err = wrapSyntacticError(d, err, pos, 0)
  446. return Token{}, d.checkDelimBeforeIOError(delim, err)
  447. }
  448. }
  449. }
  450. next = Kind(d.buf[pos]).normalize()
  451. if d.Tokens.needDelim(next) != delim {
  452. return Token{}, d.checkDelim(delim, next)
  453. }
  454. }
  455. // Handle the next token.
  456. var n int
  457. switch next {
  458. case 'n':
  459. if jsonwire.ConsumeNull(d.buf[pos:]) == 0 {
  460. pos, err = d.consumeLiteral(pos, "null")
  461. if err != nil {
  462. return Token{}, wrapSyntacticError(d, err, pos, +1)
  463. }
  464. } else {
  465. pos += len("null")
  466. }
  467. if err = d.Tokens.appendLiteral(); err != nil {
  468. return Token{}, wrapSyntacticError(d, err, pos-len("null"), +1) // report position at start of literal
  469. }
  470. d.prevStart, d.prevEnd = pos, pos
  471. return Null, nil
  472. case 'f':
  473. if jsonwire.ConsumeFalse(d.buf[pos:]) == 0 {
  474. pos, err = d.consumeLiteral(pos, "false")
  475. if err != nil {
  476. return Token{}, wrapSyntacticError(d, err, pos, +1)
  477. }
  478. } else {
  479. pos += len("false")
  480. }
  481. if err = d.Tokens.appendLiteral(); err != nil {
  482. return Token{}, wrapSyntacticError(d, err, pos-len("false"), +1) // report position at start of literal
  483. }
  484. d.prevStart, d.prevEnd = pos, pos
  485. return False, nil
  486. case 't':
  487. if jsonwire.ConsumeTrue(d.buf[pos:]) == 0 {
  488. pos, err = d.consumeLiteral(pos, "true")
  489. if err != nil {
  490. return Token{}, wrapSyntacticError(d, err, pos, +1)
  491. }
  492. } else {
  493. pos += len("true")
  494. }
  495. if err = d.Tokens.appendLiteral(); err != nil {
  496. return Token{}, wrapSyntacticError(d, err, pos-len("true"), +1) // report position at start of literal
  497. }
  498. d.prevStart, d.prevEnd = pos, pos
  499. return True, nil
  500. case '"':
  501. var flags jsonwire.ValueFlags // TODO: Preserve this in Token?
  502. if n = jsonwire.ConsumeSimpleString(d.buf[pos:]); n == 0 {
  503. oldAbsPos := d.baseOffset + int64(pos)
  504. pos, err = d.consumeString(&flags, pos)
  505. newAbsPos := d.baseOffset + int64(pos)
  506. n = int(newAbsPos - oldAbsPos)
  507. if err != nil {
  508. return Token{}, wrapSyntacticError(d, err, pos, +1)
  509. }
  510. } else {
  511. pos += n
  512. }
  513. if d.Tokens.Last.NeedObjectName() {
  514. if !d.Flags.Get(jsonflags.AllowDuplicateNames) {
  515. if !d.Tokens.Last.isValidNamespace() {
  516. return Token{}, wrapSyntacticError(d, errInvalidNamespace, pos-n, +1)
  517. }
  518. if d.Tokens.Last.isActiveNamespace() && !d.Namespaces.Last().insertQuoted(d.buf[pos-n:pos], flags.IsVerbatim()) {
  519. err = wrapWithObjectName(ErrDuplicateName, d.buf[pos-n:pos])
  520. return Token{}, wrapSyntacticError(d, err, pos-n, +1) // report position at start of string
  521. }
  522. }
  523. d.Names.ReplaceLastQuotedOffset(pos - n) // only replace if insertQuoted succeeds
  524. }
  525. if err = d.Tokens.appendString(); err != nil {
  526. return Token{}, wrapSyntacticError(d, err, pos-n, +1) // report position at start of string
  527. }
  528. d.prevStart, d.prevEnd = pos-n, pos
  529. return Token{raw: &d.decodeBuffer, num: uint64(d.previousOffsetStart())}, nil
  530. case '0':
  531. // NOTE: Since JSON numbers are not self-terminating,
  532. // we need to make sure that the next byte is not part of a number.
  533. if n = jsonwire.ConsumeSimpleNumber(d.buf[pos:]); n == 0 || d.needMore(pos+n) {
  534. oldAbsPos := d.baseOffset + int64(pos)
  535. pos, err = d.consumeNumber(pos)
  536. newAbsPos := d.baseOffset + int64(pos)
  537. n = int(newAbsPos - oldAbsPos)
  538. if err != nil {
  539. return Token{}, wrapSyntacticError(d, err, pos, +1)
  540. }
  541. } else {
  542. pos += n
  543. }
  544. if err = d.Tokens.appendNumber(); err != nil {
  545. return Token{}, wrapSyntacticError(d, err, pos-n, +1) // report position at start of number
  546. }
  547. d.prevStart, d.prevEnd = pos-n, pos
  548. return Token{raw: &d.decodeBuffer, num: uint64(d.previousOffsetStart())}, nil
  549. case '{':
  550. if err = d.Tokens.pushObject(); err != nil {
  551. return Token{}, wrapSyntacticError(d, err, pos, +1)
  552. }
  553. d.Names.push()
  554. if !d.Flags.Get(jsonflags.AllowDuplicateNames) {
  555. d.Namespaces.push()
  556. }
  557. pos += 1
  558. d.prevStart, d.prevEnd = pos, pos
  559. return ObjectStart, nil
  560. case '}':
  561. if err = d.Tokens.popObject(); err != nil {
  562. return Token{}, wrapSyntacticError(d, err, pos, +1)
  563. }
  564. d.Names.pop()
  565. if !d.Flags.Get(jsonflags.AllowDuplicateNames) {
  566. d.Namespaces.pop()
  567. }
  568. pos += 1
  569. d.prevStart, d.prevEnd = pos, pos
  570. return ObjectEnd, nil
  571. case '[':
  572. if err = d.Tokens.pushArray(); err != nil {
  573. return Token{}, wrapSyntacticError(d, err, pos, +1)
  574. }
  575. pos += 1
  576. d.prevStart, d.prevEnd = pos, pos
  577. return ArrayStart, nil
  578. case ']':
  579. if err = d.Tokens.popArray(); err != nil {
  580. return Token{}, wrapSyntacticError(d, err, pos, +1)
  581. }
  582. pos += 1
  583. d.prevStart, d.prevEnd = pos, pos
  584. return ArrayEnd, nil
  585. default:
  586. err = jsonwire.NewInvalidCharacterError(d.buf[pos:], "at start of value")
  587. return Token{}, wrapSyntacticError(d, err, pos, +1)
  588. }
  589. }
  590. // ReadValue returns the next raw JSON value, advancing the read offset.
  591. // The value is stripped of any leading or trailing whitespace and
  592. // contains the exact bytes of the input, which may contain invalid UTF-8
  593. // if [AllowInvalidUTF8] is specified.
  594. //
  595. // The returned value is only valid until the next Peek, Read, or Skip call and
  596. // may not be mutated while the Decoder remains in use.
  597. // If the decoder is currently at the end token for an object or array,
  598. // then it reports a [SyntacticError] and the internal state remains unchanged.
  599. // It returns [io.EOF] if there are no more values.
  600. func (d *Decoder) ReadValue() (Value, error) {
  601. var flags jsonwire.ValueFlags
  602. return d.s.ReadValue(&flags)
  603. }
  604. func (d *decoderState) ReadValue(flags *jsonwire.ValueFlags) (Value, error) {
  605. // Determine the next kind.
  606. var err error
  607. var next Kind
  608. pos := d.peekPos
  609. if pos != 0 {
  610. // Use cached peek result.
  611. if d.peekErr != nil {
  612. err := d.peekErr
  613. d.peekPos, d.peekErr = 0, nil // possibly a transient I/O error
  614. return nil, err
  615. }
  616. next = Kind(d.buf[pos]).normalize()
  617. d.peekPos = 0 // reset cache
  618. } else {
  619. d.invalidatePreviousRead()
  620. pos = d.prevEnd
  621. // Consume leading whitespace.
  622. pos += jsonwire.ConsumeWhitespace(d.buf[pos:])
  623. if d.needMore(pos) {
  624. if pos, err = d.consumeWhitespace(pos); err != nil {
  625. if err == io.ErrUnexpectedEOF && d.Tokens.Depth() == 1 {
  626. err = io.EOF // EOF possibly if no Tokens present after top-level value
  627. }
  628. return nil, wrapSyntacticError(d, err, pos, 0)
  629. }
  630. }
  631. // Consume colon or comma.
  632. var delim byte
  633. if c := d.buf[pos]; c == ':' || c == ',' {
  634. delim = c
  635. pos += 1
  636. pos += jsonwire.ConsumeWhitespace(d.buf[pos:])
  637. if d.needMore(pos) {
  638. if pos, err = d.consumeWhitespace(pos); err != nil {
  639. err = wrapSyntacticError(d, err, pos, 0)
  640. return nil, d.checkDelimBeforeIOError(delim, err)
  641. }
  642. }
  643. }
  644. next = Kind(d.buf[pos]).normalize()
  645. if d.Tokens.needDelim(next) != delim {
  646. return nil, d.checkDelim(delim, next)
  647. }
  648. }
  649. // Handle the next value.
  650. oldAbsPos := d.baseOffset + int64(pos)
  651. pos, err = d.consumeValue(flags, pos, d.Tokens.Depth())
  652. newAbsPos := d.baseOffset + int64(pos)
  653. n := int(newAbsPos - oldAbsPos)
  654. if err != nil {
  655. return nil, wrapSyntacticError(d, err, pos, +1)
  656. }
  657. switch next {
  658. case 'n', 't', 'f':
  659. err = d.Tokens.appendLiteral()
  660. case '"':
  661. if d.Tokens.Last.NeedObjectName() {
  662. if !d.Flags.Get(jsonflags.AllowDuplicateNames) {
  663. if !d.Tokens.Last.isValidNamespace() {
  664. err = errInvalidNamespace
  665. break
  666. }
  667. if d.Tokens.Last.isActiveNamespace() && !d.Namespaces.Last().insertQuoted(d.buf[pos-n:pos], flags.IsVerbatim()) {
  668. err = wrapWithObjectName(ErrDuplicateName, d.buf[pos-n:pos])
  669. break
  670. }
  671. }
  672. d.Names.ReplaceLastQuotedOffset(pos - n) // only replace if insertQuoted succeeds
  673. }
  674. err = d.Tokens.appendString()
  675. case '0':
  676. err = d.Tokens.appendNumber()
  677. case '{':
  678. if err = d.Tokens.pushObject(); err != nil {
  679. break
  680. }
  681. if err = d.Tokens.popObject(); err != nil {
  682. panic("BUG: popObject should never fail immediately after pushObject: " + err.Error())
  683. }
  684. case '[':
  685. if err = d.Tokens.pushArray(); err != nil {
  686. break
  687. }
  688. if err = d.Tokens.popArray(); err != nil {
  689. panic("BUG: popArray should never fail immediately after pushArray: " + err.Error())
  690. }
  691. }
  692. if err != nil {
  693. return nil, wrapSyntacticError(d, err, pos-n, +1) // report position at start of value
  694. }
  695. d.prevEnd = pos
  696. d.prevStart = pos - n
  697. return d.buf[pos-n : pos : pos], nil
  698. }
  699. // CheckNextValue checks whether the next value is syntactically valid,
  700. // but does not advance the read offset.
  701. func (d *decoderState) CheckNextValue() error {
  702. d.PeekKind() // populates d.peekPos and d.peekErr
  703. pos, err := d.peekPos, d.peekErr
  704. d.peekPos, d.peekErr = 0, nil
  705. if err != nil {
  706. return err
  707. }
  708. var flags jsonwire.ValueFlags
  709. if pos, err := d.consumeValue(&flags, pos, d.Tokens.Depth()); err != nil {
  710. return wrapSyntacticError(d, err, pos, +1)
  711. }
  712. return nil
  713. }
  714. // CheckEOF verifies that the input has no more data.
  715. func (d *decoderState) CheckEOF() error {
  716. switch pos, err := d.consumeWhitespace(d.prevEnd); err {
  717. case nil:
  718. err := jsonwire.NewInvalidCharacterError(d.buf[pos:], "after top-level value")
  719. return wrapSyntacticError(d, err, pos, 0)
  720. case io.ErrUnexpectedEOF:
  721. return nil
  722. default:
  723. return err
  724. }
  725. }
  726. // consumeWhitespace consumes all whitespace starting at d.buf[pos:].
  727. // It returns the new position in d.buf immediately after the last whitespace.
  728. // If it returns nil, there is guaranteed to at least be one unread byte.
  729. //
  730. // The following pattern is common in this implementation:
  731. //
  732. // pos += jsonwire.ConsumeWhitespace(d.buf[pos:])
  733. // if d.needMore(pos) {
  734. // if pos, err = d.consumeWhitespace(pos); err != nil {
  735. // return ...
  736. // }
  737. // }
  738. //
  739. // It is difficult to simplify this without sacrificing performance since
  740. // consumeWhitespace must be inlined. The body of the if statement is
  741. // executed only in rare situations where we need to fetch more data.
  742. // Since fetching may return an error, we also need to check the error.
  743. func (d *decoderState) consumeWhitespace(pos int) (newPos int, err error) {
  744. for {
  745. pos += jsonwire.ConsumeWhitespace(d.buf[pos:])
  746. if d.needMore(pos) {
  747. absPos := d.baseOffset + int64(pos)
  748. err = d.fetch() // will mutate d.buf and invalidate pos
  749. pos = int(absPos - d.baseOffset)
  750. if err != nil {
  751. return pos, err
  752. }
  753. continue
  754. }
  755. return pos, nil
  756. }
  757. }
  758. // consumeValue consumes a single JSON value starting at d.buf[pos:].
  759. // It returns the new position in d.buf immediately after the value.
  760. func (d *decoderState) consumeValue(flags *jsonwire.ValueFlags, pos, depth int) (newPos int, err error) {
  761. for {
  762. var n int
  763. var err error
  764. switch next := Kind(d.buf[pos]).normalize(); next {
  765. case 'n':
  766. if n = jsonwire.ConsumeNull(d.buf[pos:]); n == 0 {
  767. n, err = jsonwire.ConsumeLiteral(d.buf[pos:], "null")
  768. }
  769. case 'f':
  770. if n = jsonwire.ConsumeFalse(d.buf[pos:]); n == 0 {
  771. n, err = jsonwire.ConsumeLiteral(d.buf[pos:], "false")
  772. }
  773. case 't':
  774. if n = jsonwire.ConsumeTrue(d.buf[pos:]); n == 0 {
  775. n, err = jsonwire.ConsumeLiteral(d.buf[pos:], "true")
  776. }
  777. case '"':
  778. if n = jsonwire.ConsumeSimpleString(d.buf[pos:]); n == 0 {
  779. return d.consumeString(flags, pos)
  780. }
  781. case '0':
  782. // NOTE: Since JSON numbers are not self-terminating,
  783. // we need to make sure that the next byte is not part of a number.
  784. if n = jsonwire.ConsumeSimpleNumber(d.buf[pos:]); n == 0 || d.needMore(pos+n) {
  785. return d.consumeNumber(pos)
  786. }
  787. case '{':
  788. return d.consumeObject(flags, pos, depth)
  789. case '[':
  790. return d.consumeArray(flags, pos, depth)
  791. default:
  792. if (d.Tokens.Last.isObject() && next == ']') || (d.Tokens.Last.isArray() && next == '}') {
  793. return pos, errMismatchDelim
  794. }
  795. return pos, jsonwire.NewInvalidCharacterError(d.buf[pos:], "at start of value")
  796. }
  797. if err == io.ErrUnexpectedEOF {
  798. absPos := d.baseOffset + int64(pos)
  799. err = d.fetch() // will mutate d.buf and invalidate pos
  800. pos = int(absPos - d.baseOffset)
  801. if err != nil {
  802. return pos + n, err
  803. }
  804. continue
  805. }
  806. return pos + n, err
  807. }
  808. }
  809. // consumeLiteral consumes a single JSON literal starting at d.buf[pos:].
  810. // It returns the new position in d.buf immediately after the literal.
  811. func (d *decoderState) consumeLiteral(pos int, lit string) (newPos int, err error) {
  812. for {
  813. n, err := jsonwire.ConsumeLiteral(d.buf[pos:], lit)
  814. if err == io.ErrUnexpectedEOF {
  815. absPos := d.baseOffset + int64(pos)
  816. err = d.fetch() // will mutate d.buf and invalidate pos
  817. pos = int(absPos - d.baseOffset)
  818. if err != nil {
  819. return pos + n, err
  820. }
  821. continue
  822. }
  823. return pos + n, err
  824. }
  825. }
  826. // consumeString consumes a single JSON string starting at d.buf[pos:].
  827. // It returns the new position in d.buf immediately after the string.
  828. func (d *decoderState) consumeString(flags *jsonwire.ValueFlags, pos int) (newPos int, err error) {
  829. var n int
  830. for {
  831. n, err = jsonwire.ConsumeStringResumable(flags, d.buf[pos:], n, !d.Flags.Get(jsonflags.AllowInvalidUTF8))
  832. if err == io.ErrUnexpectedEOF {
  833. absPos := d.baseOffset + int64(pos)
  834. err = d.fetch() // will mutate d.buf and invalidate pos
  835. pos = int(absPos - d.baseOffset)
  836. if err != nil {
  837. return pos + n, err
  838. }
  839. continue
  840. }
  841. return pos + n, err
  842. }
  843. }
  844. // consumeNumber consumes a single JSON number starting at d.buf[pos:].
  845. // It returns the new position in d.buf immediately after the number.
  846. func (d *decoderState) consumeNumber(pos int) (newPos int, err error) {
  847. var n int
  848. var state jsonwire.ConsumeNumberState
  849. for {
  850. n, state, err = jsonwire.ConsumeNumberResumable(d.buf[pos:], n, state)
  851. // NOTE: Since JSON numbers are not self-terminating,
  852. // we need to make sure that the next byte is not part of a number.
  853. if err == io.ErrUnexpectedEOF || d.needMore(pos+n) {
  854. mayTerminate := err == nil
  855. absPos := d.baseOffset + int64(pos)
  856. err = d.fetch() // will mutate d.buf and invalidate pos
  857. pos = int(absPos - d.baseOffset)
  858. if err != nil {
  859. if mayTerminate && err == io.ErrUnexpectedEOF {
  860. return pos + n, nil
  861. }
  862. return pos, err
  863. }
  864. continue
  865. }
  866. return pos + n, err
  867. }
  868. }
  869. // consumeObject consumes a single JSON object starting at d.buf[pos:].
  870. // It returns the new position in d.buf immediately after the object.
  871. func (d *decoderState) consumeObject(flags *jsonwire.ValueFlags, pos, depth int) (newPos int, err error) {
  872. var n int
  873. var names *objectNamespace
  874. if !d.Flags.Get(jsonflags.AllowDuplicateNames) {
  875. d.Namespaces.push()
  876. defer d.Namespaces.pop()
  877. names = d.Namespaces.Last()
  878. }
  879. // Handle before start.
  880. if uint(pos) >= uint(len(d.buf)) || d.buf[pos] != '{' {
  881. panic("BUG: consumeObject must be called with a buffer that starts with '{'")
  882. } else if depth == maxNestingDepth+1 {
  883. return pos, errMaxDepth
  884. }
  885. pos++
  886. // Handle after start.
  887. pos += jsonwire.ConsumeWhitespace(d.buf[pos:])
  888. if d.needMore(pos) {
  889. if pos, err = d.consumeWhitespace(pos); err != nil {
  890. return pos, err
  891. }
  892. }
  893. if d.buf[pos] == '}' {
  894. pos++
  895. return pos, nil
  896. }
  897. depth++
  898. for {
  899. // Handle before name.
  900. pos += jsonwire.ConsumeWhitespace(d.buf[pos:])
  901. if d.needMore(pos) {
  902. if pos, err = d.consumeWhitespace(pos); err != nil {
  903. return pos, err
  904. }
  905. }
  906. var flags2 jsonwire.ValueFlags
  907. if n = jsonwire.ConsumeSimpleString(d.buf[pos:]); n == 0 {
  908. oldAbsPos := d.baseOffset + int64(pos)
  909. pos, err = d.consumeString(&flags2, pos)
  910. newAbsPos := d.baseOffset + int64(pos)
  911. n = int(newAbsPos - oldAbsPos)
  912. flags.Join(flags2)
  913. if err != nil {
  914. return pos, err
  915. }
  916. } else {
  917. pos += n
  918. }
  919. quotedName := d.buf[pos-n : pos]
  920. if !d.Flags.Get(jsonflags.AllowDuplicateNames) && !names.insertQuoted(quotedName, flags2.IsVerbatim()) {
  921. return pos - n, wrapWithObjectName(ErrDuplicateName, quotedName)
  922. }
  923. // Handle after name.
  924. pos += jsonwire.ConsumeWhitespace(d.buf[pos:])
  925. if d.needMore(pos) {
  926. if pos, err = d.consumeWhitespace(pos); err != nil {
  927. return pos, wrapWithObjectName(err, quotedName)
  928. }
  929. }
  930. if d.buf[pos] != ':' {
  931. err := jsonwire.NewInvalidCharacterError(d.buf[pos:], "after object name (expecting ':')")
  932. return pos, wrapWithObjectName(err, quotedName)
  933. }
  934. pos++
  935. // Handle before value.
  936. pos += jsonwire.ConsumeWhitespace(d.buf[pos:])
  937. if d.needMore(pos) {
  938. if pos, err = d.consumeWhitespace(pos); err != nil {
  939. return pos, wrapWithObjectName(err, quotedName)
  940. }
  941. }
  942. pos, err = d.consumeValue(flags, pos, depth)
  943. if err != nil {
  944. return pos, wrapWithObjectName(err, quotedName)
  945. }
  946. // Handle after value.
  947. pos += jsonwire.ConsumeWhitespace(d.buf[pos:])
  948. if d.needMore(pos) {
  949. if pos, err = d.consumeWhitespace(pos); err != nil {
  950. return pos, err
  951. }
  952. }
  953. switch d.buf[pos] {
  954. case ',':
  955. pos++
  956. continue
  957. case '}':
  958. pos++
  959. return pos, nil
  960. default:
  961. return pos, jsonwire.NewInvalidCharacterError(d.buf[pos:], "after object value (expecting ',' or '}')")
  962. }
  963. }
  964. }
  965. // consumeArray consumes a single JSON array starting at d.buf[pos:].
  966. // It returns the new position in d.buf immediately after the array.
  967. func (d *decoderState) consumeArray(flags *jsonwire.ValueFlags, pos, depth int) (newPos int, err error) {
  968. // Handle before start.
  969. if uint(pos) >= uint(len(d.buf)) || d.buf[pos] != '[' {
  970. panic("BUG: consumeArray must be called with a buffer that starts with '['")
  971. } else if depth == maxNestingDepth+1 {
  972. return pos, errMaxDepth
  973. }
  974. pos++
  975. // Handle after start.
  976. pos += jsonwire.ConsumeWhitespace(d.buf[pos:])
  977. if d.needMore(pos) {
  978. if pos, err = d.consumeWhitespace(pos); err != nil {
  979. return pos, err
  980. }
  981. }
  982. if d.buf[pos] == ']' {
  983. pos++
  984. return pos, nil
  985. }
  986. var idx int64
  987. depth++
  988. for {
  989. // Handle before value.
  990. pos += jsonwire.ConsumeWhitespace(d.buf[pos:])
  991. if d.needMore(pos) {
  992. if pos, err = d.consumeWhitespace(pos); err != nil {
  993. return pos, err
  994. }
  995. }
  996. pos, err = d.consumeValue(flags, pos, depth)
  997. if err != nil {
  998. return pos, wrapWithArrayIndex(err, idx)
  999. }
  1000. // Handle after value.
  1001. pos += jsonwire.ConsumeWhitespace(d.buf[pos:])
  1002. if d.needMore(pos) {
  1003. if pos, err = d.consumeWhitespace(pos); err != nil {
  1004. return pos, err
  1005. }
  1006. }
  1007. switch d.buf[pos] {
  1008. case ',':
  1009. pos++
  1010. idx++
  1011. continue
  1012. case ']':
  1013. pos++
  1014. return pos, nil
  1015. default:
  1016. return pos, jsonwire.NewInvalidCharacterError(d.buf[pos:], "after array element (expecting ',' or ']')")
  1017. }
  1018. }
  1019. }
  1020. // InputOffset returns the current input byte offset. It gives the location
  1021. // of the next byte immediately after the most recently returned token or value.
  1022. // The number of bytes actually read from the underlying [io.Reader] may be more
  1023. // than this offset due to internal buffering effects.
  1024. func (d *Decoder) InputOffset() int64 {
  1025. return d.s.previousOffsetEnd()
  1026. }
  1027. // UnreadBuffer returns the data remaining in the unread buffer,
  1028. // which may contain zero or more bytes.
  1029. // The returned buffer must not be mutated while Decoder continues to be used.
  1030. // The buffer contents are valid until the next Peek, Read, or Skip call.
  1031. func (d *Decoder) UnreadBuffer() []byte {
  1032. return d.s.unreadBuffer()
  1033. }
  1034. // StackDepth returns the depth of the state machine for read JSON data.
  1035. // Each level on the stack represents a nested JSON object or array.
  1036. // It is incremented whenever an [ObjectStart] or [ArrayStart] token is encountered
  1037. // and decremented whenever an [ObjectEnd] or [ArrayEnd] token is encountered.
  1038. // The depth is zero-indexed, where zero represents the top-level JSON value.
  1039. func (d *Decoder) StackDepth() int {
  1040. // NOTE: Keep in sync with Encoder.StackDepth.
  1041. return d.s.Tokens.Depth() - 1
  1042. }
  1043. // StackIndex returns information about the specified stack level.
  1044. // It must be a number between 0 and [Decoder.StackDepth], inclusive.
  1045. // For each level, it reports the kind:
  1046. //
  1047. // - 0 for a level of zero,
  1048. // - '{' for a level representing a JSON object, and
  1049. // - '[' for a level representing a JSON array.
  1050. //
  1051. // It also reports the length of that JSON object or array.
  1052. // Each name and value in a JSON object is counted separately,
  1053. // so the effective number of members would be half the length.
  1054. // A complete JSON object must have an even length.
  1055. func (d *Decoder) StackIndex(i int) (Kind, int64) {
  1056. // NOTE: Keep in sync with Encoder.StackIndex.
  1057. switch s := d.s.Tokens.index(i); {
  1058. case i > 0 && s.isObject():
  1059. return '{', s.Length()
  1060. case i > 0 && s.isArray():
  1061. return '[', s.Length()
  1062. default:
  1063. return 0, s.Length()
  1064. }
  1065. }
  1066. // StackPointer returns a JSON Pointer (RFC 6901) to the most recently read value.
  1067. func (d *Decoder) StackPointer() Pointer {
  1068. return Pointer(d.s.AppendStackPointer(nil, -1))
  1069. }
  1070. func (d *decoderState) AppendStackPointer(b []byte, where int) []byte {
  1071. d.Names.copyQuotedBuffer(d.buf)
  1072. return d.state.appendStackPointer(b, where)
  1073. }