Subversion Repositories openrisc

// Copyright 2010 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 (

        "errors"

        "io"

)

// A Decoder reads and decodes JSON objects from an input stream.

type Decoder struct {

        r    io.Reader

        buf  []byte

        d    decodeState

        scan scanner

        err  error

}

// NewDecoder returns a new decoder that reads from r.

func NewDecoder(r io.Reader) *Decoder {

        return &Decoder{r: r}

}

// Decode reads the next JSON-encoded value from its

// input and stores it in the value pointed to by v.

//

// See the documentation for Unmarshal for details about

// the conversion of JSON into a Go value.

func (dec *Decoder) Decode(v interface{}) error {

        if dec.err != nil {

                return dec.err

        }

        n, err := dec.readValue()

        if err != nil {

                return err

        }

        // Don't save err from unmarshal into dec.err:

        // the connection is still usable since we read a complete JSON

        // object from it before the error happened.

        dec.d.init(dec.buf[0:n])

        err = dec.d.unmarshal(v)

        // Slide rest of data down.

        rest := copy(dec.buf, dec.buf[n:])

        dec.buf = dec.buf[0:rest]

        return err

}

// readValue reads a JSON value into dec.buf.

// It returns the length of the encoding.

func (dec *Decoder) readValue() (int, error) {

        dec.scan.reset()

        scanp := 0

        var err error

Input:

        for {

                // Look in the buffer for a new value.

                for i, c := range dec.buf[scanp:] {

                        dec.scan.bytes++

                        v := dec.scan.step(&dec.scan, int(c))

                        if v == scanEnd {

                                scanp += i

                                break Input

                        }

                        // scanEnd is delayed one byte.

                        // We might block trying to get that byte from src,

                        // so instead invent a space byte.

                        if v == scanEndObject && dec.scan.step(&dec.scan, ' ') == scanEnd {

                                scanp += i + 1

                                break Input

                        }

                        if v == scanError {

                                dec.err = dec.scan.err

                                return 0, dec.scan.err

                        }

                }

                scanp = len(dec.buf)

                // Did the last read have an error?

                // Delayed until now to allow buffer scan.

                if err != nil {

                        if err == io.EOF {

                                if dec.scan.step(&dec.scan, ' ') == scanEnd {

                                        break Input

                                }

                                if nonSpace(dec.buf) {

                                        err = io.ErrUnexpectedEOF

                                }

                        }

                        dec.err = err

                        return 0, err

                }

                // Make room to read more into the buffer.

                const minRead = 512

                if cap(dec.buf)-len(dec.buf) < minRead {

                        newBuf := make([]byte, len(dec.buf), 2*cap(dec.buf)+minRead)

                        copy(newBuf, dec.buf)

                        dec.buf = newBuf

                }

                // Read.  Delay error for next iteration (after scan).

                var n int

                n, err = dec.r.Read(dec.buf[len(dec.buf):cap(dec.buf)])

                dec.buf = dec.buf[0 : len(dec.buf)+n]

        }

        return scanp, nil

}

func nonSpace(b []byte) bool {

        for _, c := range b {

                if !isSpace(rune(c)) {

                        return true

                }

        }

        return false

}

// An Encoder writes JSON objects to an output stream.

type Encoder struct {

        w   io.Writer

        e   encodeState

        err error

}

// NewEncoder returns a new encoder that writes to w.

func NewEncoder(w io.Writer) *Encoder {

        return &Encoder{w: w}

}

// Encode writes the JSON encoding of v to the connection.

//

// See the documentation for Marshal for details about the

// conversion of Go values to JSON.

func (enc *Encoder) Encode(v interface{}) error {

        if enc.err != nil {

                return enc.err

        }

        enc.e.Reset()

        err := enc.e.marshal(v)

        if err != nil {

                return err

        }

        // Terminate each value with a newline.

        // This makes the output look a little nicer

        // when debugging, and some kind of space

        // is required if the encoded value was a number,

        // so that the reader knows there aren't more

        // digits coming.

        enc.e.WriteByte('\n')

        if _, err = enc.w.Write(enc.e.Bytes()); err != nil {

                enc.err = err

        }

        return err

}

// RawMessage is a raw encoded JSON object.

// It implements Marshaler and Unmarshaler and can

// be used to delay JSON decoding or precompute a JSON encoding.

type RawMessage []byte

// MarshalJSON returns *m as the JSON encoding of m.

func (m *RawMessage) MarshalJSON() ([]byte, error) {

        return *m, nil

}

// UnmarshalJSON sets *m to a copy of data.

func (m *RawMessage) UnmarshalJSON(data []byte) error {

        if m == nil {

                return errors.New("json.RawMessage: UnmarshalJSON on nil pointer")

        }

        *m = append((*m)[0:0], data...)

        return nil

}

var _ Marshaler = (*RawMessage)(nil)

var _ Unmarshaler = (*RawMessage)(nil)