Esempio n. 1
0
func (context *ExecutionContext) EvalXPath(xmlNode xml.Node, data interface{}) (result interface{}, err error) {
	switch data := data.(type) {
	case string:
		if xpathExpr := xpath.Compile(data); xpathExpr != nil {
			defer xpathExpr.Free()
			result, err = context.EvalXPath(xmlNode, xpathExpr)
		} else {
			err = errors.New("cannot compile xpath: " + data)
		}
	case []byte:
		result, err = context.EvalXPath(xmlNode, string(data))
	case *xpath.Expression:
		xpathCtx := context.XPathContext
		xpathCtx.SetResolver(context)
		err := xpathCtx.Evaluate(xmlNode.NodePtr(), data)
		if err != nil {
			return nil, err
		}
		rt := xpathCtx.ReturnType()
		switch rt {
		case xpath.XPATH_NODESET, xpath.XPATH_XSLT_TREE:
			nodePtrs, err := xpathCtx.ResultAsNodeset()
			if err != nil {
				return nil, err
			}
			var output []xml.Node
			for _, nodePtr := range nodePtrs {
				output = append(output, xml.NewNode(nodePtr, xmlNode.MyDocument()))
			}
			result = output
		case xpath.XPATH_NUMBER:
			result, err = xpathCtx.ResultAsNumber()
		case xpath.XPATH_BOOLEAN:
			result, err = xpathCtx.ResultAsBoolean()
		default:
			result, err = xpathCtx.ResultAsString()
		}
	default:
		err = errors.New("Strange type passed to ExecutionContext.EvalXPath")
	}
	return
}
Esempio n. 2
0
// Returns true if the node matches the pattern
func (m *CompiledMatch) EvalMatch(node xml.Node, mode string, context *ExecutionContext) bool {
	cur := node
	//false if wrong mode
	// #all is an XSLT 2.0 feature
	if m.Template != nil && mode != m.Template.Mode && m.Template.Mode != "#all" {
		return false
	}

	for i, step := range m.Steps {
		switch step.Op {
		case OP_END:
			return true
		case OP_ROOT:
			if cur.NodeType() != xml.XML_DOCUMENT_NODE {
				return false
			}
		case OP_ELEM:
			if cur.NodeType() != xml.XML_ELEMENT_NODE {
				return false
			}
			if step.Value != cur.Name() && step.Value != "*" {
				return false
			}
		case OP_NS:
			uri := ""
			// m.Template.Node
			if m.Template != nil {
				uri = context.LookupNamespace(step.Value, m.Template.Node)
			} else {
				uri = context.LookupNamespace(step.Value, nil)
			}
			if uri != cur.Namespace() {
				return false
			}
		case OP_ATTR:
			if cur.NodeType() != xml.XML_ATTRIBUTE_NODE {
				return false
			}
			if step.Value != cur.Name() && step.Value != "*" {
				return false
			}
		case OP_TEXT:
			if cur.NodeType() != xml.XML_TEXT_NODE && cur.NodeType() != xml.XML_CDATA_SECTION_NODE {
				return false
			}
		case OP_COMMENT:
			if cur.NodeType() != xml.XML_COMMENT_NODE {
				return false
			}
		case OP_ALL:
			if cur.NodeType() != xml.XML_ELEMENT_NODE {
				return false
			}
		case OP_PI:
			if cur.NodeType() != xml.XML_PI_NODE {
				return false
			}
		case OP_NODE:
			switch cur.NodeType() {
			case xml.XML_ELEMENT_NODE, xml.XML_CDATA_SECTION_NODE, xml.XML_TEXT_NODE, xml.XML_COMMENT_NODE, xml.XML_PI_NODE:
				// matches any of these node types
			default:
				return false
			}
		case OP_PARENT:
			cur = cur.Parent()
			if cur == nil {
				return false
			}
		case OP_ANCESTOR:
			next := m.Steps[i+1]
			if next.Op != OP_ELEM {
				return false
			}
			for {
				cur = cur.Parent()
				if cur == nil {
					return false
				}
				if next.Value == cur.Name() {
					break
				}
			}
		case OP_PREDICATE:
			// see test REC/5.2-16
			// see test REC/5.2-22
			evalFull := true
			if context != nil {

				prev := m.Steps[i-1]
				if prev.Op == OP_PREDICATE {
					prev = m.Steps[i-2]
				}
				if prev.Op == OP_ELEM || prev.Op == OP_ALL {
					parent := cur.Parent()
					sibs := context.ChildrenOf(parent)
					var clen, pos int
					for _, n := range sibs {
						if n.NodePtr() == cur.NodePtr() {
							pos = clen + 1
							clen = clen + 1
						} else {
							if n.NodeType() == xml.XML_ELEMENT_NODE {
								if n.Name() == cur.Name() || prev.Op == OP_ALL {
									clen = clen + 1
								}
							}
						}
					}
					if step.Value == "last()" {
						if pos != clen {
							return false
						}
					}
					//eval predicate should do special number handling
					postest, err := strconv.Atoi(step.Value)
					if err == nil {
						if pos != postest {
							return false
						}
					}
					opos, olen := context.XPathContext.GetContextPosition()
					context.XPathContext.SetContextPosition(pos, clen)
					result := cur.EvalXPathAsBoolean(step.Value, context)
					context.XPathContext.SetContextPosition(opos, olen)
					if result == false {
						return false
					}
					evalFull = false
				}
			}
			if evalFull {
				//if we made it this far, fall back to the more expensive option of evaluating
				// the entire pattern globally
				//TODO: cache results on first run for given document
				xp := m.pattern
				if m.pattern[0] != '/' {
					xp = "//" + m.pattern
				}
				e := xpath.Compile(xp)
				o, err := node.Search(e)
				if err != nil {
					//fmt.Println("ERROR",err)
				}
				for _, n := range o {
					if cur.NodePtr() == n.NodePtr() {
						return true
					}
				}
				return false
			}

		case OP_ID:
			//TODO: fix lexer to only put literal inside step value
			val := strings.Trim(step.Value, "()\"'")
			id := cur.MyDocument().NodeById(val)
			if id == nil || node.NodePtr() != id.NodePtr() {
				return false
			}
		case OP_KEY:
			//  TODO: make this robust
			if context != nil {
				val := strings.Trim(step.Value, "()")
				v := strings.Split(val, ",")
				keyname := strings.Trim(v[0], "\"'")
				keyval := strings.Trim(v[1], "\"'")
				key, _ := context.Style.Keys[keyname]
				if key != nil {
					o, _ := key.nodes[keyval]
					for _, n := range o {
						if cur.NodePtr() == n.NodePtr() {
							return true
						}
					}
				}
			}
			return false
		default:
			return false
		}
	}
	//in theory, OP_END means we never reach here
	// in practice, we can generate match patterns
	// that are missing OP_END due to how we handle OP_OR
	return true
}