Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
Xiaomi
soar
提交
ee667a09
S
soar
项目概览
Xiaomi
/
soar
9 个月 前同步成功
通知
373
Star
8512
Fork
1328
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
S
soar
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
提交
Issue看板
前往新版Gitcode,体验更适合开发者的 AI 搜索 >>
提交
ee667a09
编写于
1月 10, 2019
作者:
martianzhang
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
tiast-json marshal unexported type
change encoding/json -> github.com/CorgiMan/json2
上级
d891be61
变更
8
展开全部
隐藏空白更改
内联
并排
Showing
8 changed file
with
3220 addition
and
2 deletion
+3220
-2
ast/tidb.go
ast/tidb.go
+2
-2
vendor/github.com/CorgiMan/json2/README.md
vendor/github.com/CorgiMan/json2/README.md
+0
-0
vendor/github.com/CorgiMan/json2/decode.go
vendor/github.com/CorgiMan/json2/decode.go
+1047
-0
vendor/github.com/CorgiMan/json2/encode.go
vendor/github.com/CorgiMan/json2/encode.go
+1168
-0
vendor/github.com/CorgiMan/json2/indent.go
vendor/github.com/CorgiMan/json2/indent.go
+136
-0
vendor/github.com/CorgiMan/json2/scanner.go
vendor/github.com/CorgiMan/json2/scanner.go
+623
-0
vendor/github.com/CorgiMan/json2/stream.go
vendor/github.com/CorgiMan/json2/stream.go
+200
-0
vendor/github.com/CorgiMan/json2/tags.go
vendor/github.com/CorgiMan/json2/tags.go
+44
-0
未找到文件。
ast/tidb.go
浏览文件 @
ee667a09
...
...
@@ -17,14 +17,14 @@
package
ast
import
(
"encoding/json"
"github.com/XiaoMi/soar/common"
"github.com/kr/pretty"
"github.com/pingcap/parser"
"github.com/pingcap/parser/ast"
json
"github.com/CorgiMan/json2"
// for pingcap parser
_
"github.com/pingcap/tidb/types/parser_driver"
)
...
...
vendor/github.com/CorgiMan/json2/README.md
0 → 100644
浏览文件 @
ee667a09
B
#JSON2
vendor/github.com/CorgiMan/json2/decode.go
0 → 100644
浏览文件 @
ee667a09
此差异已折叠。
点击以展开。
vendor/github.com/CorgiMan/json2/encode.go
0 → 100644
浏览文件 @
ee667a09
此差异已折叠。
点击以展开。
vendor/github.com/CorgiMan/json2/indent.go
0 → 100644
浏览文件 @
ee667a09
// 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
json2
import
"bytes"
// Compact appends to dst the JSON-encoded src with
// insignificant space characters elided.
func
Compact
(
dst
*
bytes
.
Buffer
,
src
[]
byte
)
error
{
return
compact
(
dst
,
src
,
false
)
}
func
compact
(
dst
*
bytes
.
Buffer
,
src
[]
byte
,
escape
bool
)
error
{
origLen
:=
dst
.
Len
()
var
scan
scanner
scan
.
reset
()
start
:=
0
for
i
,
c
:=
range
src
{
if
escape
&&
(
c
==
'<'
||
c
==
'>'
||
c
==
'&'
)
{
if
start
<
i
{
dst
.
Write
(
src
[
start
:
i
])
}
dst
.
WriteString
(
`\u00`
)
dst
.
WriteByte
(
hex
[
c
>>
4
])
dst
.
WriteByte
(
hex
[
c
&
0xF
])
start
=
i
+
1
}
// Convert U+2028 and U+2029 (E2 80 A8 and E2 80 A9).
if
c
==
0xE2
&&
i
+
2
<
len
(
src
)
&&
src
[
i
+
1
]
==
0x80
&&
src
[
i
+
2
]
&^
1
==
0xA8
{
if
start
<
i
{
dst
.
Write
(
src
[
start
:
i
])
}
dst
.
WriteString
(
`\u202`
)
dst
.
WriteByte
(
hex
[
src
[
i
+
2
]
&
0xF
])
start
=
i
+
3
}
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
}
vendor/github.com/CorgiMan/json2/scanner.go
0 → 100644
浏览文件 @
ee667a09
// 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
json2
// JSON value parser state machine.
// Just about at the limit of what is reasonable to write by hand.
// Some parts are a bit tedious, but overall it nicely factors out the
// otherwise common code from the multiple scanning functions
// in this package (Compact, Indent, checkValid, nextValue, etc).
//
// This file starts with two simple examples using the scanner
// before diving into the scanner itself.
import
"strconv"
// checkValid verifies that data is valid JSON-encoded data.
// scan is passed in for use by checkValid to avoid an allocation.
func
checkValid
(
data
[]
byte
,
scan
*
scanner
)
error
{
scan
.
reset
()
for
_
,
c
:=
range
data
{
scan
.
bytes
++
if
scan
.
step
(
scan
,
int
(
c
))
==
scanError
{
return
scan
.
err
}
}
if
scan
.
eof
()
==
scanError
{
return
scan
.
err
}
return
nil
}
// nextValue splits data after the next whole JSON value,
// returning that value and the bytes that follow it as separate slices.
// scan is passed in for use by nextValue to avoid an allocation.
func
nextValue
(
data
[]
byte
,
scan
*
scanner
)
(
value
,
rest
[]
byte
,
err
error
)
{
scan
.
reset
()
for
i
,
c
:=
range
data
{
v
:=
scan
.
step
(
scan
,
int
(
c
))
if
v
>=
scanEnd
{
switch
v
{
case
scanError
:
return
nil
,
nil
,
scan
.
err
case
scanEnd
:
return
data
[
0
:
i
],
data
[
i
:
],
nil
}
}
}
if
scan
.
eof
()
==
scanError
{
return
nil
,
nil
,
scan
.
err
}
return
data
,
nil
,
nil
}
// A SyntaxError is a description of a JSON syntax error.
type
SyntaxError
struct
{
msg
string
// description of error
Offset
int64
// error occurred after reading Offset bytes
}
func
(
e
*
SyntaxError
)
Error
()
string
{
return
e
.
msg
}
// A scanner is a JSON scanning state machine.
// Callers call scan.reset() and then pass bytes in one at a time
// by calling scan.step(&scan, c) for each byte.
// The return value, referred to as an opcode, tells the
// caller about significant parsing events like beginning
// and ending literals, objects, and arrays, so that the
// caller can follow along if it wishes.
// The return value scanEnd indicates that a single top-level
// JSON value has been completed, *before* the byte that
// just got passed in. (The indication must be delayed in order
// to recognize the end of numbers: is 123 a whole value or
// the beginning of 12345e+6?).
type
scanner
struct
{
// The step is a func to be called to execute the next transition.
// Also tried using an integer constant and a single func
// with a switch, but using the func directly was 10% faster
// on a 64-bit Mac Mini, and it's nicer to read.
step
func
(
*
scanner
,
int
)
int
// Reached end of top-level value.
endTop
bool
// Stack of what we're in the middle of - array values, object keys, object values.
parseState
[]
int
// Error that happened, if any.
err
error
// 1-byte redo (see undo method)
redo
bool
redoCode
int
redoState
func
(
*
scanner
,
int
)
int
// total bytes consumed, updated by decoder.Decode
bytes
int64
}
// These values are returned by the state transition functions
// assigned to scanner.state and the method scanner.eof.
// They give details about the current state of the scan that
// callers might be interested to know about.
// It is okay to ignore the return value of any particular
// call to scanner.state: if one call returns scanError,
// every subsequent call will return scanError too.
const
(
// Continue.
scanContinue
=
iota
// uninteresting byte
scanBeginLiteral
// end implied by next result != scanContinue
scanBeginObject
// begin object
scanObjectKey
// just finished object key (string)
scanObjectValue
// just finished non-last object value
scanEndObject
// end object (implies scanObjectValue if possible)
scanBeginArray
// begin array
scanArrayValue
// just finished array value
scanEndArray
// end array (implies scanArrayValue if possible)
scanSkipSpace
// space byte; can skip; known to be last "continue" result
// Stop.
scanEnd
// top-level value ended *before* this byte; known to be first "stop" result
scanError
// hit an error, scanner.err.
)
// These values are stored in the parseState stack.
// They give the current state of a composite value
// being scanned. If the parser is inside a nested value
// the parseState describes the nested state, outermost at entry 0.
const
(
parseObjectKey
=
iota
// parsing object key (before colon)
parseObjectValue
// parsing object value (after colon)
parseArrayValue
// parsing array value
)
// reset prepares the scanner for use.
// It must be called before calling s.step.
func
(
s
*
scanner
)
reset
()
{
s
.
step
=
stateBeginValue
s
.
parseState
=
s
.
parseState
[
0
:
0
]
s
.
err
=
nil
s
.
redo
=
false
s
.
endTop
=
false
}
// eof tells the scanner that the end of input has been reached.
// It returns a scan status just as s.step does.
func
(
s
*
scanner
)
eof
()
int
{
if
s
.
err
!=
nil
{
return
scanError
}
if
s
.
endTop
{
return
scanEnd
}
s
.
step
(
s
,
' '
)
if
s
.
endTop
{
return
scanEnd
}
if
s
.
err
==
nil
{
s
.
err
=
&
SyntaxError
{
"unexpected end of JSON input"
,
s
.
bytes
}
}
return
scanError
}
// pushParseState pushes a new parse state p onto the parse stack.
func
(
s
*
scanner
)
pushParseState
(
p
int
)
{
s
.
parseState
=
append
(
s
.
parseState
,
p
)
}
// popParseState pops a parse state (already obtained) off the stack
// and updates s.step accordingly.
func
(
s
*
scanner
)
popParseState
()
{
n
:=
len
(
s
.
parseState
)
-
1
s
.
parseState
=
s
.
parseState
[
0
:
n
]
s
.
redo
=
false
if
n
==
0
{
s
.
step
=
stateEndTop
s
.
endTop
=
true
}
else
{
s
.
step
=
stateEndValue
}
}
func
isSpace
(
c
rune
)
bool
{
return
c
==
' '
||
c
==
'\t'
||
c
==
'\r'
||
c
==
'\n'
}
// stateBeginValueOrEmpty is the state after reading `[`.
func
stateBeginValueOrEmpty
(
s
*
scanner
,
c
int
)
int
{
if
c
<=
' '
&&
isSpace
(
rune
(
c
))
{
return
scanSkipSpace
}
if
c
==
']'
{
return
stateEndValue
(
s
,
c
)
}
return
stateBeginValue
(
s
,
c
)
}
// stateBeginValue is the state at the beginning of the input.
func
stateBeginValue
(
s
*
scanner
,
c
int
)
int
{
if
c
<=
' '
&&
isSpace
(
rune
(
c
))
{
return
scanSkipSpace
}
switch
c
{
case
'{'
:
s
.
step
=
stateBeginStringOrEmpty
s
.
pushParseState
(
parseObjectKey
)
return
scanBeginObject
case
'['
:
s
.
step
=
stateBeginValueOrEmpty
s
.
pushParseState
(
parseArrayValue
)
return
scanBeginArray
case
'"'
:
s
.
step
=
stateInString
return
scanBeginLiteral
case
'-'
:
s
.
step
=
stateNeg
return
scanBeginLiteral
case
'0'
:
// beginning of 0.123
s
.
step
=
state0
return
scanBeginLiteral
case
't'
:
// beginning of true
s
.
step
=
stateT
return
scanBeginLiteral
case
'f'
:
// beginning of false
s
.
step
=
stateF
return
scanBeginLiteral
case
'n'
:
// beginning of null
s
.
step
=
stateN
return
scanBeginLiteral
}
if
'1'
<=
c
&&
c
<=
'9'
{
// beginning of 1234.5
s
.
step
=
state1
return
scanBeginLiteral
}
return
s
.
error
(
c
,
"looking for beginning of value"
)
}
// stateBeginStringOrEmpty is the state after reading `{`.
func
stateBeginStringOrEmpty
(
s
*
scanner
,
c
int
)
int
{
if
c
<=
' '
&&
isSpace
(
rune
(
c
))
{
return
scanSkipSpace
}
if
c
==
'}'
{
n
:=
len
(
s
.
parseState
)
s
.
parseState
[
n
-
1
]
=
parseObjectValue
return
stateEndValue
(
s
,
c
)
}
return
stateBeginString
(
s
,
c
)
}
// stateBeginString is the state after reading `{"key": value,`.
func
stateBeginString
(
s
*
scanner
,
c
int
)
int
{
if
c
<=
' '
&&
isSpace
(
rune
(
c
))
{
return
scanSkipSpace
}
if
c
==
'"'
{
s
.
step
=
stateInString
return
scanBeginLiteral
}
return
s
.
error
(
c
,
"looking for beginning of object key string"
)
}
// stateEndValue is the state after completing a value,
// such as after reading `{}` or `true` or `["x"`.
func
stateEndValue
(
s
*
scanner
,
c
int
)
int
{
n
:=
len
(
s
.
parseState
)
if
n
==
0
{
// Completed top-level before the current byte.
s
.
step
=
stateEndTop
s
.
endTop
=
true
return
stateEndTop
(
s
,
c
)
}
if
c
<=
' '
&&
isSpace
(
rune
(
c
))
{
s
.
step
=
stateEndValue
return
scanSkipSpace
}
ps
:=
s
.
parseState
[
n
-
1
]
switch
ps
{
case
parseObjectKey
:
if
c
==
':'
{
s
.
parseState
[
n
-
1
]
=
parseObjectValue
s
.
step
=
stateBeginValue
return
scanObjectKey
}
return
s
.
error
(
c
,
"after object key"
)
case
parseObjectValue
:
if
c
==
','
{
s
.
parseState
[
n
-
1
]
=
parseObjectKey
s
.
step
=
stateBeginString
return
scanObjectValue
}
if
c
==
'}'
{
s
.
popParseState
()
return
scanEndObject
}
return
s
.
error
(
c
,
"after object key:value pair"
)
case
parseArrayValue
:
if
c
==
','
{
s
.
step
=
stateBeginValue
return
scanArrayValue
}
if
c
==
']'
{
s
.
popParseState
()
return
scanEndArray
}
return
s
.
error
(
c
,
"after array element"
)
}
return
s
.
error
(
c
,
""
)
}
// stateEndTop is the state after finishing the top-level value,
// such as after reading `{}` or `[1,2,3]`.
// Only space characters should be seen now.
func
stateEndTop
(
s
*
scanner
,
c
int
)
int
{
if
c
!=
' '
&&
c
!=
'\t'
&&
c
!=
'\r'
&&
c
!=
'\n'
{
// Complain about non-space byte on next call.
s
.
error
(
c
,
"after top-level value"
)
}
return
scanEnd
}
// stateInString is the state after reading `"`.
func
stateInString
(
s
*
scanner
,
c
int
)
int
{
if
c
==
'"'
{
s
.
step
=
stateEndValue
return
scanContinue
}
if
c
==
'\\'
{
s
.
step
=
stateInStringEsc
return
scanContinue
}
if
c
<
0x20
{
return
s
.
error
(
c
,
"in string literal"
)
}
return
scanContinue
}
// stateInStringEsc is the state after reading `"\` during a quoted string.
func
stateInStringEsc
(
s
*
scanner
,
c
int
)
int
{
switch
c
{
case
'b'
,
'f'
,
'n'
,
'r'
,
't'
,
'\\'
,
'/'
,
'"'
:
s
.
step
=
stateInString
return
scanContinue
}
if
c
==
'u'
{
s
.
step
=
stateInStringEscU
return
scanContinue
}
return
s
.
error
(
c
,
"in string escape code"
)
}
// stateInStringEscU is the state after reading `"\u` during a quoted string.
func
stateInStringEscU
(
s
*
scanner
,
c
int
)
int
{
if
'0'
<=
c
&&
c
<=
'9'
||
'a'
<=
c
&&
c
<=
'f'
||
'A'
<=
c
&&
c
<=
'F'
{
s
.
step
=
stateInStringEscU1
return
scanContinue
}
// numbers
return
s
.
error
(
c
,
"in
\\
u hexadecimal character escape"
)
}
// stateInStringEscU1 is the state after reading `"\u1` during a quoted string.
func
stateInStringEscU1
(
s
*
scanner
,
c
int
)
int
{
if
'0'
<=
c
&&
c
<=
'9'
||
'a'
<=
c
&&
c
<=
'f'
||
'A'
<=
c
&&
c
<=
'F'
{
s
.
step
=
stateInStringEscU12
return
scanContinue
}
// numbers
return
s
.
error
(
c
,
"in
\\
u hexadecimal character escape"
)
}
// stateInStringEscU12 is the state after reading `"\u12` during a quoted string.
func
stateInStringEscU12
(
s
*
scanner
,
c
int
)
int
{
if
'0'
<=
c
&&
c
<=
'9'
||
'a'
<=
c
&&
c
<=
'f'
||
'A'
<=
c
&&
c
<=
'F'
{
s
.
step
=
stateInStringEscU123
return
scanContinue
}
// numbers
return
s
.
error
(
c
,
"in
\\
u hexadecimal character escape"
)
}
// stateInStringEscU123 is the state after reading `"\u123` during a quoted string.
func
stateInStringEscU123
(
s
*
scanner
,
c
int
)
int
{
if
'0'
<=
c
&&
c
<=
'9'
||
'a'
<=
c
&&
c
<=
'f'
||
'A'
<=
c
&&
c
<=
'F'
{
s
.
step
=
stateInString
return
scanContinue
}
// numbers
return
s
.
error
(
c
,
"in
\\
u hexadecimal character escape"
)
}
// stateNeg is the state after reading `-` during a number.
func
stateNeg
(
s
*
scanner
,
c
int
)
int
{
if
c
==
'0'
{
s
.
step
=
state0
return
scanContinue
}
if
'1'
<=
c
&&
c
<=
'9'
{
s
.
step
=
state1
return
scanContinue
}
return
s
.
error
(
c
,
"in numeric literal"
)
}
// state1 is the state after reading a non-zero integer during a number,
// such as after reading `1` or `100` but not `0`.
func
state1
(
s
*
scanner
,
c
int
)
int
{
if
'0'
<=
c
&&
c
<=
'9'
{
s
.
step
=
state1
return
scanContinue
}
return
state0
(
s
,
c
)
}
// state0 is the state after reading `0` during a number.
func
state0
(
s
*
scanner
,
c
int
)
int
{
if
c
==
'.'
{
s
.
step
=
stateDot
return
scanContinue
}
if
c
==
'e'
||
c
==
'E'
{
s
.
step
=
stateE
return
scanContinue
}
return
stateEndValue
(
s
,
c
)
}
// stateDot is the state after reading the integer and decimal point in a number,
// such as after reading `1.`.
func
stateDot
(
s
*
scanner
,
c
int
)
int
{
if
'0'
<=
c
&&
c
<=
'9'
{
s
.
step
=
stateDot0
return
scanContinue
}
return
s
.
error
(
c
,
"after decimal point in numeric literal"
)
}
// stateDot0 is the state after reading the integer, decimal point, and subsequent
// digits of a number, such as after reading `3.14`.
func
stateDot0
(
s
*
scanner
,
c
int
)
int
{
if
'0'
<=
c
&&
c
<=
'9'
{
s
.
step
=
stateDot0
return
scanContinue
}
if
c
==
'e'
||
c
==
'E'
{
s
.
step
=
stateE
return
scanContinue
}
return
stateEndValue
(
s
,
c
)
}
// stateE is the state after reading the mantissa and e in a number,
// such as after reading `314e` or `0.314e`.
func
stateE
(
s
*
scanner
,
c
int
)
int
{
if
c
==
'+'
{
s
.
step
=
stateESign
return
scanContinue
}
if
c
==
'-'
{
s
.
step
=
stateESign
return
scanContinue
}
return
stateESign
(
s
,
c
)
}
// stateESign is the state after reading the mantissa, e, and sign in a number,
// such as after reading `314e-` or `0.314e+`.
func
stateESign
(
s
*
scanner
,
c
int
)
int
{
if
'0'
<=
c
&&
c
<=
'9'
{
s
.
step
=
stateE0
return
scanContinue
}
return
s
.
error
(
c
,
"in exponent of numeric literal"
)
}
// stateE0 is the state after reading the mantissa, e, optional sign,
// and at least one digit of the exponent in a number,
// such as after reading `314e-2` or `0.314e+1` or `3.14e0`.
func
stateE0
(
s
*
scanner
,
c
int
)
int
{
if
'0'
<=
c
&&
c
<=
'9'
{
s
.
step
=
stateE0
return
scanContinue
}
return
stateEndValue
(
s
,
c
)
}
// stateT is the state after reading `t`.
func
stateT
(
s
*
scanner
,
c
int
)
int
{
if
c
==
'r'
{
s
.
step
=
stateTr
return
scanContinue
}
return
s
.
error
(
c
,
"in literal true (expecting 'r')"
)
}
// stateTr is the state after reading `tr`.
func
stateTr
(
s
*
scanner
,
c
int
)
int
{
if
c
==
'u'
{
s
.
step
=
stateTru
return
scanContinue
}
return
s
.
error
(
c
,
"in literal true (expecting 'u')"
)
}
// stateTru is the state after reading `tru`.
func
stateTru
(
s
*
scanner
,
c
int
)
int
{
if
c
==
'e'
{
s
.
step
=
stateEndValue
return
scanContinue
}
return
s
.
error
(
c
,
"in literal true (expecting 'e')"
)
}
// stateF is the state after reading `f`.
func
stateF
(
s
*
scanner
,
c
int
)
int
{
if
c
==
'a'
{
s
.
step
=
stateFa
return
scanContinue
}
return
s
.
error
(
c
,
"in literal false (expecting 'a')"
)
}
// stateFa is the state after reading `fa`.
func
stateFa
(
s
*
scanner
,
c
int
)
int
{
if
c
==
'l'
{
s
.
step
=
stateFal
return
scanContinue
}
return
s
.
error
(
c
,
"in literal false (expecting 'l')"
)
}
// stateFal is the state after reading `fal`.
func
stateFal
(
s
*
scanner
,
c
int
)
int
{
if
c
==
's'
{
s
.
step
=
stateFals
return
scanContinue
}
return
s
.
error
(
c
,
"in literal false (expecting 's')"
)
}
// stateFals is the state after reading `fals`.
func
stateFals
(
s
*
scanner
,
c
int
)
int
{
if
c
==
'e'
{
s
.
step
=
stateEndValue
return
scanContinue
}
return
s
.
error
(
c
,
"in literal false (expecting 'e')"
)
}
// stateN is the state after reading `n`.
func
stateN
(
s
*
scanner
,
c
int
)
int
{
if
c
==
'u'
{
s
.
step
=
stateNu
return
scanContinue
}
return
s
.
error
(
c
,
"in literal null (expecting 'u')"
)
}
// stateNu is the state after reading `nu`.
func
stateNu
(
s
*
scanner
,
c
int
)
int
{
if
c
==
'l'
{
s
.
step
=
stateNul
return
scanContinue
}
return
s
.
error
(
c
,
"in literal null (expecting 'l')"
)
}
// stateNul is the state after reading `nul`.
func
stateNul
(
s
*
scanner
,
c
int
)
int
{
if
c
==
'l'
{
s
.
step
=
stateEndValue
return
scanContinue
}
return
s
.
error
(
c
,
"in literal null (expecting 'l')"
)
}
// stateError is the state after reaching a syntax error,
// such as after reading `[1}` or `5.1.2`.
func
stateError
(
s
*
scanner
,
c
int
)
int
{
return
scanError
}
// error records an error and switches to the error state.
func
(
s
*
scanner
)
error
(
c
int
,
context
string
)
int
{
s
.
step
=
stateError
s
.
err
=
&
SyntaxError
{
"invalid character "
+
quoteChar
(
c
)
+
" "
+
context
,
s
.
bytes
}
return
scanError
}
// quoteChar formats c as a quoted character literal
func
quoteChar
(
c
int
)
string
{
// special cases - different from quoted strings
if
c
==
'\'
'
{
return
`'\''`
}
if
c
==
'"'
{
return
`'"'`
}
// use quoted string with different quotation marks
s
:=
strconv
.
Quote
(
string
(
c
))
return
"'"
+
s
[
1
:
len
(
s
)
-
1
]
+
"'"
}
// undo causes the scanner to return scanCode from the next state transition.
// This gives callers a simple 1-byte undo mechanism.
func
(
s
*
scanner
)
undo
(
scanCode
int
)
{
if
s
.
redo
{
panic
(
"json: invalid use of scanner"
)
}
s
.
redoCode
=
scanCode
s
.
redoState
=
s
.
step
s
.
step
=
stateRedo
s
.
redo
=
true
}
// stateRedo helps implement the scanner's 1-byte undo.
func
stateRedo
(
s
*
scanner
,
c
int
)
int
{
s
.
redo
=
false
s
.
step
=
s
.
redoState
return
s
.
redoCode
}
vendor/github.com/CorgiMan/json2/stream.go
0 → 100644
浏览文件 @
ee667a09
// 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
json2
import
(
"bytes"
"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.
//
// The decoder introduces its own buffering and may
// read data from r beyond the JSON values requested.
func
NewDecoder
(
r
io
.
Reader
)
*
Decoder
{
return
&
Decoder
{
r
:
r
}
}
// UseNumber causes the Decoder to unmarshal a number into an interface{} as a
// Number instead of as a float64.
func
(
dec
*
Decoder
)
UseNumber
()
{
dec
.
d
.
useNumber
=
true
}
// 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
}
// Buffered returns a reader of the data remaining in the Decoder's
// buffer. The reader is valid until the next call to Decode.
func
(
dec
*
Decoder
)
Buffered
()
io
.
Reader
{
return
bytes
.
NewReader
(
dec
.
buf
)
}
// 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
||
v
==
scanEndArray
)
&&
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 stream.
//
// 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
}
e
:=
newEncodeState
()
err
:=
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.
e
.
WriteByte
(
'\n'
)
if
_
,
err
=
enc
.
w
.
Write
(
e
.
Bytes
());
err
!=
nil
{
enc
.
err
=
err
}
putEncodeState
(
e
)
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
)
vendor/github.com/CorgiMan/json2/tags.go
0 → 100644
浏览文件 @
ee667a09
// Copyright 2011 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
json2
import
(
"strings"
)
// tagOptions is the string following a comma in a struct field's "json"
// tag, or the empty string. It does not include the leading comma.
type
tagOptions
string
// parseTag splits a struct field's json tag into its name and
// comma-separated options.
func
parseTag
(
tag
string
)
(
string
,
tagOptions
)
{
if
idx
:=
strings
.
Index
(
tag
,
","
);
idx
!=
-
1
{
return
tag
[
:
idx
],
tagOptions
(
tag
[
idx
+
1
:
])
}
return
tag
,
tagOptions
(
""
)
}
// Contains reports whether a comma-separated list of options
// contains a particular substr flag. substr must be surrounded by a
// string boundary or commas.
func
(
o
tagOptions
)
Contains
(
optionName
string
)
bool
{
if
len
(
o
)
==
0
{
return
false
}
s
:=
string
(
o
)
for
s
!=
""
{
var
next
string
i
:=
strings
.
Index
(
s
,
","
)
if
i
>=
0
{
s
,
next
=
s
[
:
i
],
s
[
i
+
1
:
]
}
if
s
==
optionName
{
return
true
}
s
=
next
}
return
false
}
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录