Hein
278 lines
7.0 KiB
Go
278 lines
7.0 KiB
Go
// Copyright (C) 2016 Kohei YOSHIDA. All rights reserved.
|
|
//
|
|
// This program is free software; you can redistribute it and/or
|
|
// modify it under the terms of The BSD 3-Clause License
|
|
// that can be found in the LICENSE file.
|
|
|
|
package uritemplate
|
|
|
|
import (
|
|
"fmt"
|
|
"unicode"
|
|
"unicode/utf8"
|
|
)
|
|
|
|
type parseOp int
|
|
|
|
const (
|
|
parseOpSimple parseOp = iota
|
|
parseOpPlus
|
|
parseOpCrosshatch
|
|
parseOpDot
|
|
parseOpSlash
|
|
parseOpSemicolon
|
|
parseOpQuestion
|
|
parseOpAmpersand
|
|
)
|
|
|
|
var (
|
|
rangeVarchar = &unicode.RangeTable{
|
|
R16: []unicode.Range16{
|
|
{Lo: 0x0030, Hi: 0x0039, Stride: 1}, // '0' - '9'
|
|
{Lo: 0x0041, Hi: 0x005A, Stride: 1}, // 'A' - 'Z'
|
|
{Lo: 0x005F, Hi: 0x005F, Stride: 1}, // '_'
|
|
{Lo: 0x0061, Hi: 0x007A, Stride: 1}, // 'a' - 'z'
|
|
},
|
|
LatinOffset: 4,
|
|
}
|
|
rangeLiterals = &unicode.RangeTable{
|
|
R16: []unicode.Range16{
|
|
{Lo: 0x0021, Hi: 0x0021, Stride: 1}, // '!'
|
|
{Lo: 0x0023, Hi: 0x0024, Stride: 1}, // '#' - '$'
|
|
{Lo: 0x0026, Hi: 0x003B, Stride: 1}, // '&' ''' '(' - ';'. '''/27 used to be excluded but an errata is in the review process https://www.rfc-editor.org/errata/eid6937
|
|
{Lo: 0x003D, Hi: 0x003D, Stride: 1}, // '='
|
|
{Lo: 0x003F, Hi: 0x005B, Stride: 1}, // '?' - '['
|
|
{Lo: 0x005D, Hi: 0x005D, Stride: 1}, // ']'
|
|
{Lo: 0x005F, Hi: 0x005F, Stride: 1}, // '_'
|
|
{Lo: 0x0061, Hi: 0x007A, Stride: 1}, // 'a' - 'z'
|
|
{Lo: 0x007E, Hi: 0x007E, Stride: 1}, // '~'
|
|
{Lo: 0x00A0, Hi: 0xD7FF, Stride: 1}, // ucschar
|
|
{Lo: 0xE000, Hi: 0xF8FF, Stride: 1}, // iprivate
|
|
{Lo: 0xF900, Hi: 0xFDCF, Stride: 1}, // ucschar
|
|
{Lo: 0xFDF0, Hi: 0xFFEF, Stride: 1}, // ucschar
|
|
},
|
|
R32: []unicode.Range32{
|
|
{Lo: 0x00010000, Hi: 0x0001FFFD, Stride: 1}, // ucschar
|
|
{Lo: 0x00020000, Hi: 0x0002FFFD, Stride: 1}, // ucschar
|
|
{Lo: 0x00030000, Hi: 0x0003FFFD, Stride: 1}, // ucschar
|
|
{Lo: 0x00040000, Hi: 0x0004FFFD, Stride: 1}, // ucschar
|
|
{Lo: 0x00050000, Hi: 0x0005FFFD, Stride: 1}, // ucschar
|
|
{Lo: 0x00060000, Hi: 0x0006FFFD, Stride: 1}, // ucschar
|
|
{Lo: 0x00070000, Hi: 0x0007FFFD, Stride: 1}, // ucschar
|
|
{Lo: 0x00080000, Hi: 0x0008FFFD, Stride: 1}, // ucschar
|
|
{Lo: 0x00090000, Hi: 0x0009FFFD, Stride: 1}, // ucschar
|
|
{Lo: 0x000A0000, Hi: 0x000AFFFD, Stride: 1}, // ucschar
|
|
{Lo: 0x000B0000, Hi: 0x000BFFFD, Stride: 1}, // ucschar
|
|
{Lo: 0x000C0000, Hi: 0x000CFFFD, Stride: 1}, // ucschar
|
|
{Lo: 0x000D0000, Hi: 0x000DFFFD, Stride: 1}, // ucschar
|
|
{Lo: 0x000E1000, Hi: 0x000EFFFD, Stride: 1}, // ucschar
|
|
{Lo: 0x000F0000, Hi: 0x000FFFFD, Stride: 1}, // iprivate
|
|
{Lo: 0x00100000, Hi: 0x0010FFFD, Stride: 1}, // iprivate
|
|
},
|
|
LatinOffset: 10,
|
|
}
|
|
)
|
|
|
|
type parser struct {
|
|
r string
|
|
start int
|
|
stop int
|
|
state parseState
|
|
}
|
|
|
|
func (p *parser) errorf(i rune, format string, a ...interface{}) error {
|
|
return fmt.Errorf("%s: %s%s", fmt.Sprintf(format, a...), p.r[0:p.stop], string(i))
|
|
}
|
|
|
|
func (p *parser) rune() (rune, int) {
|
|
r, size := utf8.DecodeRuneInString(p.r[p.stop:])
|
|
if r != utf8.RuneError {
|
|
p.stop += size
|
|
}
|
|
return r, size
|
|
}
|
|
|
|
func (p *parser) unread(r rune) {
|
|
p.stop -= utf8.RuneLen(r)
|
|
}
|
|
|
|
type parseState int
|
|
|
|
const (
|
|
parseStateDefault = parseState(iota)
|
|
parseStateOperator
|
|
parseStateVarList
|
|
parseStateVarName
|
|
parseStatePrefix
|
|
)
|
|
|
|
func (p *parser) setState(state parseState) {
|
|
p.state = state
|
|
p.start = p.stop
|
|
}
|
|
|
|
func (p *parser) parseURITemplate() (*Template, error) {
|
|
tmpl := Template{
|
|
raw: p.r,
|
|
exprs: []template{},
|
|
}
|
|
|
|
var exp *expression
|
|
for {
|
|
r, size := p.rune()
|
|
if r == utf8.RuneError {
|
|
if size == 0 {
|
|
if p.state != parseStateDefault {
|
|
return nil, p.errorf('_', "incomplete expression")
|
|
}
|
|
if p.start < p.stop {
|
|
tmpl.exprs = append(tmpl.exprs, literals(p.r[p.start:p.stop]))
|
|
}
|
|
return &tmpl, nil
|
|
}
|
|
return nil, p.errorf('_', "invalid UTF-8 sequence")
|
|
}
|
|
|
|
switch p.state {
|
|
case parseStateDefault:
|
|
switch r {
|
|
case '{':
|
|
if stop := p.stop - size; stop > p.start {
|
|
tmpl.exprs = append(tmpl.exprs, literals(p.r[p.start:stop]))
|
|
}
|
|
exp = &expression{}
|
|
tmpl.exprs = append(tmpl.exprs, exp)
|
|
p.setState(parseStateOperator)
|
|
case '%':
|
|
p.unread(r)
|
|
if err := p.consumeTriplet(); err != nil {
|
|
return nil, err
|
|
}
|
|
default:
|
|
if !unicode.Is(rangeLiterals, r) {
|
|
p.unread(r)
|
|
return nil, p.errorf('_', "unacceptable character (hint: use %%XX encoding)")
|
|
}
|
|
}
|
|
case parseStateOperator:
|
|
switch r {
|
|
default:
|
|
p.unread(r)
|
|
exp.op = parseOpSimple
|
|
case '+':
|
|
exp.op = parseOpPlus
|
|
case '#':
|
|
exp.op = parseOpCrosshatch
|
|
case '.':
|
|
exp.op = parseOpDot
|
|
case '/':
|
|
exp.op = parseOpSlash
|
|
case ';':
|
|
exp.op = parseOpSemicolon
|
|
case '?':
|
|
exp.op = parseOpQuestion
|
|
case '&':
|
|
exp.op = parseOpAmpersand
|
|
case '=', ',', '!', '@', '|': // op-reserved
|
|
return nil, p.errorf('|', "unimplemented operator (op-reserved)")
|
|
}
|
|
p.setState(parseStateVarName)
|
|
case parseStateVarList:
|
|
switch r {
|
|
case ',':
|
|
p.setState(parseStateVarName)
|
|
case '}':
|
|
exp.init()
|
|
p.setState(parseStateDefault)
|
|
default:
|
|
p.unread(r)
|
|
return nil, p.errorf('_', "unrecognized value modifier")
|
|
}
|
|
case parseStateVarName:
|
|
switch r {
|
|
case ':', '*':
|
|
name := p.r[p.start : p.stop-size]
|
|
if !isValidVarname(name) {
|
|
return nil, p.errorf('|', "unacceptable variable name")
|
|
}
|
|
explode := r == '*'
|
|
exp.vars = append(exp.vars, varspec{
|
|
name: name,
|
|
explode: explode,
|
|
})
|
|
if explode {
|
|
p.setState(parseStateVarList)
|
|
} else {
|
|
p.setState(parseStatePrefix)
|
|
}
|
|
case ',', '}':
|
|
p.unread(r)
|
|
name := p.r[p.start:p.stop]
|
|
if !isValidVarname(name) {
|
|
return nil, p.errorf('|', "unacceptable variable name")
|
|
}
|
|
exp.vars = append(exp.vars, varspec{
|
|
name: name,
|
|
})
|
|
p.setState(parseStateVarList)
|
|
case '%':
|
|
p.unread(r)
|
|
if err := p.consumeTriplet(); err != nil {
|
|
return nil, err
|
|
}
|
|
case '.':
|
|
if dot := p.stop - size; dot == p.start || p.r[dot-1] == '.' {
|
|
return nil, p.errorf('|', "unacceptable variable name")
|
|
}
|
|
default:
|
|
if !unicode.Is(rangeVarchar, r) {
|
|
p.unread(r)
|
|
return nil, p.errorf('_', "unacceptable variable name")
|
|
}
|
|
}
|
|
case parseStatePrefix:
|
|
spec := &(exp.vars[len(exp.vars)-1])
|
|
switch {
|
|
case '0' <= r && r <= '9':
|
|
spec.maxlen *= 10
|
|
spec.maxlen += int(r - '0')
|
|
if spec.maxlen == 0 || spec.maxlen > 9999 {
|
|
return nil, p.errorf('|', "max-length must be (0, 9999]")
|
|
}
|
|
default:
|
|
p.unread(r)
|
|
if spec.maxlen == 0 {
|
|
return nil, p.errorf('_', "max-length must be (0, 9999]")
|
|
}
|
|
p.setState(parseStateVarList)
|
|
}
|
|
default:
|
|
p.unread(r)
|
|
panic(p.errorf('_', "unhandled parseState(%d)", p.state))
|
|
}
|
|
}
|
|
}
|
|
|
|
func isValidVarname(name string) bool {
|
|
if l := len(name); l == 0 || name[0] == '.' || name[l-1] == '.' {
|
|
return false
|
|
}
|
|
for i := 1; i < len(name)-1; i++ {
|
|
switch c := name[i]; c {
|
|
case '.':
|
|
if name[i-1] == '.' {
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func (p *parser) consumeTriplet() error {
|
|
if len(p.r)-p.stop < 3 || p.r[p.stop] != '%' || !ishex(p.r[p.stop+1]) || !ishex(p.r[p.stop+2]) {
|
|
return p.errorf('_', "incomplete pct-encodeed")
|
|
}
|
|
p.stop += 3
|
|
return nil
|
|
}
|