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 "bytes"

// Compact appends to dst the JSON-encoded src with
// insignificant space characters elided.
func Compact(dst *bytes.Buffer, src []byte) error {
        origLen := dst.Len()
        var scan scanner
        scan.reset()
        start := 0
        for i, c := range src {
                v := scan.step(&scan, int(c))
                if v >= scanSkipSpace {
                        if v == scanError {
                                break
                        }
                        if start < i {
                                dst.Write(src[start:i])
                        }
                        start = i + 1
                }
        }
        if scan.eof() == scanError {
                dst.Truncate(origLen)
                return scan.err
        }
        if start < len(src) {
                dst.Write(src[start:])
        }
        return nil
}

func newline(dst *bytes.Buffer, prefix, indent string, depth int) {
        dst.WriteByte('\n')
        dst.WriteString(prefix)
        for i := 0; i < depth; i++ {
                dst.WriteString(indent)
        }
}

// Indent appends to dst an indented form of the JSON-encoded src.
// Each element in a JSON object or array begins on a new,
// indented line beginning with prefix followed by one or more
// copies of indent according to the indentation nesting.
// The data appended to dst has no trailing newline, to make it easier
// to embed inside other formatted JSON data.
func Indent(dst *bytes.Buffer, src []byte, prefix, indent string) error {
        origLen := dst.Len()
        var scan scanner
        scan.reset()
        needIndent := false
        depth := 0
        for _, c := range src {
                scan.bytes++
                v := scan.step(&scan, int(c))
                if v == scanSkipSpace {
                        continue
                }
                if v == scanError {
                        break
                }
                if needIndent && v != scanEndObject && v != scanEndArray {
                        needIndent = false
                        depth++
                        newline(dst, prefix, indent, depth)
                }

                // Emit semantically uninteresting bytes
                // (in particular, punctuation in strings) unmodified.
                if v == scanContinue {
                        dst.WriteByte(c)
                        continue
                }

                // Add spacing around real punctuation.
                switch c {
                case '{', '[':
                        // delay indent so that empty object and array are formatted as {} and [].
                        needIndent = true
                        dst.WriteByte(c)

                case ',':
                        dst.WriteByte(c)
                        newline(dst, prefix, indent, depth)

                case ':':
                        dst.WriteByte(c)
                        dst.WriteByte(' ')

                case '}', ']':
                        if needIndent {
                                // suppress indent in empty object/array
                                needIndent = false
                        } else {
                                depth--
                                newline(dst, prefix, indent, depth)
                        }
                        dst.WriteByte(c)

                default:
                        dst.WriteByte(c)
                }
        }
        if scan.eof() == scanError {
                dst.Truncate(origLen)
                return scan.err
        }
        return nil
}