json: initial scanner implementation
Currently lacking correct support for unicode text segmentation into grapheme clusters, so it miscounts "Column" in positions. This will be addressed later.
This commit is contained in:
Martin Atkins
parent
b9183e85e4
commit
b5ce4360cd
8
zcl/json/doc.go
Normal file
8
zcl/json/doc.go
Normal file
@ -0,0 +1,8 @@
|
|||||||
|
// Package json is the JSON parser for ZCL. It parses JSON files and returns
|
||||||
|
// implementations of the core ZCL structural interfaces in terms of the
|
||||||
|
// JSON data inside.
|
||||||
|
//
|
||||||
|
// This is not a generic JSON parser. Instead, it deals with the mapping from
|
||||||
|
// the JSON information model to the ZCL information model, using a number
|
||||||
|
// of hard-coded structural conventions.
|
||||||
|
package json
|
||||||
281
zcl/json/scanner.go
Normal file
281
zcl/json/scanner.go
Normal file
@ -0,0 +1,281 @@
|
|||||||
|
package json
|
||||||
|
|
||||||
|
import (
|
||||||
|
"fmt"
|
||||||
|
|
||||||
|
"github.com/apparentlymart/go-zcl/zcl"
|
||||||
|
)
|
||||||
|
|
||||||
|
//go:generate stringer -type tokenType scanner.go
|
||||||
|
type tokenType rune
|
||||||
|
|
||||||
|
const (
|
||||||
|
tokenBraceO tokenType = '{'
|
||||||
|
tokenBraceC tokenType = '}'
|
||||||
|
tokenBrackO tokenType = '['
|
||||||
|
tokenBrackC tokenType = ']'
|
||||||
|
tokenComma tokenType = ','
|
||||||
|
tokenColon tokenType = ':'
|
||||||
|
tokenKeyword tokenType = 'K'
|
||||||
|
tokenString tokenType = 'S'
|
||||||
|
tokenNumber tokenType = 'N'
|
||||||
|
tokenInvalid tokenType = 0
|
||||||
|
)
|
||||||
|
|
||||||
|
type token struct {
|
||||||
|
Type tokenType
|
||||||
|
Bytes []byte
|
||||||
|
Range zcl.Range
|
||||||
|
}
|
||||||
|
|
||||||
|
// scan returns the primary tokens for the given JSON buffer in sequence.
|
||||||
|
//
|
||||||
|
// The responsibility of this pass is to just mark the slices of the buffer
|
||||||
|
// as being of various types. It is lax in how it interprets the multi-byte
|
||||||
|
// token types keyword, string and number, preferring to capture erroneous
|
||||||
|
// extra bytes that we presume the user intended to be part of the token
|
||||||
|
// so that we can generate more helpful diagnostics in the parser.
|
||||||
|
func scan(buf []byte, start pos) []token {
|
||||||
|
var tokens []token
|
||||||
|
p := start
|
||||||
|
for {
|
||||||
|
if len(buf) == 0 {
|
||||||
|
return tokens
|
||||||
|
}
|
||||||
|
|
||||||
|
buf, p = skipWhitespace(buf, p)
|
||||||
|
|
||||||
|
if len(buf) == 0 {
|
||||||
|
return tokens
|
||||||
|
}
|
||||||
|
|
||||||
|
start = p
|
||||||
|
|
||||||
|
first := buf[0]
|
||||||
|
switch {
|
||||||
|
case first == '{' || first == '}' || first == '[' || first == ']' || first == ',' || first == ':':
|
||||||
|
p.Pos.Column++
|
||||||
|
p.Pos.Byte++
|
||||||
|
tokens = append(tokens, token{
|
||||||
|
Type: tokenType(first),
|
||||||
|
Bytes: buf[0:1],
|
||||||
|
Range: posRange(start, p),
|
||||||
|
})
|
||||||
|
buf = buf[1:]
|
||||||
|
case first == '"':
|
||||||
|
var tokBuf []byte
|
||||||
|
tokBuf, buf, p = scanString(buf, p)
|
||||||
|
tokens = append(tokens, token{
|
||||||
|
Type: tokenString,
|
||||||
|
Bytes: tokBuf,
|
||||||
|
Range: posRange(start, p),
|
||||||
|
})
|
||||||
|
case byteCanStartNumber(first):
|
||||||
|
var tokBuf []byte
|
||||||
|
tokBuf, buf, p = scanNumber(buf, p)
|
||||||
|
tokens = append(tokens, token{
|
||||||
|
Type: tokenNumber,
|
||||||
|
Bytes: tokBuf,
|
||||||
|
Range: posRange(start, p),
|
||||||
|
})
|
||||||
|
case byteCanStartKeyword(first):
|
||||||
|
var tokBuf []byte
|
||||||
|
tokBuf, buf, p = scanKeyword(buf, p)
|
||||||
|
tokens = append(tokens, token{
|
||||||
|
Type: tokenKeyword,
|
||||||
|
Bytes: tokBuf,
|
||||||
|
Range: posRange(start, p),
|
||||||
|
})
|
||||||
|
default:
|
||||||
|
tokens = append(tokens, token{
|
||||||
|
Type: tokenInvalid,
|
||||||
|
Bytes: buf[:1],
|
||||||
|
Range: start.Range(1, 1),
|
||||||
|
})
|
||||||
|
// If we've encountered an invalid then we might as well stop
|
||||||
|
// scanning since the parser won't proceed beyond this point.
|
||||||
|
return tokens
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func byteCanStartNumber(b byte) bool {
|
||||||
|
switch b {
|
||||||
|
// We are slightly more tolerant than JSON requires here since we
|
||||||
|
// expect the parser will make a stricter interpretation of the
|
||||||
|
// number bytes, but we specifically don't allow 'e' or 'E' here
|
||||||
|
// since we want the scanner to treat that as the start of an
|
||||||
|
// invalid keyword instead, to produce more intelligible error messages.
|
||||||
|
case '-', '+', '.', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
|
||||||
|
return true
|
||||||
|
default:
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func scanNumber(buf []byte, start pos) ([]byte, []byte, pos) {
|
||||||
|
// The scanner doesn't check that the sequence of digit-ish bytes is
|
||||||
|
// in a valid order. The parser must do this when decoding a number
|
||||||
|
// token.
|
||||||
|
var i int
|
||||||
|
p := start
|
||||||
|
Byte:
|
||||||
|
for i = 0; i < len(buf); i++ {
|
||||||
|
switch buf[i] {
|
||||||
|
case '-', '+', '.', 'e', 'E', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
|
||||||
|
p.Pos.Byte++
|
||||||
|
p.Pos.Column++
|
||||||
|
default:
|
||||||
|
break Byte
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return buf[:i], buf[i:], p
|
||||||
|
}
|
||||||
|
|
||||||
|
func byteCanStartKeyword(b byte) bool {
|
||||||
|
switch {
|
||||||
|
// We allow any sequence of alphabetical characters here, even though
|
||||||
|
// JSON is more constrained, so that we can collect what we presume
|
||||||
|
// the user intended to be a single keyword and then check its validity
|
||||||
|
// in the parser, where we can generate better diagnostics.
|
||||||
|
// So e.g. we want to be able to say:
|
||||||
|
// unrecognized keyword "True". Did you mean "true"?
|
||||||
|
case b >= 'a' || b <= 'z' || b >= 'A' || b <= 'Z':
|
||||||
|
return true
|
||||||
|
default:
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func scanKeyword(buf []byte, start pos) ([]byte, []byte, pos) {
|
||||||
|
var i int
|
||||||
|
p := start
|
||||||
|
Byte:
|
||||||
|
for i = 0; i < len(buf); i++ {
|
||||||
|
b := buf[i]
|
||||||
|
switch {
|
||||||
|
case b >= 'a' || b <= 'z' || b >= 'A' || b <= 'Z' || b == '_':
|
||||||
|
p.Pos.Byte++
|
||||||
|
p.Pos.Column++
|
||||||
|
default:
|
||||||
|
break Byte
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return buf[:i], buf[i:], p
|
||||||
|
}
|
||||||
|
|
||||||
|
func scanString(buf []byte, start pos) ([]byte, []byte, pos) {
|
||||||
|
// The scanner doesn't validate correct use of escapes, etc. It pays
|
||||||
|
// attention to escapes only for the purpose of identifying the closing
|
||||||
|
// quote character. It's the parser's responsibility to do proper
|
||||||
|
// validation.
|
||||||
|
//
|
||||||
|
// The scanner also doesn't specifically detect unterminated string
|
||||||
|
// literals, though they can be identified in the parser by checking if
|
||||||
|
// the final byte in a string token is the double-quote character.
|
||||||
|
|
||||||
|
// Skip the opening quote symbol
|
||||||
|
i := 1
|
||||||
|
p := start
|
||||||
|
p.Pos.Byte++
|
||||||
|
p.Pos.Column++
|
||||||
|
escaping := false
|
||||||
|
Byte:
|
||||||
|
for i < len(buf) {
|
||||||
|
b := buf[i]
|
||||||
|
|
||||||
|
switch {
|
||||||
|
case b == '\\':
|
||||||
|
escaping = !escaping
|
||||||
|
p.Pos.Byte++
|
||||||
|
p.Pos.Column++
|
||||||
|
i++
|
||||||
|
case b == '"':
|
||||||
|
p.Pos.Byte++
|
||||||
|
p.Pos.Column++
|
||||||
|
i++
|
||||||
|
if !escaping {
|
||||||
|
break Byte
|
||||||
|
}
|
||||||
|
escaping = false
|
||||||
|
case b < 32:
|
||||||
|
break Byte
|
||||||
|
default:
|
||||||
|
// TODO: Use Unicode Text Segmentation spec to advance
|
||||||
|
// Column only once per grapheme cluster, rather than once per
|
||||||
|
// byte.
|
||||||
|
// Consume one or more UTF-8 codepoints that together form
|
||||||
|
// a single grapheme cluster.
|
||||||
|
|
||||||
|
p.Pos.Byte++
|
||||||
|
p.Pos.Column++
|
||||||
|
i++
|
||||||
|
|
||||||
|
escaping = false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return buf[:i], buf[i:], p
|
||||||
|
}
|
||||||
|
|
||||||
|
func skipWhitespace(buf []byte, start pos) ([]byte, pos) {
|
||||||
|
var i int
|
||||||
|
p := start
|
||||||
|
Byte:
|
||||||
|
for i = 0; i < len(buf); i++ {
|
||||||
|
switch buf[i] {
|
||||||
|
case ' ':
|
||||||
|
p.Pos.Byte++
|
||||||
|
p.Pos.Column++
|
||||||
|
case '\n':
|
||||||
|
p.Pos.Byte++
|
||||||
|
p.Pos.Column = 1
|
||||||
|
p.Pos.Line++
|
||||||
|
case '\r':
|
||||||
|
// For the purpose of line/column counting we consider a
|
||||||
|
// carriage return to take up no space, assuming that it will
|
||||||
|
// be paired up with a newline (on Windows, for example) that
|
||||||
|
// will account for both of them.
|
||||||
|
p.Pos.Byte++
|
||||||
|
case '\t':
|
||||||
|
// We arbitrarily count a tab as if it were two spaces, because
|
||||||
|
// we need to choose _some_ number here. This means any system
|
||||||
|
// that renders code on-screen with markers must itself treat
|
||||||
|
// tabs as a pair of spaces for rendering purposes, or instead
|
||||||
|
// use the byte offset and back into its own column position.
|
||||||
|
p.Pos.Byte++
|
||||||
|
p.Pos.Column += 2
|
||||||
|
default:
|
||||||
|
break Byte
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return buf[i:], p
|
||||||
|
}
|
||||||
|
|
||||||
|
type pos struct {
|
||||||
|
Filename string
|
||||||
|
Pos zcl.Pos
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *pos) Range(byteLen, charLen int) zcl.Range {
|
||||||
|
start := p.Pos
|
||||||
|
end := p.Pos
|
||||||
|
end.Byte += byteLen
|
||||||
|
end.Column += charLen
|
||||||
|
return zcl.Range{
|
||||||
|
Filename: p.Filename,
|
||||||
|
Start: start,
|
||||||
|
End: end,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func posRange(start, end pos) zcl.Range {
|
||||||
|
return zcl.Range{
|
||||||
|
Filename: start.Filename,
|
||||||
|
Start: start.Pos,
|
||||||
|
End: end.Pos,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (t token) GoString() string {
|
||||||
|
return fmt.Sprintf("json.token{json.%s, []byte(%q), %#v}", t.Type, t.Bytes, t.Range)
|
||||||
|
}
|
||||||
462
zcl/json/scanner_test.go
Normal file
462
zcl/json/scanner_test.go
Normal file
@ -0,0 +1,462 @@
|
|||||||
|
package json
|
||||||
|
|
||||||
|
import (
|
||||||
|
"bytes"
|
||||||
|
"fmt"
|
||||||
|
"reflect"
|
||||||
|
"testing"
|
||||||
|
|
||||||
|
"github.com/apparentlymart/go-zcl/zcl"
|
||||||
|
)
|
||||||
|
|
||||||
|
func TestScan(t *testing.T) {
|
||||||
|
tests := []struct {
|
||||||
|
Input string
|
||||||
|
Want []token
|
||||||
|
}{
|
||||||
|
{
|
||||||
|
``,
|
||||||
|
nil,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
`{}`,
|
||||||
|
[]token{
|
||||||
|
{
|
||||||
|
Type: tokenBraceO,
|
||||||
|
Bytes: []byte(`{`),
|
||||||
|
Range: zcl.Range{
|
||||||
|
Start: zcl.Pos{
|
||||||
|
Byte: 0,
|
||||||
|
Line: 1,
|
||||||
|
Column: 1,
|
||||||
|
},
|
||||||
|
End: zcl.Pos{
|
||||||
|
Byte: 1,
|
||||||
|
Line: 1,
|
||||||
|
Column: 2,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
{
|
||||||
|
Type: tokenBraceC,
|
||||||
|
Bytes: []byte(`}`),
|
||||||
|
Range: zcl.Range{
|
||||||
|
Start: zcl.Pos{
|
||||||
|
Byte: 1,
|
||||||
|
Line: 1,
|
||||||
|
Column: 2,
|
||||||
|
},
|
||||||
|
End: zcl.Pos{
|
||||||
|
Byte: 2,
|
||||||
|
Line: 1,
|
||||||
|
Column: 3,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
{
|
||||||
|
`][`,
|
||||||
|
[]token{
|
||||||
|
{
|
||||||
|
Type: tokenBrackC,
|
||||||
|
Bytes: []byte(`]`),
|
||||||
|
Range: zcl.Range{
|
||||||
|
Start: zcl.Pos{
|
||||||
|
Byte: 0,
|
||||||
|
Line: 1,
|
||||||
|
Column: 1,
|
||||||
|
},
|
||||||
|
End: zcl.Pos{
|
||||||
|
Byte: 1,
|
||||||
|
Line: 1,
|
||||||
|
Column: 2,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
{
|
||||||
|
Type: tokenBrackO,
|
||||||
|
Bytes: []byte(`[`),
|
||||||
|
Range: zcl.Range{
|
||||||
|
Start: zcl.Pos{
|
||||||
|
Byte: 1,
|
||||||
|
Line: 1,
|
||||||
|
Column: 2,
|
||||||
|
},
|
||||||
|
End: zcl.Pos{
|
||||||
|
Byte: 2,
|
||||||
|
Line: 1,
|
||||||
|
Column: 3,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
{
|
||||||
|
`:,`,
|
||||||
|
[]token{
|
||||||
|
{
|
||||||
|
Type: tokenColon,
|
||||||
|
Bytes: []byte(`:`),
|
||||||
|
Range: zcl.Range{
|
||||||
|
Start: zcl.Pos{
|
||||||
|
Byte: 0,
|
||||||
|
Line: 1,
|
||||||
|
Column: 1,
|
||||||
|
},
|
||||||
|
End: zcl.Pos{
|
||||||
|
Byte: 1,
|
||||||
|
Line: 1,
|
||||||
|
Column: 2,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
{
|
||||||
|
Type: tokenComma,
|
||||||
|
Bytes: []byte(`,`),
|
||||||
|
Range: zcl.Range{
|
||||||
|
Start: zcl.Pos{
|
||||||
|
Byte: 1,
|
||||||
|
Line: 1,
|
||||||
|
Column: 2,
|
||||||
|
},
|
||||||
|
End: zcl.Pos{
|
||||||
|
Byte: 2,
|
||||||
|
Line: 1,
|
||||||
|
Column: 3,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
{
|
||||||
|
`1`,
|
||||||
|
[]token{
|
||||||
|
{
|
||||||
|
Type: tokenNumber,
|
||||||
|
Bytes: []byte(`1`),
|
||||||
|
Range: zcl.Range{
|
||||||
|
Start: zcl.Pos{
|
||||||
|
Byte: 0,
|
||||||
|
Line: 1,
|
||||||
|
Column: 1,
|
||||||
|
},
|
||||||
|
End: zcl.Pos{
|
||||||
|
Byte: 1,
|
||||||
|
Line: 1,
|
||||||
|
Column: 2,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
{
|
||||||
|
` 1`,
|
||||||
|
[]token{
|
||||||
|
{
|
||||||
|
Type: tokenNumber,
|
||||||
|
Bytes: []byte(`1`),
|
||||||
|
Range: zcl.Range{
|
||||||
|
Start: zcl.Pos{
|
||||||
|
Byte: 2,
|
||||||
|
Line: 1,
|
||||||
|
Column: 3,
|
||||||
|
},
|
||||||
|
End: zcl.Pos{
|
||||||
|
Byte: 3,
|
||||||
|
Line: 1,
|
||||||
|
Column: 4,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
{
|
||||||
|
` 12`,
|
||||||
|
[]token{
|
||||||
|
{
|
||||||
|
Type: tokenNumber,
|
||||||
|
Bytes: []byte(`12`),
|
||||||
|
Range: zcl.Range{
|
||||||
|
Start: zcl.Pos{
|
||||||
|
Byte: 2,
|
||||||
|
Line: 1,
|
||||||
|
Column: 3,
|
||||||
|
},
|
||||||
|
End: zcl.Pos{
|
||||||
|
Byte: 4,
|
||||||
|
Line: 1,
|
||||||
|
Column: 5,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
{
|
||||||
|
`1 2`,
|
||||||
|
[]token{
|
||||||
|
{
|
||||||
|
Type: tokenNumber,
|
||||||
|
Bytes: []byte(`1`),
|
||||||
|
Range: zcl.Range{
|
||||||
|
Start: zcl.Pos{
|
||||||
|
Byte: 0,
|
||||||
|
Line: 1,
|
||||||
|
Column: 1,
|
||||||
|
},
|
||||||
|
End: zcl.Pos{
|
||||||
|
Byte: 1,
|
||||||
|
Line: 1,
|
||||||
|
Column: 2,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
{
|
||||||
|
Type: tokenNumber,
|
||||||
|
Bytes: []byte(`2`),
|
||||||
|
Range: zcl.Range{
|
||||||
|
Start: zcl.Pos{
|
||||||
|
Byte: 2,
|
||||||
|
Line: 1,
|
||||||
|
Column: 3,
|
||||||
|
},
|
||||||
|
End: zcl.Pos{
|
||||||
|
Byte: 3,
|
||||||
|
Line: 1,
|
||||||
|
Column: 4,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"\n1\n 2",
|
||||||
|
[]token{
|
||||||
|
{
|
||||||
|
Type: tokenNumber,
|
||||||
|
Bytes: []byte(`1`),
|
||||||
|
Range: zcl.Range{
|
||||||
|
Start: zcl.Pos{
|
||||||
|
Byte: 1,
|
||||||
|
Line: 2,
|
||||||
|
Column: 1,
|
||||||
|
},
|
||||||
|
End: zcl.Pos{
|
||||||
|
Byte: 2,
|
||||||
|
Line: 2,
|
||||||
|
Column: 2,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
{
|
||||||
|
Type: tokenNumber,
|
||||||
|
Bytes: []byte(`2`),
|
||||||
|
Range: zcl.Range{
|
||||||
|
Start: zcl.Pos{
|
||||||
|
Byte: 4,
|
||||||
|
Line: 3,
|
||||||
|
Column: 2,
|
||||||
|
},
|
||||||
|
End: zcl.Pos{
|
||||||
|
Byte: 5,
|
||||||
|
Line: 3,
|
||||||
|
Column: 3,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
{
|
||||||
|
`-1 2.5`,
|
||||||
|
[]token{
|
||||||
|
{
|
||||||
|
Type: tokenNumber,
|
||||||
|
Bytes: []byte(`-1`),
|
||||||
|
Range: zcl.Range{
|
||||||
|
Start: zcl.Pos{
|
||||||
|
Byte: 0,
|
||||||
|
Line: 1,
|
||||||
|
Column: 1,
|
||||||
|
},
|
||||||
|
End: zcl.Pos{
|
||||||
|
Byte: 2,
|
||||||
|
Line: 1,
|
||||||
|
Column: 3,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
{
|
||||||
|
Type: tokenNumber,
|
||||||
|
Bytes: []byte(`2.5`),
|
||||||
|
Range: zcl.Range{
|
||||||
|
Start: zcl.Pos{
|
||||||
|
Byte: 3,
|
||||||
|
Line: 1,
|
||||||
|
Column: 4,
|
||||||
|
},
|
||||||
|
End: zcl.Pos{
|
||||||
|
Byte: 6,
|
||||||
|
Line: 1,
|
||||||
|
Column: 7,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
{
|
||||||
|
`true`,
|
||||||
|
[]token{
|
||||||
|
{
|
||||||
|
Type: tokenKeyword,
|
||||||
|
Bytes: []byte(`true`),
|
||||||
|
Range: zcl.Range{
|
||||||
|
Start: zcl.Pos{
|
||||||
|
Byte: 0,
|
||||||
|
Line: 1,
|
||||||
|
Column: 1,
|
||||||
|
},
|
||||||
|
End: zcl.Pos{
|
||||||
|
Byte: 4,
|
||||||
|
Line: 1,
|
||||||
|
Column: 5,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
{
|
||||||
|
`""`,
|
||||||
|
[]token{
|
||||||
|
{
|
||||||
|
Type: tokenString,
|
||||||
|
Bytes: []byte(`""`),
|
||||||
|
Range: zcl.Range{
|
||||||
|
Start: zcl.Pos{
|
||||||
|
Byte: 0,
|
||||||
|
Line: 1,
|
||||||
|
Column: 1,
|
||||||
|
},
|
||||||
|
End: zcl.Pos{
|
||||||
|
Byte: 2,
|
||||||
|
Line: 1,
|
||||||
|
Column: 3,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
{
|
||||||
|
`"hello"`,
|
||||||
|
[]token{
|
||||||
|
{
|
||||||
|
Type: tokenString,
|
||||||
|
Bytes: []byte(`"hello"`),
|
||||||
|
Range: zcl.Range{
|
||||||
|
Start: zcl.Pos{
|
||||||
|
Byte: 0,
|
||||||
|
Line: 1,
|
||||||
|
Column: 1,
|
||||||
|
},
|
||||||
|
End: zcl.Pos{
|
||||||
|
Byte: 7,
|
||||||
|
Line: 1,
|
||||||
|
Column: 8,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
{
|
||||||
|
`"he\"llo"`,
|
||||||
|
[]token{
|
||||||
|
{
|
||||||
|
Type: tokenString,
|
||||||
|
Bytes: []byte(`"he\"llo"`),
|
||||||
|
Range: zcl.Range{
|
||||||
|
Start: zcl.Pos{
|
||||||
|
Byte: 0,
|
||||||
|
Line: 1,
|
||||||
|
Column: 1,
|
||||||
|
},
|
||||||
|
End: zcl.Pos{
|
||||||
|
Byte: 9,
|
||||||
|
Line: 1,
|
||||||
|
Column: 10,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
{
|
||||||
|
`"hello\\" 1`,
|
||||||
|
[]token{
|
||||||
|
{
|
||||||
|
Type: tokenString,
|
||||||
|
Bytes: []byte(`"hello\\"`),
|
||||||
|
Range: zcl.Range{
|
||||||
|
Start: zcl.Pos{
|
||||||
|
Byte: 0,
|
||||||
|
Line: 1,
|
||||||
|
Column: 1,
|
||||||
|
},
|
||||||
|
End: zcl.Pos{
|
||||||
|
Byte: 9,
|
||||||
|
Line: 1,
|
||||||
|
Column: 10,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
{
|
||||||
|
Type: tokenNumber,
|
||||||
|
Bytes: []byte(`1`),
|
||||||
|
Range: zcl.Range{
|
||||||
|
Start: zcl.Pos{
|
||||||
|
Byte: 10,
|
||||||
|
Line: 1,
|
||||||
|
Column: 11,
|
||||||
|
},
|
||||||
|
End: zcl.Pos{
|
||||||
|
Byte: 11,
|
||||||
|
Line: 1,
|
||||||
|
Column: 12,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, test := range tests {
|
||||||
|
t.Run(test.Input, func(t *testing.T) {
|
||||||
|
buf := []byte(test.Input)
|
||||||
|
start := pos{
|
||||||
|
Filename: "",
|
||||||
|
Pos: zcl.Pos{
|
||||||
|
Byte: 0,
|
||||||
|
Line: 1,
|
||||||
|
Column: 1,
|
||||||
|
},
|
||||||
|
}
|
||||||
|
got := scan(buf, start)
|
||||||
|
|
||||||
|
if !reflect.DeepEqual(got, test.Want) {
|
||||||
|
errMsg := &bytes.Buffer{}
|
||||||
|
errMsg.WriteString("wrong result\ngot:\n")
|
||||||
|
if len(got) == 0 {
|
||||||
|
errMsg.WriteString(" (empty slice)\n")
|
||||||
|
}
|
||||||
|
for _, tok := range got {
|
||||||
|
fmt.Fprintf(errMsg, " - %#v\n", tok)
|
||||||
|
}
|
||||||
|
errMsg.WriteString("want:\n")
|
||||||
|
if len(test.Want) == 0 {
|
||||||
|
errMsg.WriteString(" (empty slice)\n")
|
||||||
|
}
|
||||||
|
for _, tok := range test.Want {
|
||||||
|
fmt.Fprintf(errMsg, " - %#v\n", tok)
|
||||||
|
}
|
||||||
|
t.Error(errMsg.String())
|
||||||
|
}
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
58
zcl/json/tokentype_string.go
Normal file
58
zcl/json/tokentype_string.go
Normal file
@ -0,0 +1,58 @@
|
|||||||
|
// Code generated by "stringer -type tokenType scanner.go"; DO NOT EDIT.
|
||||||
|
|
||||||
|
package json
|
||||||
|
|
||||||
|
import "fmt"
|
||||||
|
|
||||||
|
const (
|
||||||
|
_tokenType_name_0 = "tokenInvalid"
|
||||||
|
_tokenType_name_1 = "tokenComma"
|
||||||
|
_tokenType_name_2 = "tokenColon"
|
||||||
|
_tokenType_name_3 = "tokenKeyword"
|
||||||
|
_tokenType_name_4 = "tokenNumber"
|
||||||
|
_tokenType_name_5 = "tokenString"
|
||||||
|
_tokenType_name_6 = "tokenBrackO"
|
||||||
|
_tokenType_name_7 = "tokenBrackC"
|
||||||
|
_tokenType_name_8 = "tokenBraceO"
|
||||||
|
_tokenType_name_9 = "tokenBraceC"
|
||||||
|
)
|
||||||
|
|
||||||
|
var (
|
||||||
|
_tokenType_index_0 = [...]uint8{0, 12}
|
||||||
|
_tokenType_index_1 = [...]uint8{0, 10}
|
||||||
|
_tokenType_index_2 = [...]uint8{0, 10}
|
||||||
|
_tokenType_index_3 = [...]uint8{0, 12}
|
||||||
|
_tokenType_index_4 = [...]uint8{0, 11}
|
||||||
|
_tokenType_index_5 = [...]uint8{0, 11}
|
||||||
|
_tokenType_index_6 = [...]uint8{0, 11}
|
||||||
|
_tokenType_index_7 = [...]uint8{0, 11}
|
||||||
|
_tokenType_index_8 = [...]uint8{0, 11}
|
||||||
|
_tokenType_index_9 = [...]uint8{0, 11}
|
||||||
|
)
|
||||||
|
|
||||||
|
func (i tokenType) String() string {
|
||||||
|
switch {
|
||||||
|
case i == 0:
|
||||||
|
return _tokenType_name_0
|
||||||
|
case i == 44:
|
||||||
|
return _tokenType_name_1
|
||||||
|
case i == 58:
|
||||||
|
return _tokenType_name_2
|
||||||
|
case i == 75:
|
||||||
|
return _tokenType_name_3
|
||||||
|
case i == 78:
|
||||||
|
return _tokenType_name_4
|
||||||
|
case i == 83:
|
||||||
|
return _tokenType_name_5
|
||||||
|
case i == 91:
|
||||||
|
return _tokenType_name_6
|
||||||
|
case i == 93:
|
||||||
|
return _tokenType_name_7
|
||||||
|
case i == 123:
|
||||||
|
return _tokenType_name_8
|
||||||
|
case i == 125:
|
||||||
|
return _tokenType_name_9
|
||||||
|
default:
|
||||||
|
return fmt.Sprintf("tokenType(%d)", i)
|
||||||
|
}
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue
Block a user