513 lines
9.8 KiB
Go
513 lines
9.8 KiB
Go
|
/**
|
||
|
|
* Copyright 2014 Paul Querna
|
||
|
|
*
|
||
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
|
|
* you may not use this file except in compliance with the License.
|
||
|
|
* You may obtain a copy of the License at
|
||
|
|
*
|
||
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||
|
|
*
|
||
|
|
* Unless required by applicable law or agreed to in writing, software
|
||
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
|
|
* See the License for the specific language governing permissions and
|
||
|
|
* limitations under the License.
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
|
||
|
|
/* Portions of this file are on Go stdlib's encoding/json/encode.go */
|
||
|
|
// 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 v1
|
||
|
|
|
||
|
|
import (
|
||
|
|
"io"
|
||
|
|
"unicode/utf8"
|
||
|
|
"strconv"
|
||
|
|
"unicode/utf16"
|
||
|
|
"unicode"
|
||
|
|
)
|
||
|
|
|
||
|
|
const hex = "0123456789abcdef"
|
||
|
|
|
||
|
|
type JsonStringWriter interface {
|
||
|
|
io.Writer
|
||
|
|
io.ByteWriter
|
||
|
|
stringWriter
|
||
|
|
}
|
||
|
|
|
||
|
|
func WriteJsonString(buf JsonStringWriter, s string) {
|
||
|
|
WriteJson(buf, []byte(s))
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Function ported from encoding/json: func (e *encodeState) string(s string) (int, error)
|
||
|
|
*/
|
||
|
|
func WriteJson(buf JsonStringWriter, s []byte) {
|
||
|
|
buf.WriteByte('"')
|
||
|
|
start := 0
|
||
|
|
for i := 0; i < len(s); {
|
||
|
|
if b := s[i]; b < utf8.RuneSelf {
|
||
|
|
/*
|
||
|
|
if 0x20 <= b && b != '\\' && b != '"' && b != '<' && b != '>' && b != '&' {
|
||
|
|
i++
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
*/
|
||
|
|
if lt[b] == true {
|
||
|
|
i++
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
|
||
|
|
if start < i {
|
||
|
|
buf.Write(s[start:i])
|
||
|
|
}
|
||
|
|
switch b {
|
||
|
|
case '\\', '"':
|
||
|
|
buf.WriteByte('\\')
|
||
|
|
buf.WriteByte(b)
|
||
|
|
case '\n':
|
||
|
|
buf.WriteByte('\\')
|
||
|
|
buf.WriteByte('n')
|
||
|
|
case '\r':
|
||
|
|
buf.WriteByte('\\')
|
||
|
|
buf.WriteByte('r')
|
||
|
|
default:
|
||
|
|
// This encodes bytes < 0x20 except for \n and \r,
|
||
|
|
// as well as < and >. The latter are escaped because they
|
||
|
|
// can lead to security holes when user-controlled strings
|
||
|
|
// are rendered into JSON and served to some browsers.
|
||
|
|
buf.WriteString(`\u00`)
|
||
|
|
buf.WriteByte(hex[b>>4])
|
||
|
|
buf.WriteByte(hex[b&0xF])
|
||
|
|
}
|
||
|
|
i++
|
||
|
|
start = i
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
c, size := utf8.DecodeRune(s[i:])
|
||
|
|
if c == utf8.RuneError && size == 1 {
|
||
|
|
if start < i {
|
||
|
|
buf.Write(s[start:i])
|
||
|
|
}
|
||
|
|
buf.WriteString(`\ufffd`)
|
||
|
|
i += size
|
||
|
|
start = i
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
// U+2028 is LINE SEPARATOR.
|
||
|
|
// U+2029 is PARAGRAPH SEPARATOR.
|
||
|
|
// They are both technically valid characters in JSON strings,
|
||
|
|
// but don't work in JSONP, which has to be evaluated as JavaScript,
|
||
|
|
// and can lead to security holes there. It is valid JSON to
|
||
|
|
// escape them, so we do so unconditionally.
|
||
|
|
// See http://timelessrepo.com/json-isnt-a-javascript-subset for discussion.
|
||
|
|
if c == '\u2028' || c == '\u2029' {
|
||
|
|
if start < i {
|
||
|
|
buf.Write(s[start:i])
|
||
|
|
}
|
||
|
|
buf.WriteString(`\u202`)
|
||
|
|
buf.WriteByte(hex[c&0xF])
|
||
|
|
i += size
|
||
|
|
start = i
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
i += size
|
||
|
|
}
|
||
|
|
if start < len(s) {
|
||
|
|
buf.Write(s[start:])
|
||
|
|
}
|
||
|
|
buf.WriteByte('"')
|
||
|
|
}
|
||
|
|
|
||
|
|
// UnquoteBytes will decode []byte containing json string to go string
|
||
|
|
// ported from encoding/json/decode.go
|
||
|
|
func UnquoteBytes(s []byte) (t []byte, ok bool) {
|
||
|
|
if len(s) < 2 || s[0] != '"' || s[len(s)-1] != '"' {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
s = s[1 : len(s)-1]
|
||
|
|
|
||
|
|
// Check for unusual characters. If there are none,
|
||
|
|
// then no unquoting is needed, so return a slice of the
|
||
|
|
// original bytes.
|
||
|
|
r := 0
|
||
|
|
for r < len(s) {
|
||
|
|
c := s[r]
|
||
|
|
if c == '\\' || c == '"' || c < ' ' {
|
||
|
|
break
|
||
|
|
}
|
||
|
|
if c < utf8.RuneSelf {
|
||
|
|
r++
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
rr, size := utf8.DecodeRune(s[r:])
|
||
|
|
if rr == utf8.RuneError && size == 1 {
|
||
|
|
break
|
||
|
|
}
|
||
|
|
r += size
|
||
|
|
}
|
||
|
|
if r == len(s) {
|
||
|
|
return s, true
|
||
|
|
}
|
||
|
|
|
||
|
|
b := make([]byte, len(s)+2*utf8.UTFMax)
|
||
|
|
w := copy(b, s[0:r])
|
||
|
|
for r < len(s) {
|
||
|
|
// Out of room? Can only happen if s is full of
|
||
|
|
// malformed UTF-8 and we're replacing each
|
||
|
|
// byte with RuneError.
|
||
|
|
if w >= len(b)-2*utf8.UTFMax {
|
||
|
|
nb := make([]byte, (len(b)+utf8.UTFMax)*2)
|
||
|
|
copy(nb, b[0:w])
|
||
|
|
b = nb
|
||
|
|
}
|
||
|
|
switch c := s[r]; {
|
||
|
|
case c == '\\':
|
||
|
|
r++
|
||
|
|
if r >= len(s) {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
switch s[r] {
|
||
|
|
default:
|
||
|
|
return
|
||
|
|
case '"', '\\', '/', '\'':
|
||
|
|
b[w] = s[r]
|
||
|
|
r++
|
||
|
|
w++
|
||
|
|
case 'b':
|
||
|
|
b[w] = '\b'
|
||
|
|
r++
|
||
|
|
w++
|
||
|
|
case 'f':
|
||
|
|
b[w] = '\f'
|
||
|
|
r++
|
||
|
|
w++
|
||
|
|
case 'n':
|
||
|
|
b[w] = '\n'
|
||
|
|
r++
|
||
|
|
w++
|
||
|
|
case 'r':
|
||
|
|
b[w] = '\r'
|
||
|
|
r++
|
||
|
|
w++
|
||
|
|
case 't':
|
||
|
|
b[w] = '\t'
|
||
|
|
r++
|
||
|
|
w++
|
||
|
|
case 'u':
|
||
|
|
r--
|
||
|
|
rr := getu4(s[r:])
|
||
|
|
if rr < 0 {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
r += 6
|
||
|
|
if utf16.IsSurrogate(rr) {
|
||
|
|
rr1 := getu4(s[r:])
|
||
|
|
if dec := utf16.DecodeRune(rr, rr1); dec != unicode.ReplacementChar {
|
||
|
|
// A valid pair; consume.
|
||
|
|
r += 6
|
||
|
|
w += utf8.EncodeRune(b[w:], dec)
|
||
|
|
break
|
||
|
|
}
|
||
|
|
// Invalid surrogate; fall back to replacement rune.
|
||
|
|
rr = unicode.ReplacementChar
|
||
|
|
}
|
||
|
|
w += utf8.EncodeRune(b[w:], rr)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Quote, control characters are invalid.
|
||
|
|
case c == '"', c < ' ':
|
||
|
|
return
|
||
|
|
|
||
|
|
// ASCII
|
||
|
|
case c < utf8.RuneSelf:
|
||
|
|
b[w] = c
|
||
|
|
r++
|
||
|
|
w++
|
||
|
|
|
||
|
|
// Coerce to well-formed UTF-8.
|
||
|
|
default:
|
||
|
|
rr, size := utf8.DecodeRune(s[r:])
|
||
|
|
r += size
|
||
|
|
w += utf8.EncodeRune(b[w:], rr)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return b[0:w], true
|
||
|
|
}
|
||
|
|
|
||
|
|
// getu4 decodes \uXXXX from the beginning of s, returning the hex value,
|
||
|
|
// or it returns -1.
|
||
|
|
func getu4(s []byte) rune {
|
||
|
|
if len(s) < 6 || s[0] != '\\' || s[1] != 'u' {
|
||
|
|
return -1
|
||
|
|
}
|
||
|
|
r, err := strconv.ParseUint(string(s[2:6]), 16, 64)
|
||
|
|
if err != nil {
|
||
|
|
return -1
|
||
|
|
}
|
||
|
|
return rune(r)
|
||
|
|
}
|
||
|
|
|
||
|
|
// TODO(pquerna): consider combining wibth the normal byte mask.
|
||
|
|
var lt [256]bool = [256]bool{
|
||
|
|
false, /* 0 */
|
||
|
|
false, /* 1 */
|
||
|
|
false, /* 2 */
|
||
|
|
false, /* 3 */
|
||
|
|
false, /* 4 */
|
||
|
|
false, /* 5 */
|
||
|
|
false, /* 6 */
|
||
|
|
false, /* 7 */
|
||
|
|
false, /* 8 */
|
||
|
|
false, /* 9 */
|
||
|
|
false, /* 10 */
|
||
|
|
false, /* 11 */
|
||
|
|
false, /* 12 */
|
||
|
|
false, /* 13 */
|
||
|
|
false, /* 14 */
|
||
|
|
false, /* 15 */
|
||
|
|
false, /* 16 */
|
||
|
|
false, /* 17 */
|
||
|
|
false, /* 18 */
|
||
|
|
false, /* 19 */
|
||
|
|
false, /* 20 */
|
||
|
|
false, /* 21 */
|
||
|
|
false, /* 22 */
|
||
|
|
false, /* 23 */
|
||
|
|
false, /* 24 */
|
||
|
|
false, /* 25 */
|
||
|
|
false, /* 26 */
|
||
|
|
false, /* 27 */
|
||
|
|
false, /* 28 */
|
||
|
|
false, /* 29 */
|
||
|
|
false, /* 30 */
|
||
|
|
false, /* 31 */
|
||
|
|
true, /* 32 */
|
||
|
|
true, /* 33 */
|
||
|
|
false, /* 34 */
|
||
|
|
true, /* 35 */
|
||
|
|
true, /* 36 */
|
||
|
|
true, /* 37 */
|
||
|
|
false, /* 38 */
|
||
|
|
true, /* 39 */
|
||
|
|
true, /* 40 */
|
||
|
|
true, /* 41 */
|
||
|
|
true, /* 42 */
|
||
|
|
true, /* 43 */
|
||
|
|
true, /* 44 */
|
||
|
|
true, /* 45 */
|
||
|
|
true, /* 46 */
|
||
|
|
true, /* 47 */
|
||
|
|
true, /* 48 */
|
||
|
|
true, /* 49 */
|
||
|
|
true, /* 50 */
|
||
|
|
true, /* 51 */
|
||
|
|
true, /* 52 */
|
||
|
|
true, /* 53 */
|
||
|
|
true, /* 54 */
|
||
|
|
true, /* 55 */
|
||
|
|
true, /* 56 */
|
||
|
|
true, /* 57 */
|
||
|
|
true, /* 58 */
|
||
|
|
true, /* 59 */
|
||
|
|
false, /* 60 */
|
||
|
|
true, /* 61 */
|
||
|
|
false, /* 62 */
|
||
|
|
true, /* 63 */
|
||
|
|
true, /* 64 */
|
||
|
|
true, /* 65 */
|
||
|
|
true, /* 66 */
|
||
|
|
true, /* 67 */
|
||
|
|
true, /* 68 */
|
||
|
|
true, /* 69 */
|
||
|
|
true, /* 70 */
|
||
|
|
true, /* 71 */
|
||
|
|
true, /* 72 */
|
||
|
|
true, /* 73 */
|
||
|
|
true, /* 74 */
|
||
|
|
true, /* 75 */
|
||
|
|
true, /* 76 */
|
||
|
|
true, /* 77 */
|
||
|
|
true, /* 78 */
|
||
|
|
true, /* 79 */
|
||
|
|
true, /* 80 */
|
||
|
|
true, /* 81 */
|
||
|
|
true, /* 82 */
|
||
|
|
true, /* 83 */
|
||
|
|
true, /* 84 */
|
||
|
|
true, /* 85 */
|
||
|
|
true, /* 86 */
|
||
|
|
true, /* 87 */
|
||
|
|
true, /* 88 */
|
||
|
|
true, /* 89 */
|
||
|
|
true, /* 90 */
|
||
|
|
true, /* 91 */
|
||
|
|
false, /* 92 */
|
||
|
|
true, /* 93 */
|
||
|
|
true, /* 94 */
|
||
|
|
true, /* 95 */
|
||
|
|
true, /* 96 */
|
||
|
|
true, /* 97 */
|
||
|
|
true, /* 98 */
|
||
|
|
true, /* 99 */
|
||
|
|
true, /* 100 */
|
||
|
|
true, /* 101 */
|
||
|
|
true, /* 102 */
|
||
|
|
true, /* 103 */
|
||
|
|
true, /* 104 */
|
||
|
|
true, /* 105 */
|
||
|
|
true, /* 106 */
|
||
|
|
true, /* 107 */
|
||
|
|
true, /* 108 */
|
||
|
|
true, /* 109 */
|
||
|
|
true, /* 110 */
|
||
|
|
true, /* 111 */
|
||
|
|
true, /* 112 */
|
||
|
|
true, /* 113 */
|
||
|
|
true, /* 114 */
|
||
|
|
true, /* 115 */
|
||
|
|
true, /* 116 */
|
||
|
|
true, /* 117 */
|
||
|
|
true, /* 118 */
|
||
|
|
true, /* 119 */
|
||
|
|
true, /* 120 */
|
||
|
|
true, /* 121 */
|
||
|
|
true, /* 122 */
|
||
|
|
true, /* 123 */
|
||
|
|
true, /* 124 */
|
||
|
|
true, /* 125 */
|
||
|
|
true, /* 126 */
|
||
|
|
true, /* 127 */
|
||
|
|
true, /* 128 */
|
||
|
|
true, /* 129 */
|
||
|
|
true, /* 130 */
|
||
|
|
true, /* 131 */
|
||
|
|
true, /* 132 */
|
||
|
|
true, /* 133 */
|
||
|
|
true, /* 134 */
|
||
|
|
true, /* 135 */
|
||
|
|
true, /* 136 */
|
||
|
|
true, /* 137 */
|
||
|
|
true, /* 138 */
|
||
|
|
true, /* 139 */
|
||
|
|
true, /* 140 */
|
||
|
|
true, /* 141 */
|
||
|
|
true, /* 142 */
|
||
|
|
true, /* 143 */
|
||
|
|
true, /* 144 */
|
||
|
|
true, /* 145 */
|
||
|
|
true, /* 146 */
|
||
|
|
true, /* 147 */
|
||
|
|
true, /* 148 */
|
||
|
|
true, /* 149 */
|
||
|
|
true, /* 150 */
|
||
|
|
true, /* 151 */
|
||
|
|
true, /* 152 */
|
||
|
|
true, /* 153 */
|
||
|
|
true, /* 154 */
|
||
|
|
true, /* 155 */
|
||
|
|
true, /* 156 */
|
||
|
|
true, /* 157 */
|
||
|
|
true, /* 158 */
|
||
|
|
true, /* 159 */
|
||
|
|
true, /* 160 */
|
||
|
|
true, /* 161 */
|
||
|
|
true, /* 162 */
|
||
|
|
true, /* 163 */
|
||
|
|
true, /* 164 */
|
||
|
|
true, /* 165 */
|
||
|
|
true, /* 166 */
|
||
|
|
true, /* 167 */
|
||
|
|
true, /* 168 */
|
||
|
|
true, /* 169 */
|
||
|
|
true, /* 170 */
|
||
|
|
true, /* 171 */
|
||
|
|
true, /* 172 */
|
||
|
|
true, /* 173 */
|
||
|
|
true, /* 174 */
|
||
|
|
true, /* 175 */
|
||
|
|
true, /* 176 */
|
||
|
|
true, /* 177 */
|
||
|
|
true, /* 178 */
|
||
|
|
true, /* 179 */
|
||
|
|
true, /* 180 */
|
||
|
|
true, /* 181 */
|
||
|
|
true, /* 182 */
|
||
|
|
true, /* 183 */
|
||
|
|
true, /* 184 */
|
||
|
|
true, /* 185 */
|
||
|
|
true, /* 186 */
|
||
|
|
true, /* 187 */
|
||
|
|
true, /* 188 */
|
||
|
|
true, /* 189 */
|
||
|
|
true, /* 190 */
|
||
|
|
true, /* 191 */
|
||
|
|
true, /* 192 */
|
||
|
|
true, /* 193 */
|
||
|
|
true, /* 194 */
|
||
|
|
true, /* 195 */
|
||
|
|
true, /* 196 */
|
||
|
|
true, /* 197 */
|
||
|
|
true, /* 198 */
|
||
|
|
true, /* 199 */
|
||
|
|
true, /* 200 */
|
||
|
|
true, /* 201 */
|
||
|
|
true, /* 202 */
|
||
|
|
true, /* 203 */
|
||
|
|
true, /* 204 */
|
||
|
|
true, /* 205 */
|
||
|
|
true, /* 206 */
|
||
|
|
true, /* 207 */
|
||
|
|
true, /* 208 */
|
||
|
|
true, /* 209 */
|
||
|
|
true, /* 210 */
|
||
|
|
true, /* 211 */
|
||
|
|
true, /* 212 */
|
||
|
|
true, /* 213 */
|
||
|
|
true, /* 214 */
|
||
|
|
true, /* 215 */
|
||
|
|
true, /* 216 */
|
||
|
|
true, /* 217 */
|
||
|
|
true, /* 218 */
|
||
|
|
true, /* 219 */
|
||
|
|
true, /* 220 */
|
||
|
|
true, /* 221 */
|
||
|
|
true, /* 222 */
|
||
|
|
true, /* 223 */
|
||
|
|
true, /* 224 */
|
||
|
|
true, /* 225 */
|
||
|
|
true, /* 226 */
|
||
|
|
true, /* 227 */
|
||
|
|
true, /* 228 */
|
||
|
|
true, /* 229 */
|
||
|
|
true, /* 230 */
|
||
|
|
true, /* 231 */
|
||
|
|
true, /* 232 */
|
||
|
|
true, /* 233 */
|
||
|
|
true, /* 234 */
|
||
|
|
true, /* 235 */
|
||
|
|
true, /* 236 */
|
||
|
|
true, /* 237 */
|
||
|
|
true, /* 238 */
|
||
|
|
true, /* 239 */
|
||
|
|
true, /* 240 */
|
||
|
|
true, /* 241 */
|
||
|
|
true, /* 242 */
|
||
|
|
true, /* 243 */
|
||
|
|
true, /* 244 */
|
||
|
|
true, /* 245 */
|
||
|
|
true, /* 246 */
|
||
|
|
true, /* 247 */
|
||
|
|
true, /* 248 */
|
||
|
|
true, /* 249 */
|
||
|
|
true, /* 250 */
|
||
|
|
true, /* 251 */
|
||
|
|
true, /* 252 */
|
||
|
|
true, /* 253 */
|
||
|
|
true, /* 254 */
|
||
|
|
true, /* 255 */
|
||
|
|
}
|