podman

1
// Copyright 2018 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
6

7
import (
8
	"math"
9
	"math/bits"
10
	"strconv"
11
	"strings"
12
	"unicode/utf8"
13

14
	"google.golang.org/protobuf/internal/detrand"
15
	"google.golang.org/protobuf/internal/errors"
16
)
17

18
// kind represents an encoding type.
19
type kind uint8
20

21
const (
22
	_ kind = (1 << iota) / 2
23
	name
24
	scalar
25
	objectOpen
26
	objectClose
27
	arrayOpen
28
	arrayClose
29
)
30

31
// Encoder provides methods to write out JSON constructs and values. The user is
32
// responsible for producing valid sequences of JSON constructs and values.
33
type Encoder struct {
34
	indent   string
35
	lastKind kind
36
	indents  []byte
37
	out      []byte
38
}
39

40
// NewEncoder returns an Encoder.
41
//
42
// If indent is a non-empty string, it causes every entry for an Array or Object
43
// to be preceded by the indent and trailed by a newline.
44
func NewEncoder(buf []byte, indent string) (*Encoder, error) {
45
	e := &Encoder{
46
		out: buf,
47
	}
48
	if len(indent) > 0 {
49
		if strings.Trim(indent, " \t") != "" {
50
			return nil, errors.New("indent may only be composed of space or tab characters")
51
		}
52
		e.indent = indent
53
	}
54
	return e, nil
55
}
56

57
// Bytes returns the content of the written bytes.
58
func (e *Encoder) Bytes() []byte {
59
	return e.out
60
}
61

62
// WriteNull writes out the null value.
63
func (e *Encoder) WriteNull() {
64
	e.prepareNext(scalar)
65
	e.out = append(e.out, "null"...)
66
}
67

68
// WriteBool writes out the given boolean value.
69
func (e *Encoder) WriteBool(b bool) {
70
	e.prepareNext(scalar)
71
	if b {
72
		e.out = append(e.out, "true"...)
73
	} else {
74
		e.out = append(e.out, "false"...)
75
	}
76
}
77

78
// WriteString writes out the given string in JSON string value. Returns error
79
// if input string contains invalid UTF-8.
80
func (e *Encoder) WriteString(s string) error {
81
	e.prepareNext(scalar)
82
	var err error
83
	if e.out, err = appendString(e.out, s); err != nil {
84
		return err
85
	}
86
	return nil
87
}
88

89
// Sentinel error used for indicating invalid UTF-8.
90
var errInvalidUTF8 = errors.New("invalid UTF-8")
91

92
func appendString(out []byte, in string) ([]byte, error) {
93
	out = append(out, '"')
94
	i := indexNeedEscapeInString(in)
95
	in, out = in[i:], append(out, in[:i]...)
96
	for len(in) > 0 {
97
		switch r, n := utf8.DecodeRuneInString(in); {
98
		case r == utf8.RuneError && n == 1:
99
			return out, errInvalidUTF8
100
		case r < ' ' || r == '"' || r == '\\':
101
			out = append(out, '\\')
102
			switch r {
103
			case '"', '\\':
104
				out = append(out, byte(r))
105
			case '\b':
106
				out = append(out, 'b')
107
			case '\f':
108
				out = append(out, 'f')
109
			case '\n':
110
				out = append(out, 'n')
111
			case '\r':
112
				out = append(out, 'r')
113
			case '\t':
114
				out = append(out, 't')
115
			default:
116
				out = append(out, 'u')
117
				out = append(out, "0000"[1+(bits.Len32(uint32(r))-1)/4:]...)
118
				out = strconv.AppendUint(out, uint64(r), 16)
119
			}
120
			in = in[n:]
121
		default:
122
			i := indexNeedEscapeInString(in[n:])
123
			in, out = in[n+i:], append(out, in[:n+i]...)
124
		}
125
	}
126
	out = append(out, '"')
127
	return out, nil
128
}
129

130
// indexNeedEscapeInString returns the index of the character that needs
131
// escaping. If no characters need escaping, this returns the input length.
132
func indexNeedEscapeInString(s string) int {
133
	for i, r := range s {
134
		if r < ' ' || r == '\\' || r == '"' || r == utf8.RuneError {
135
			return i
136
		}
137
	}
138
	return len(s)
139
}
140

141
// WriteFloat writes out the given float and bitSize in JSON number value.
142
func (e *Encoder) WriteFloat(n float64, bitSize int) {
143
	e.prepareNext(scalar)
144
	e.out = appendFloat(e.out, n, bitSize)
145
}
146

