packer-cn/vendor/gopkg.in/xmlpath.v2/path.go

791 lines
16 KiB
Go

package xmlpath
import (
"fmt"
"strconv"
"unicode/utf8"
)
// Path is a compiled path that can be applied to a context
// node to obtain a matching node set.
// A single Path can be applied concurrently to any number
// of context nodes.
type Path struct {
path string
steps []pathStep
}
// Iter returns an iterator that goes over the list of nodes
// that p matches on the given context.
func (p *Path) Iter(context *Node) *Iter {
iter := Iter{
make([]pathStepState, len(p.steps)),
make([]bool, len(context.nodes)),
}
for i := range p.steps {
iter.state[i].step = &p.steps[i]
}
iter.state[0].init(context)
return &iter
}
// Exists returns whether any nodes match p on the given context.
func (p *Path) Exists(context *Node) bool {
return p.Iter(context).Next()
}
// String returns the string value of the first node matched
// by p on the given context.
//
// See the documentation of Node.String.
func (p *Path) String(context *Node) (s string, ok bool) {
iter := p.Iter(context)
if iter.Next() {
return iter.Node().String(), true
}
return "", false
}
// Bytes returns as a byte slice the string value of the first
// node matched by p on the given context.
//
// See the documentation of Node.String.
func (p *Path) Bytes(node *Node) (b []byte, ok bool) {
iter := p.Iter(node)
if iter.Next() {
return iter.Node().Bytes(), true
}
return nil, false
}
// Iter iterates over node sets.
type Iter struct {
state []pathStepState
seen []bool
}
// Node returns the current node.
// Must only be called after Iter.Next returns true.
func (iter *Iter) Node() *Node {
state := iter.state[len(iter.state)-1]
if state.pos == 0 {
panic("Iter.Node called before Iter.Next")
}
if state.node == nil {
panic("Iter.Node called after Iter.Next false")
}
return state.node
}
// Next iterates to the next node in the set, if any, and
// returns whether there is a node available.
func (iter *Iter) Next() bool {
tip := len(iter.state) - 1
outer:
for {
for !iter.state[tip].next() {
tip--
if tip == -1 {
return false
}
}
for tip < len(iter.state)-1 {
tip++
iter.state[tip].init(iter.state[tip-1].node)
if !iter.state[tip].next() {
tip--
continue outer
}
}
if iter.seen[iter.state[tip].node.pos] {
continue
}
iter.seen[iter.state[tip].node.pos] = true
return true
}
panic("unreachable")
}
type pathStepState struct {
step *pathStep
node *Node
pos int
idx int
aux int
}
func (s *pathStepState) init(node *Node) {
s.node = node
s.pos = 0
s.idx = 0
s.aux = 0
}
func (s *pathStepState) next() bool {
for s._next() {
s.pos++
if s.step.pred == nil || s.test(s.step.pred) {
return true
}
}
return false
}
func (s *pathStepState) test(pred predicate) bool {
switch pred := pred.(type) {
case positionPredicate:
if pred.pos == s.pos {
return true
}
case existsPredicate:
if pred.path.Exists(s.node) {
return true
}
case equalsPredicate:
iter := pred.path.Iter(s.node)
for iter.Next() {
if iter.Node().equals(pred.value) {
return true
}
}
case containsPredicate:
iter := pred.path.Iter(s.node)
for iter.Next() {
if iter.Node().contains(pred.value) {
return true
}
}
case notPredicate:
iter := pred.path.Iter(s.node)
if !iter.Next() {
return true
}
case andPredicate:
for _, sub := range pred.sub {
if !s.test(sub) {
return false
}
}
return true
case orPredicate:
for _, sub := range pred.sub {
if s.test(sub) {
return true
}
}
default:
panic(fmt.Sprintf("internal error: unknown predicate type: %#v", s.step.pred))
}
return false
}
func (s *pathStepState) _next() bool {
if s.node == nil {
return false
}
if s.step.root && s.idx == 0 {
for s.node.up != nil {
s.node = s.node.up
}
}
switch s.step.axis {
case "self":
if s.idx == 0 && s.step.match(s.node) {
s.idx++
return true
}
case "parent":
if s.idx == 0 && s.node.up != nil && s.step.match(s.node.up) {
s.idx++
s.node = s.node.up
return true
}
case "ancestor", "ancestor-or-self":
if s.idx == 0 && s.step.axis == "ancestor-or-self" {
s.idx++
if s.step.match(s.node) {
return true
}
}
for s.node.up != nil {
s.node = s.node.up
s.idx++
if s.step.match(s.node) {
return true
}
}
case "child":
var down []*Node
if s.idx == 0 {
down = s.node.down
} else {
down = s.node.up.down
}
for s.idx < len(down) {
node := down[s.idx]
s.idx++
if s.step.match(node) {
s.node = node
return true
}
}
case "descendant", "descendant-or-self":
if s.idx == 0 {
s.idx = s.node.pos
s.aux = s.node.end
if s.step.axis == "descendant" {
s.idx++
}
}
for s.idx < s.aux {
node := &s.node.nodes[s.idx]
s.idx++
if node.kind == attrNode {
continue
}
if s.step.match(node) {
s.node = node
return true
}
}
case "following":
if s.idx == 0 {
s.idx = s.node.end
}
for s.idx < len(s.node.nodes) {
node := &s.node.nodes[s.idx]
s.idx++
if node.kind == attrNode {
continue
}
if s.step.match(node) {
s.node = node
return true
}
}
case "following-sibling":
var down []*Node
if s.node.up != nil {
down = s.node.up.down
if s.idx == 0 {
for s.idx < len(down) {
node := down[s.idx]
s.idx++
if node == s.node {
break
}
}
}
}
for s.idx < len(down) {
node := down[s.idx]
s.idx++
if s.step.match(node) {
s.node = node
return true
}
}
case "preceding":
if s.idx == 0 {
s.aux = s.node.pos // Detect ancestors.
s.idx = s.node.pos - 1
}
for s.idx >= 0 {
node := &s.node.nodes[s.idx]
s.idx--
if node.kind == attrNode {
continue
}
if node == s.node.nodes[s.aux].up {
s.aux = s.node.nodes[s.aux].up.pos
continue
}
if s.step.match(node) {
s.node = node
return true
}
}
case "preceding-sibling":
var down []*Node
if s.node.up != nil {
down = s.node.up.down
if s.aux == 0 {
s.aux = 1
for s.idx < len(down) {
node := down[s.idx]
s.idx++
if node == s.node {
s.idx--
break
}
}
}
}
for s.idx >= 0 {
node := down[s.idx]
s.idx--
if s.step.match(node) {
s.node = node
return true
}
}
case "attribute":
if s.idx == 0 {
s.idx = s.node.pos + 1
s.aux = s.node.end
}
for s.idx < s.aux {
node := &s.node.nodes[s.idx]
s.idx++
if node.kind != attrNode {
break
}
if s.step.match(node) {
s.node = node
return true
}
}
}
s.node = nil
return false
}
type positionPredicate struct {
pos int
}
type existsPredicate struct {
path *Path
}
type equalsPredicate struct {
path *Path
value string
}
type containsPredicate struct {
path *Path
value string
}
type notPredicate struct {
path *Path
}
type andPredicate struct {
sub []predicate
}
type orPredicate struct {
sub []predicate
}
// predicate is a marker interface for predicate types.
type predicate interface {
predicate()
}
func (positionPredicate) predicate() {}
func (existsPredicate) predicate() {}
func (equalsPredicate) predicate() {}
func (containsPredicate) predicate() {}
func (notPredicate) predicate() {}
func (andPredicate) predicate() {}
func (orPredicate) predicate() {}
type pathStep struct {
root bool
axis string
name string
kind nodeKind
pred predicate
}
func (step *pathStep) match(node *Node) bool {
return node.kind != endNode &&
(step.kind == anyNode || step.kind == node.kind) &&
(step.name == "*" || node.name.Local == step.name)
}
// MustCompile returns the compiled path, and panics if
// there are any errors.
func MustCompile(path string) *Path {
e, err := Compile(path)
if err != nil {
panic(err)
}
return e
}
// Compile returns the compiled path.
func Compile(path string) (*Path, error) {
c := pathCompiler{path, 0}
if path == "" {
return nil, c.errorf("empty path")
}
p, err := c.parsePath()
if err != nil {
return nil, err
}
return p, nil
}
type pathCompiler struct {
path string
i int
}
func (c *pathCompiler) errorf(format string, args ...interface{}) error {
return fmt.Errorf("compiling xml path %q:%d: %s", c.path, c.i, fmt.Sprintf(format, args...))
}
func (c *pathCompiler) parsePath() (path *Path, err error) {
var steps []pathStep
var start = c.i
for {
step := pathStep{axis: "child"}
c.skipSpaces()
if c.i == 0 && c.skipByte('/') {
c.skipSpaces()
step.root = true
if len(c.path) == 1 {
step.name = "*"
}
}
if c.peekByte('/') {
step.axis = "descendant-or-self"
step.name = "*"
} else if c.skipByte('@') {
mark := c.i
if !c.skipName() {
return nil, c.errorf("missing name after @")
}
step.axis = "attribute"
step.name = c.path[mark:c.i]
step.kind = attrNode
} else {
mark := c.i
if c.skipName() {
step.name = c.path[mark:c.i]
c.skipSpaces()
}
if step.name == "" {
return nil, c.errorf("missing name")
} else if step.name == "*" {
step.kind = startNode
} else if step.name == "." {
step.axis = "self"
step.name = "*"
} else if step.name == ".." {
step.axis = "parent"
step.name = "*"
} else {
if c.skipByte(':') {
if !c.skipByte(':') {
return nil, c.errorf("missing ':'")
}
c.skipSpaces()
switch step.name {
case "attribute":
step.kind = attrNode
case "self", "child", "parent":
case "descendant", "descendant-or-self":
case "ancestor", "ancestor-or-self":
case "following", "following-sibling":
case "preceding", "preceding-sibling":
default:
return nil, c.errorf("unsupported axis: %q", step.name)
}
step.axis = step.name
mark = c.i
if !c.skipName() {
return nil, c.errorf("missing name")
}
step.name = c.path[mark:c.i]
c.skipSpaces()
}
if c.skipByte('(') {
c.skipSpaces()
conflict := step.kind != anyNode
switch step.name {
case "node":
// must be anyNode
case "text":
step.kind = textNode
case "comment":
step.kind = commentNode
case "processing-instruction":
step.kind = procInstNode
default:
return nil, c.errorf("unsupported expression: %s()", step.name)
}
if conflict {
return nil, c.errorf("%s() cannot succeed on axis %q", step.name, step.axis)
}
name := step.name
literal, err := c.parseLiteral()
if err == errNoLiteral {
step.name = "*"
} else if err != nil {
return nil, c.errorf("%v", err)
} else if step.kind == procInstNode {
c.skipSpaces()
step.name = literal
} else {
return nil, c.errorf("%s() has no arguments", name)
}
if !c.skipByte(')') {
return nil, c.errorf("%s() missing ')'", name)
}
c.skipSpaces()
} else if step.name == "*" && step.kind == anyNode {
step.kind = startNode
}
}
}
if c.skipByte('[') {
c.skipSpaces()
type state struct {
sub []predicate
and bool
}
var stack []state
var sub []predicate
var and bool
NextPred:
if c.skipByte('(') {
stack = append(stack, state{sub, and})
sub = nil
and = false
}
var next predicate
if pos, ok := c.parseInt(); ok {
if pos == 0 {
return nil, c.errorf("positions start at 1")
}
next = positionPredicate{pos}
} else if c.skipString("contains(") {
path, err := c.parsePath()
if err != nil {
return nil, err
}
c.skipSpaces()
if !c.skipByte(',') {
return nil, c.errorf("contains() expected ',' followed by a literal string")
}
c.skipSpaces()
value, err := c.parseLiteral()
if err != nil {
return nil, err
}
c.skipSpaces()
if !c.skipByte(')') {
return nil, c.errorf("contains() missing ')'")
}
next = containsPredicate{path, value}
} else if c.skipString("not(") {
// TODO Generalize to handle any predicate expression.
path, err := c.parsePath()
if err != nil {
return nil, err
}
c.skipSpaces()
if !c.skipByte(')') {
return nil, c.errorf("not() missing ')'")
}
next = notPredicate{path}
} else {
path, err := c.parsePath()
if err != nil {
return nil, err
}
if path.path[0] == '-' {
if _, err = strconv.Atoi(path.path); err == nil {
return nil, c.errorf("positions must be positive")
}
}
c.skipSpaces()
if c.skipByte('=') {
c.skipSpaces()
value, err := c.parseLiteral()
if err != nil {
return nil, c.errorf("%v", err)
}
next = equalsPredicate{path, value}
} else {
next = existsPredicate{path}
}
}
HandleNext:
if and {
p := sub[len(sub)-1].(andPredicate)
p.sub = append(p.sub, next)
sub[len(sub)-1] = p
} else {
sub = append(sub, next)
}
if c.skipSpaces() {
mark := c.i
if c.skipString("and") && c.skipSpaces() {
if !and {
and = true
sub[len(sub)-1] = andPredicate{[]predicate{sub[len(sub)-1]}}
}
goto NextPred
} else if c.skipString("or") && c.skipSpaces() {
and = false
goto NextPred
} else {
c.i = mark
}
}
if c.skipByte(')') {
if len(stack) == 0 {
return nil, c.errorf("unexpected ')'")
}
if len(sub) == 1 {
next = sub[0]
} else {
next = orPredicate{sub}
}
s := stack[len(stack)-1]
stack = stack[:len(stack)-1]
sub = s.sub
and = s.and
goto HandleNext
}
if len(stack) > 0 {
return nil, c.errorf("expected ')'")
}
if len(sub) == 1 {
step.pred = sub[0]
} else {
step.pred = orPredicate{sub}
}
if !c.skipByte(']') {
return nil, c.errorf("expected ']'")
}
c.skipSpaces()
}
steps = append(steps, step)
//fmt.Printf("step: %#v\n", step)
if !c.skipByte('/') {
if (start == 0 || start == c.i) && c.i < len(c.path) {
return nil, c.errorf("unexpected %q", c.path[c.i])
}
return &Path{steps: steps, path: c.path[start:c.i]}, nil
}
}
panic("unreachable")
}
var errNoLiteral = fmt.Errorf("expected a literal string")
func (c *pathCompiler) parseLiteral() (string, error) {
if c.skipByte('"') {
mark := c.i
if !c.skipByteFind('"') {
return "", fmt.Errorf(`missing '"'`)
}
return c.path[mark : c.i-1], nil
}
if c.skipByte('\'') {
mark := c.i
if !c.skipByteFind('\'') {
return "", fmt.Errorf(`missing "'"`)
}
return c.path[mark : c.i-1], nil
}
return "", errNoLiteral
}
func (c *pathCompiler) parseInt() (v int, ok bool) {
mark := c.i
for c.i < len(c.path) && c.path[c.i] >= '0' && c.path[c.i] <= '9' {
v *= 10
v += int(c.path[c.i]) - '0'
c.i++
}
if c.i == mark {
return 0, false
}
return v, true
}
func (c *pathCompiler) skipByte(b byte) bool {
if c.i < len(c.path) && c.path[c.i] == b {
c.i++
return true
}
return false
}
func (c *pathCompiler) skipByteFind(b byte) bool {
for i := c.i; i < len(c.path); i++ {
if c.path[i] == b {
c.i = i + 1
return true
}
}
return false
}
func (c *pathCompiler) peekByte(b byte) bool {
return c.i < len(c.path) && c.path[c.i] == b
}
func (c *pathCompiler) skipSpaces() bool {
mark := c.i
for c.i < len(c.path) {
if c.path[c.i] != ' ' {
break
}
c.i++
}
return c.i != mark
}
func (c *pathCompiler) skipString(s string) bool {
if c.i+len(s) <= len(c.path) && c.path[c.i:c.i+len(s)] == s {
c.i += len(s)
return true
}
return false
}
func (c *pathCompiler) skipName() bool {
if c.i >= len(c.path) {
return false
}
if c.path[c.i] == '*' {
c.i++
return true
}
start := c.i
for c.i < len(c.path) && (c.path[c.i] >= utf8.RuneSelf || isNameByte(c.path[c.i])) {
c.i++
}
return c.i > start
}
func isNameByte(c byte) bool {
return 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z' || '0' <= c && c <= '9' || c == '_' || c == '.' || c == '-'
}