147
// appendFloat formats given float in bitSize, and appends to the given []byte.
148
func appendFloat(out []byte, n float64, bitSize int) []byte {
149
	switch {
150
	case math.IsNaN(n):
151
		return append(out, `"NaN"`...)
152
	case math.IsInf(n, +1):
153
		return append(out, `"Infinity"`...)
154
	case math.IsInf(n, -1):
155
		return append(out, `"-Infinity"`...)
156
	}
157

158
	// JSON number formatting logic based on encoding/json.
159
	// See floatEncoder.encode for reference.
160
	fmt := byte('f')
161
	if abs := math.Abs(n); abs != 0 {
162
		if bitSize == 64 && (abs < 1e-6 || abs >= 1e21) ||
163
			bitSize == 32 && (float32(abs) < 1e-6 || float32(abs) >= 1e21) {
164
			fmt = 'e'
165
		}
166
	}
167
	out = strconv.AppendFloat(out, n, fmt, -1, bitSize)
168
	if fmt == 'e' {
169
		n := len(out)
170
		if n >= 4 && out[n-4] == 'e' && out[n-3] == '-' && out[n-2] == '0' {
171
			out[n-2] = out[n-1]
172
			out = out[:n-1]
173
		}
174
	}
175
	return out
176
}
177

178
// WriteInt writes out the given signed integer in JSON number value.
179
func (e *Encoder) WriteInt(n int64) {
180
	e.prepareNext(scalar)
181
	e.out = strconv.AppendInt(e.out, n, 10)
182
}
183

184
// WriteUint writes out the given unsigned integer in JSON number value.
185
func (e *Encoder) WriteUint(n uint64) {
186
	e.prepareNext(scalar)
187
	e.out = strconv.AppendUint(e.out, n, 10)
188
}
189

190
// StartObject writes out the '{' symbol.
191
func (e *Encoder) StartObject() {
192
	e.prepareNext(objectOpen)
193
	e.out = append(e.out, '{')
194
}
195

196
// EndObject writes out the '}' symbol.
197
func (e *Encoder) EndObject() {
198
	e.prepareNext(objectClose)
199
	e.out = append(e.out, '}')
200
}
201

202
// WriteName writes out the given string in JSON string value and the name
203
// separator ':'. Returns error if input string contains invalid UTF-8, which
204
// should not be likely as protobuf field names should be valid.
205
func (e *Encoder) WriteName(s string) error {
206
	e.prepareNext(name)
207
	var err error
208
	// Append to output regardless of error.
209
	e.out, err = appendString(e.out, s)
210
	e.out = append(e.out, ':')
211
	return err
212
}
213

214
// StartArray writes out the '[' symbol.
215
func (e *Encoder) StartArray() {
216
	e.prepareNext(arrayOpen)
217
	e.out = append(e.out, '[')
218
}
219

220
// EndArray writes out the ']' symbol.
221
func (e *Encoder) EndArray() {
222
	e.prepareNext(arrayClose)
223
	e.out = append(e.out, ']')
224
}
225

226
// prepareNext adds possible comma and indentation for the next value based
227
// on last type and indent option. It also updates lastKind to next.
228
func (e *Encoder) prepareNext(next kind) {
229
	defer func() {
230
		// Set lastKind to next.
231
		e.lastKind = next
232
	}()
233

234
	if len(e.indent) == 0 {
235
		// Need to add comma on the following condition.
236
		if e.lastKind&(scalar|objectClose|arrayClose) != 0 &&
237
			next&(name|scalar|objectOpen|arrayOpen) != 0 {
238
			e.out = append(e.out, ',')
239
			// For single-line output, add a random extra space after each
240
			// comma to make output unstable.
241
			if detrand.Bool() {
242
				e.out = append(e.out, ' ')
243
			}
244
		}
245
		return
246
	}
247

248
	switch {
249
	case e.lastKind&(objectOpen|arrayOpen) != 0:
250
		// If next type is NOT closing, add indent and newline.
251
		if next&(objectClose|arrayClose) == 0 {
252
			e.indents = append(e.indents, e.indent...)
253
			e.out = append(e.out, '\n')
254
			e.out = append(e.out, e.indents...)
255
		}
256

257
	case e.lastKind&(scalar|objectClose|arrayClose) != 0:
258
		switch {
259
		// If next type is either a value or name, add comma and newline.
260
		case next&(name|scalar|objectOpen|arrayOpen) != 0:
261
			e.out = append(e.out, ',', '\n')
262

263
		// If next type is a closing object or array, adjust indentation.
264
		case next&(objectClose|arrayClose) != 0:
265
			e.indents = e.indents[:len(e.indents)-len(e.indent)]
266
			e.out = append(e.out, '\n')
267
		}
268
		e.out = append(e.out, e.indents...)
269

270
	case e.lastKind&name != 0:
271
		e.out = append(e.out, ' ')
272
		// For multi-line output, add a random extra space after key: to make
273
		// output unstable.
274
		if detrand.Bool() {
275
			e.out = append(e.out, ' ')
276
		}
277
	}
278
}
279