25476724141

Committed 07 May 2026 04:51AM UTC coverage: 81.149% (+1.0%) from 80.118%

Build # 25476724141

Build Type

push

github

Committed by

davidhoo

Commit Message

fix: improve CTS pass rate to 85.2% (599/703)

- Fix index validation: reject leading zeros, positive sign, negative zero, out-of-range
- Fix slice validation: same integer validation as indices
- Fix non-singular query detection in filter comparisons
- Fix filter number literal validation
- Fix name selector escape handling (53 tests)
- Fix filter absent/null comparisons

Coverage Stats

340 of 377 new or added lines in 2 files covered. (90.19%)

7 existing lines in 1 file now uncovered.

3319 of 4090 relevant lines covered (81.15%)

654.67 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

85.44

/parser.go

package jsonpath

import (
        "fmt"
        "regexp"
        "strconv"
        "strings"
)

// 解析 JSONPath 表达式
func parse(path string) ([]segment, error) {
        // 处理空路径
        if path == "" {
                return nil, nil
        }

        // 检查是否是函数调用格式: functionName(arg1, arg2, ...)
        // 这是 RFC 9535 的 match() 和 search() 函数语法
        if idx := strings.Index(path, "("); idx > 0 && strings.HasSuffix(path, ")") {
                funcName := path[:idx]
                // 验证函数名是有效的标识符
                if isValidFunctionName(funcName) {
                        argsStr := path[idx+1 : len(path)-1]
                        return parseTopLevelFunctionCall(funcName, argsStr)
                }
        }

        // 检查并移除 $ 前缀
        if !strings.HasPrefix(path, "$") {
                return nil, NewError(ErrSyntax, "path must start with $", path)
        }
        path = strings.TrimPrefix(path, "$")

        // 如果路径只有 $，返回空段列表
        if path == "" {
                return nil, nil
        }

        // Reject path that is only whitespace after $ (e.g. "$ ")
        if strings.TrimSpace(path) == "" {
                return nil, NewError(ErrSyntax, "invalid path: trailing whitespace after $", "$"+path)
        }

        // 移除前导点
        dotStripped := false
        if strings.HasPrefix(path, ".") {
                path = path[1:]
                dotStripped = true
        }

        // Reject whitespace between dot and name (e.g. "$. a" after stripping $)
        // Only applies when a dot was actually stripped from the path
        if dotStripped && len(path) > 0 && (path[0] == ' ' || path[0] == '\t' || path[0] == '\n' || path[0] == '\r') {
                return nil, NewError(ErrSyntax, "whitespace is not allowed between dot and member name", "$")
        }

        // 处理递归下降
        if strings.HasPrefix(path, ".") {
                return parseRecursive(path[1:])
        }

        // 处理常规路径
        return parseRegular(path)
}

// isValidFunctionName 检查是否是有效的函数名
func isValidFunctionName(name string) bool {
        if name == "" {
                return false
        }
        for i, r := range name {
                if i == 0 {
                        if !((r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || r == '_') {
                                return false
                        }
                } else {
                        if !((r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') || r == '_') {
                                return false
                        }
                }
        }
        return true
}

// parseTopLevelFunctionCall 解析顶层函数调用
func parseTopLevelFunctionCall(funcName, argsStr string) ([]segment, error) {
        // 解析参数
        args, err := parseFunctionArgsList(argsStr)
        if err != nil {
                return nil, err
        }

        // 创建函数段
        return []segment{&functionSegment{name: funcName, args: args}}, nil
}

// parseFunctionArgsList 解析函数参数列表
func parseFunctionArgsList(argsStr string) ([]interface{}, error) {
        if strings.TrimSpace(argsStr) == "" {
                return nil, nil
        }

        var args []interface{}
        var currentArg strings.Builder
        var inQuote bool
        var quoteChar rune
        depth := 0

        for i := 0; i < len(argsStr); i++ {
                ch := rune(argsStr[i])

                switch {
                case (ch == '\'' || ch == '"') && !inQuote:
                        // 开始引号
                        inQuote = true
                        quoteChar = ch
                        // 不将引号写入 currentArg
                case ch == quoteChar && inQuote:
                        // 结束引号
                        inQuote = false
                        quoteChar = 0
                        // 不将引号写入 currentArg
                case ch == '\\' && inQuote && i+1 < len(argsStr):
                        // 处理转义字符
                        nextCh := rune(argsStr[i+1])
                        if nextCh == quoteChar || nextCh == '\\' {
                                // 转义的引号或反斜杠
                                currentArg.WriteRune(nextCh)
                                i++ // 跳过下一个字符
                        } else {
                                // 其他转义序列，保持原样
                                currentArg.WriteRune(ch)
                        }
                case ch == '(' && !inQuote:
                        depth++
                        currentArg.WriteRune(ch)
                case ch == ')' && !inQuote:
                        depth--
                        currentArg.WriteRune(ch)
                case ch == ',' && !inQuote && depth == 0:
                        arg := strings.TrimSpace(currentArg.String())
                        if arg != "" {
                                parsedArg, err := parseSingleFunctionArg(arg)
                                if err != nil {
                                        return nil, err
                                }
                                args = append(args, parsedArg)
                        }
                        currentArg.Reset()
                default:
                        currentArg.WriteRune(ch)
                }
        }

        // 处理最后一个参数
        arg := strings.TrimSpace(currentArg.String())
        if arg != "" {
                parsedArg, err := parseSingleFunctionArg(arg)
                if err != nil {
                        return nil, err
                }
                args = append(args, parsedArg)
        }

        return args, nil
}

// parseSingleFunctionArg 解析单个函数参数
func parseSingleFunctionArg(arg string) (interface{}, error) {
        arg = strings.TrimSpace(arg)

        // 尝试解析为数字
        if num, err := strconv.ParseFloat(arg, 64); err == nil {
                return num, nil
        }

        // 处理布尔值
        if arg == "true" {
                return true, nil
        }
        if arg == "false" {
                return false, nil
        }

        // 处理 null
        if arg == "null" {
                return nil, nil
        }

        // 如果以 $ 开头，它是一个路径引用
        if strings.HasPrefix(arg, "$") {
                return arg, nil
        }

        // 处理 @ 引用（在过滤器上下文中）
        if strings.HasPrefix(arg, "@") {
                return arg, nil
        }

        // 其他情况都作为字符串处理（包括正则表达式模式）
        return arg, nil
}

// 解析递归下降路径
func parseRecursive(path string) ([]segment, error) {
        // Reject bare recursive descent: $..
        if path == "" {
                return nil, NewError(ErrSyntax, "bare recursive descent is not allowed", "..")
        }

        var segments []segment
        segments = append(segments, &recursiveSegment{})

        // 移除前导点
        path = strings.TrimPrefix(path, ".")

        // 如果还有路径，继续解析
        if path != "" {
                remainingSegments, err := parseRegular(path)
                if err != nil {
                        return nil, err
                }
                segments = append(segments, remainingSegments...)
        }

        return segments, nil
}

// 解析常规路径
func parseRegular(path string) ([]segment, error) {
        var segments []segment
        var current string
        var inBracket bool
        var bracketContent string
        var bracketDepth int
        afterDot := false
        parenDepth := 0

        // Use rune iteration to properly handle multi-byte UTF-8 characters
        for _, r := range path {
                switch {
                case r == '[':
                        if inBracket {
                                // Inside bracket, nested brackets are allowed for filter expressions
                                // (e.g., $[?@.list[0]])
                                bracketDepth++
                                bracketContent += string(r)
                        } else {
                                if current != "" {
                                        seg, err := createDotSegment(current)
                                        if err != nil {
                                                return nil, err
                                        }
                                        segments = append(segments, seg)
                                        current = ""
                                }
                                inBracket = true
                                bracketDepth = 0
                                afterDot = false
                        }

                case r == ']':
                        if !inBracket {
                                return nil, NewError(ErrSyntax, "unexpected closing bracket", path)
                        }
                        if bracketDepth > 0 {
                                // Closing a nested bracket inside the filter
                                bracketDepth--
                                bracketContent += string(r)
                        } else {
                                // Closing the outer bracket
                                seg, err := parseBracketSegment(bracketContent)
                                if err != nil {
                                        return nil, err
                                }
                                segments = append(segments, seg)
                                bracketContent = ""
                                inBracket = false
                        }

                case r == '(' && !inBracket:
                        parenDepth++
                        current += string(r)
                        afterDot = false

                case r == ')' && !inBracket:
                        parenDepth--
                        current += string(r)
                        afterDot = false

                case r == '.' && !inBracket:
                        if current != "" {
                                seg, err := createDotSegment(current)
                                if err != nil {
                                        return nil, err
                                }
                                segments = append(segments, seg)
                                current = ""
                        }
                        afterDot = true

                case (r == ' ' || r == '\t' || r == '\n' || r == '\r') && !inBracket && parenDepth == 0:
                        // RFC 9535: whitespace is allowed between root and dot (e.g. "$ .a")
                        // but NOT between dot and name (e.g. "$. a" is invalid).
                        if afterDot {
                                // Whitespace immediately after dot: invalid
                                return nil, NewError(ErrSyntax, "whitespace is not allowed between dot and member name", path)
                        }
                        if current == "" {
                                // Leading whitespace (e.g. "$ .a"), skip it
                        } else {
                                // Whitespace after a name: flush the name as a segment
                                seg, err := createDotSegment(current)
                                if err != nil {
                                        return nil, err
                                }
                                segments = append(segments, seg)
                                current = ""
                        }

                default:
                        if inBracket {
                                bracketContent += string(r)
                        } else {
                                current += string(r)
                                afterDot = false
                        }
                }
        }

        // 处理最后一个段
        if inBracket {
                return nil, NewError(ErrSyntax, "unclosed bracket", path)
        }
        if current != "" {
                seg, err := createDotSegment(current)
                if err != nil {
                        return nil, err
                }
                segments = append(segments, seg)
        }

        return segments, nil
}

// 创建点表示法段
func createDotSegment(name string) (segment, error) {
        if name == "*" {
                return &wildcardSegment{}, nil
        }
        // Only validate non-function names (functions are handled by nameSegmentV3.evaluateFunction)
        if !strings.Contains(name, "(") && !isValidMemberName(name) {
                return nil, NewError(ErrSyntax, fmt.Sprintf("invalid member name: %s", name), name)
        }
        return &nameSegment{name: name}, nil
}

// isValidMemberName checks if a name is valid for dot notation per RFC 9535.
// member-name-shorthand = name-first *name-char
// name-first = %x41-5A / "_" / %x61-7A / %x80-10FFFF  (letter / "_" / non-ASCII)
// name-char = name-first / %x30-39  (name-first / digit)
func isValidMemberName(name string) bool {
        if name == "" {
                return false
        }
        for i, r := range name {
                if i == 0 {
                        if !((r >= 'A' && r <= 'Z') || (r >= 'a' && r <= 'z') || r == '_' || r >= 0x80) {
                                return false
                        }
                } else {
                        if !((r >= 'A' && r <= 'Z') || (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') || r == '_' || r >= 0x80) {
                                return false
                        }
                }
        }
        return true
}

// 解析方括号段
func parseBracketSegment(content string) (segment, error) {
        // RFC 9535: whitespace is allowed around selectors in brackets
        content = strings.TrimSpace(content)

        // Reject empty brackets: $[]
        if content == "" {
                return nil, NewError(ErrSyntax, "empty bracket segment", "")
        }

        // Reject @ outside of filter expression (must be preceded by ?)
        if strings.HasPrefix(content, "@") {
                return nil, NewError(ErrSyntax, "@ is only allowed inside filter expressions", content)
        }

        // Reject $ outside of filter expression (must be preceded by ?)
        if strings.HasPrefix(content, "$") {
                return nil, NewError(ErrSyntax, "$ is only allowed inside filter expressions", content)
        }

        // Reject space-separated indices: $[0 2]
        // After trimming, check if content looks like "0 2" (numbers separated by space)
        if strings.Contains(content, " ") && !strings.Contains(content, ",") && !strings.HasPrefix(content, "?") && !strings.HasPrefix(content, "'") && !strings.HasPrefix(content, "\"") {
                // Check if it looks like space-separated tokens (not just whitespace in a string)
                parts := strings.Fields(content)
                if len(parts) > 1 {
                        return nil, NewError(ErrSyntax, "space is not a valid separator in bracket selector, use comma", content)
                }
        }

        // 处理通配符
        if content == "*" {
                return &wildcardSegment{}, nil
        }

        // 处理过滤器表达式
        if strings.HasPrefix(content, "?") {
                return parseFilterSegment(content[1:])
        }

        // 处理多索引选择或多字段选择
        if strings.Contains(content, ",") ||
                ((strings.HasPrefix(content, "'") && strings.HasSuffix(content, "'")) && strings.Contains(content[1:len(content)-1], "','")) ||
                ((strings.HasPrefix(content, "\"") && strings.HasSuffix(content, "\"")) && strings.Contains(content[1:len(content)-1], "\",\"")) {
                return parseMultiIndexSegment(content)
        }

        // 处理切片表达式
        if strings.Contains(content, ":") {
                return parseSliceSegment(content)
        }

        // 处理索引或名称
        return parseIndexOrName(content)
}

// 标准化过滤器表达式
func normalizeFilterExpression(expr string) string {
        expr = strings.TrimSpace(expr)
        return expr
}

// expressionParser is a recursive descent parser for filter expressions
type expressionParser struct {
        input string
        pos   int
}

// parseFilterExpression parses a filter expression string into an expression tree
func parseFilterExpression(input string) (exprNode, error) {
        p := &expressionParser{input: input, pos: 0}
        node, err := p.parseOr()
        if err != nil {
                return nil, err
        }
        p.skipSpaces()
        if p.pos < len(p.input) {
                return nil, NewError(ErrInvalidFilter, fmt.Sprintf("unexpected character at position %d: %c", p.pos, p.input[p.pos]), input)
        }
        return node, nil
}

func (p *expressionParser) skipSpaces() {
        for p.pos < len(p.input) && p.input[p.pos] == ' ' {
                p.pos++
        }
}

func (p *expressionParser) parseOr() (exprNode, error) {
        left, err := p.parseAnd()
        if err != nil {
                return nil, err
        }

        children := []exprNode{left}
        for {
                p.skipSpaces()
                if p.pos+1 < len(p.input) && p.input[p.pos:p.pos+2] == "||" {
                        p.pos += 2
                        right, err := p.parseAnd()
                        if err != nil {
                                return nil, err
                        }
                        children = append(children, right)
                } else {
                        break
                }
        }

        if len(children) == 1 {
                return children[0], nil
        }
        return &orNode{children: children}, nil
}

func (p *expressionParser) parseAnd() (exprNode, error) {
        left, err := p.parseUnary()
        if err != nil {
                return nil, err
        }

        children := []exprNode{left}
        for {
                p.skipSpaces()
                if p.pos+1 < len(p.input) && p.input[p.pos:p.pos+2] == "&&" {
                        p.pos += 2
                        right, err := p.parseUnary()
                        if err != nil {
                                return nil, err
                        }
                        children = append(children, right)
                } else {
                        break
                }
        }

        if len(children) == 1 {
                return children[0], nil
        }
        return &andNode{children: children}, nil
}

func (p *expressionParser) parseUnary() (exprNode, error) {
        p.skipSpaces()
        if p.pos < len(p.input) && p.input[p.pos] == '!' {
                p.pos++
                inner, err := p.parsePrimary()
                if err != nil {
                        return nil, err
                }
                return negateNode(inner)
        }
        return p.parsePrimary()
}

func (p *expressionParser) parsePrimary() (exprNode, error) {
        p.skipSpaces()

        if p.pos >= len(p.input) {
                return nil, NewError(ErrInvalidFilter, "unexpected end of expression", p.input)
        }

        // Handle parenthesized expression
        if p.input[p.pos] == '(' {
                p.pos++ // skip '('
                node, err := p.parseOr()
                if err != nil {
                        return nil, err
                }
                p.skipSpaces()
                if p.pos >= len(p.input) || p.input[p.pos] != ')' {
                        return nil, NewError(ErrInvalidFilter, "missing closing parenthesis", p.input)
                }
                p.pos++ // skip ')'
                return node, nil
        }

        // Parse atomic condition (everything until next &&, ||, or unmatched ))
        start := p.pos
        depth := 0
        inQuotes := false
        inSingleQuotes := false

        for p.pos < len(p.input) {
                ch := p.input[p.pos]

                if ch == '"' && !inSingleQuotes {
                        inQuotes = !inQuotes
                        p.pos++
                        continue
                }
                if ch == '\'' && !inQuotes {
                        inSingleQuotes = !inSingleQuotes
                        p.pos++
                        continue
                }

                if inQuotes || inSingleQuotes {
                        p.pos++
                        continue
                }

                if ch == '(' {
                        depth++
                        p.pos++
                        continue
                }
                if ch == ')' {
                        if depth == 0 {
                                break
                        }
                        depth--
                        p.pos++
                        continue
                }

                // Check for top-level && or ||
                if depth == 0 && p.pos+1 < len(p.input) {
                        op := p.input[p.pos : p.pos+2]
                        if op == "&&" || op == "||" {
                                break
                        }
                }

                p.pos++
        }

        condStr := strings.TrimSpace(p.input[start:p.pos])
        if condStr == "" {
                return nil, NewError(ErrInvalidFilter, "empty condition", p.input)
        }

        cond, err := parseFilterCondition(condStr)
        if err != nil {
                return nil, err
        }
        return &conditionNode{cond: cond}, nil
}

// negateNode applies negation to an expression node
func negateNode(node exprNode) (exprNode, error) {
        switch n := node.(type) {
        case *conditionNode:
                newCond := n.cond
                switch newCond.operator {
                case "==":
                        newCond.operator = "!="
                case "!=":
                        newCond.operator = "=="
                case "<":
                        newCond.operator = ">="
                case "<=":
                        newCond.operator = ">"
                case ">":
                        newCond.operator = "<="
                case ">=":
                        newCond.operator = "<"
                case "exists":
                        newCond.operator = "not_exists"
                case "not_exists":
                        newCond.operator = "exists"
                default:
                        return nil, NewError(ErrInvalidFilter, fmt.Sprintf("cannot negate operator: %s", newCond.operator), "")
                }
                return &conditionNode{cond: newCond}, nil
        case *andNode:
                children := make([]exprNode, len(n.children))
                for i, child := range n.children {
                        negated, err := negateNode(child)
                        if err != nil {
                                return nil, err
                        }
                        children[i] = negated
                }
                return &orNode{children: children}, nil
        case *orNode:
                children := make([]exprNode, len(n.children))
                for i, child := range n.children {
                        negated, err := negateNode(child)
                        if err != nil {
                                return nil, err
                        }
                        children[i] = negated
                }
                return &andNode{children: children}, nil
        default:
                return nil, NewError(ErrInvalidFilter, "cannot negate expression", "")
        }
}

// 解析过滤器表达式
func parseFilterSegment(content string) (segment, error) {
        // RFC 9535: allow whitespace in filter expressions
        content = strings.TrimSpace(content)

        // 检查是否是函数调用格式: functionName(arg1, arg2)
        // 这是 RFC 9535 的 match() 和 search() 函数语法
        if idx := strings.Index(content, "("); idx > 0 && strings.HasSuffix(content, ")") {
                funcName := content[:idx]
                if isValidFunctionName(funcName) {
                        // 这是一个函数调用，解析为过滤器表达式
                        argsStr := content[idx+1 : len(content)-1]
                        cond, err := parseFilterFunctionCall(funcName, argsStr)
                        if err != nil {
                                return nil, NewError(ErrInvalidFilter, fmt.Sprintf("invalid filter syntax: %s", content), content)
                        }
                        return &filterSegment{expr: &conditionNode{cond: cond}}, nil
                }
        }

        // 检查语法 - 支持 @, $, 和函数调用作为过滤器表达式的开头
        trimmed := strings.TrimSpace(content)
        if !strings.HasPrefix(trimmed, "@") && !strings.HasPrefix(trimmed, "$") &&
                !strings.HasPrefix(trimmed, "(@") && !strings.HasPrefix(trimmed, "($") &&
                !strings.HasPrefix(trimmed, "!") && !strings.HasPrefix(trimmed, "(!") &&
                !strings.HasPrefix(trimmed, "(") {
                return nil, NewError(ErrInvalidFilter, fmt.Sprintf("invalid filter syntax: %s", content), content)
        }

        // 取过滤器内容
        var filterContent string

        switch {
        case strings.HasPrefix(content, "(!"):
                if !strings.HasSuffix(content, ")") {
                        return nil, NewError(ErrInvalidFilter, "invalid filter syntax: missing closing parenthesis", content)
                }
                filterContent = content[2 : len(content)-1]
                // Apply De Morgan's laws: !(A && B) => !A || !B, !(A || B) => !A && !B
                expr, err := parseFilterExpression(filterContent)
                if err != nil {
                        return nil, NewError(ErrInvalidFilter, fmt.Sprintf("error parsing filter expression: %v", err), content)
                }
                negated, err := negateNode(expr)
                if err != nil {
                        return nil, NewError(ErrInvalidFilter, fmt.Sprintf("error negating expression: %v", err), content)
                }
                return &filterSegment{expr: negated}, nil
        case strings.HasPrefix(content, "!@"):
                // Keep the ! in the content for the parser to handle as unary operator
                filterContent = content
        case strings.HasPrefix(content, "(@"):
                if !strings.HasSuffix(content, ")") {
                        return nil, NewError(ErrInvalidFilter, "invalid filter syntax: missing closing parenthesis", content)
                }
                filterContent = content[2 : len(content)-1]
        case strings.HasPrefix(content, "($"):
                if !strings.HasSuffix(content, ")") {
                        return nil, NewError(ErrInvalidFilter, "invalid filter syntax: missing closing parenthesis", content)
                }
                filterContent = content[2 : len(content)-1]
        case strings.HasPrefix(content, "@"):
                filterContent = content
        case strings.HasPrefix(content, "$"):
                filterContent = content
        case strings.HasPrefix(content, "!"):
                // Keep the ! in the content for the parser to handle as unary operator
                filterContent = content
                // Check for !(expr) pattern
                if len(content) > 1 && content[1] == '(' {
                        if !strings.HasSuffix(content, ")") {
                                return nil, NewError(ErrInvalidFilter, "invalid filter syntax: missing closing parenthesis", content)
                        }
                        // Apply De Morgan's laws for !(expr)
                        innerContent := content[2 : len(content)-1]
                        expr, err := parseFilterExpression(innerContent)
                        if err != nil {
                                return nil, NewError(ErrInvalidFilter, fmt.Sprintf("error parsing filter expression: %v", err), content)
                        }
                        negated, err := negateNode(expr)
                        if err != nil {
                                return nil, NewError(ErrInvalidFilter, fmt.Sprintf("error negating expression: %v", err), content)
                        }
                        return &filterSegment{expr: negated}, nil
                }
        case strings.HasPrefix(content, "("):
                if !strings.HasSuffix(content, ")") {
                        return nil, NewError(ErrInvalidFilter, "invalid filter syntax: missing closing parenthesis", content)
                }
                filterContent = content[1 : len(content)-1]
        default:
                filterContent = content
        }

        // 标准化表达式
        filterContent = normalizeFilterExpression(filterContent)

        // 解析表达式为树结构
        expr, err := parseFilterExpression(filterContent)
        if err != nil {
                return nil, NewError(ErrInvalidFilter, fmt.Sprintf("error parsing filter expression: %v", err), content)
        }

        return &filterSegment{expr: expr}, nil
}

// 解析过滤器条件
// isNonSingularQuery checks if a path contains non-singular selectors
// (wildcard, slice, multi-index, descendant) which are not allowed in comparisons
func isNonSingularQuery(field string) bool {
        // Check for wildcard
        if strings.Contains(field, "*") {
                return true
        }
        // Check for descendant (..)
        if strings.Contains(field, "..") {
                return true
        }
        // Check for bracket expressions
        if strings.Contains(field, "[") {
                // Check for slice (:)
                if strings.Contains(field, ":") {
                        return true
                }
                // Check for multi-index (,) - but need to be careful about commas in strings
                // Simple check: if there's a comma outside of quotes
                inQuotes := false
                for i := 0; i < len(field); i++ {
                        if field[i] == '\'' || field[i] == '"' {
                                inQuotes = !inQuotes
                        } else if field[i] == ',' && !inQuotes {
                                return true
                        }
                }
        }
        return false
}

func parseFilterCondition(content string) (filterCondition, error) {
        // 检查是否是函数调用格式: functionName(arg1, arg2)
        // 这是 RFC 9535 的 match() 和 search() 函数语法
        if idx := strings.Index(content, "("); idx > 0 && strings.HasSuffix(content, ")") {
                funcName := content[:idx]
                if isValidFunctionName(funcName) {
                        argsStr := content[idx+1 : len(content)-1]
                        return parseFilterFunctionCall(funcName, argsStr)
                }
        }

        // 确保条件以 @ 或 $ 开头
        isRoot := false
        if strings.HasPrefix(content, "$") {
                isRoot = true
        } else if !strings.HasPrefix(content, "@") {
                if strings.HasPrefix(content, ".") {
                        content = "@" + content
                } else {
                        return filterCondition{}, NewError(ErrInvalidFilter, fmt.Sprintf("invalid condition: %s", content), content)
                }
        }

        // 检查是否是旧式方法调用: @.field.match(pattern)
        if strings.Contains(content, ".match(") {
                parts := strings.Split(content, ".match(")
                if len(parts) != 2 || !strings.HasSuffix(parts[1], ")") {
                        return filterCondition{}, NewError(ErrInvalidFilter, "invalid match function syntax", content)
                }

                field := strings.TrimSpace(parts[0])
                pattern := strings.TrimSpace(parts[1][:len(parts[1])-1])

                // 验证字段格式
                if !strings.HasPrefix(field, "@") && !strings.HasPrefix(field, "$") {
                        return filterCondition{}, NewError(ErrInvalidFilter, "filter condition must start with @ or $", content)
                }

                // 移除引号
                pattern = strings.Trim(pattern, "\"'")

                fieldIsRoot := strings.HasPrefix(field, "$")
                return filterCondition{
                        field:    strings.TrimPrefix(strings.TrimPrefix(field, "@."), "$."),
                        operator: "match",
                        value:    pattern,
                        isRoot:   fieldIsRoot,
                }, nil
        }

        // 查找比较操作符
        var operator string
        var operatorIndex int
        var operatorFound bool

        // 按长度排序的操作符列表，确保先匹配较长的操作符
        operators := []string{"<=", ">=", "==", "!=", "<", ">"}
        for _, op := range operators {
                idx := strings.Index(content, op)
                if idx != -1 {
                        // 确保这是一个独立的操作符，不是符串值的一部分
                        inQuotes := false
                        inParens := 0
                        isValid := true
                        for i := 0; i < idx; i++ {
                                switch content[i] {
                                case '"':
                                        inQuotes = !inQuotes
                                case '(':
                                        inParens++
                                case ')':
                                        inParens--
                                }
                        }
                        if inQuotes || inParens > 0 {
                                isValid = false
                        }
                        if isValid {
                                operator = op
                                operatorIndex = idx
                                operatorFound = true
                                break
                        }
                }
        }

        if !operatorFound {
                // No operator found - validate that this is a valid field path
                field := strings.TrimSpace(content)
                // Check for invalid operator-like characters
                if strings.ContainsAny(field, "=<>!") {
                        return filterCondition{}, NewError(ErrInvalidFilter, fmt.Sprintf("no valid operator found in condition: %s", content), content)
                }
                // Strip field prefix (@ or $)
                field = strings.TrimPrefix(field, "@.")
                field = strings.TrimPrefix(field, "$.")
                field = strings.TrimPrefix(field, "@")
                field = strings.TrimPrefix(field, "$")
                return filterCondition{
                        field:    field,
                        operator: "exists",
                        value:    nil,
                        isRoot:   isRoot,
                }, nil
        }

        // 分割路径和值
        field := strings.TrimSpace(content[:operatorIndex])
        value := strings.TrimSpace(content[operatorIndex+len(operator):])

        // RFC 9535: non-singular paths are not allowed in comparisons
        // Check the left side (field) for non-singular queries
        if isNonSingularQuery(field) {
                return filterCondition{}, NewError(ErrInvalidFilter, "non-singular query is not allowed in comparison", content)
        }

        // 解析值
        parsedValue, err := parseFilterValue(value)
        if err != nil {
                return filterCondition{}, NewError(ErrInvalidFilter, fmt.Sprintf("invalid value: %s", value), content)
        }

        // Strip field prefix (@ or $)
        field = strings.TrimPrefix(field, "@.")
        field = strings.TrimPrefix(field, "$.")
        field = strings.TrimPrefix(field, "@")
        field = strings.TrimPrefix(field, "$")

        return filterCondition{
                field:    field,
                operator: operator,
                value:    parsedValue,
                isRoot:   isRoot,
        }, nil
}

// parseFilterFunctionCall 解析过滤器中的函数调用
func parseFilterFunctionCall(funcName, argsStr string) (filterCondition, error) {
        // 解析参数
        args, err := parseFunctionArgsList(argsStr)
        if err != nil {
                return filterCondition{}, NewError(ErrInvalidFilter, fmt.Sprintf("invalid function arguments: %v", err), funcName+"("+argsStr+")")
        }

        // 对于 match 和 search 函数，需要两个参数
        if funcName == "match" || funcName == "search" {
                if len(args) != 2 {
                        return filterCondition{}, NewError(ErrInvalidFilter, fmt.Sprintf("%s() requires exactly 2 arguments", funcName), funcName+"("+argsStr+")")
                }

                // 第一个参数是字段路径
                field, ok := args[0].(string)
                if !ok {
                        return filterCondition{}, NewError(ErrInvalidFilter, fmt.Sprintf("%s() first argument must be a string", funcName), funcName+"("+argsStr+")")
                }

                // 第二个参数是模式
                pattern, ok := args[1].(string)
                if !ok {
                        return filterCondition{}, NewError(ErrInvalidFilter, fmt.Sprintf("%s() second argument must be a string", funcName), funcName+"("+argsStr+")")
                }

                return filterCondition{
                        field:    strings.TrimPrefix(field, "@."),
                        operator: funcName,
                        value:    pattern,
                }, nil
        }

        // 对于其他函数，创建一个通用的函数调用条件
        return filterCondition{
                field:    "",
                operator: "function:" + funcName,
                value:    args,
        }, nil
}

// compareValues compares two values based on the operator
func compareValues(value1 interface{}, operator string, value2 interface{}) (bool, error) {
        // 检查操作符是否有效
        validOperators := map[string]bool{
                "==":    true,
                "!=":    true,
                ">":     true,
                "<":     true,
                ">=":    true,
                "<=":    true,
                "match": true,
        }
        if !validOperators[operator] {
                return false, fmt.Errorf("invalid operator: %s", operator)
        }

        // 处理 nil 值
        if value1 == nil || value2 == nil {
                switch operator {
                case "==":
                        return value1 == value2, nil
                case "!=":
                        return value1 != value2, nil
                default:
                        return false, nil
                }
        }

        // 处理数字类型
        num1, num2, isNum := normalizeNumbers(value1, value2)
        if isNum {
                switch operator {
                case "==":
                        return num1 == num2, nil
                case "!=":
                        return num1 != num2, nil
                case ">":
                        return num1 > num2, nil
                case "<":
                        return num1 < num2, nil
                case ">=":
                        return num1 >= num2, nil
                case "<=":
                        return num1 <= num2, nil
                default:
                        return false, fmt.Errorf("invalid operator for numbers: %s", operator)
                }
        }

        // 处理字符串类型
        if str1, ok := value1.(string); ok {
                if str2, ok := value2.(string); ok {
                        switch operator {
                        case "==":
                                return str1 == str2, nil
                        case "!=":
                                return str1 != str2, nil
                        case ">":
                                return str1 > str2, nil
                        case "<":
                                return str1 < str2, nil
                        case ">=":
                                return str1 >= str2, nil
                        case "<=":
                                return str1 <= str2, nil
                        case "match":
                                re, err := regexp.Compile(str2)
                                if err != nil {
                                        return false, fmt.Errorf("invalid regex pattern: %s", str2)
                                }
                                return re.MatchString(str1), nil
                        default:
                                return false, fmt.Errorf("invalid operator for strings: %s", operator)
                        }
                }
                if operator == "match" {
                        return false, fmt.Errorf("pattern must be a string")
                }
        }
        if operator == "match" {
                return false, fmt.Errorf("value must be a string")
        }

        // 处理布尔类型
        if bool1, ok := value1.(bool); ok {
                if bool2, ok := value2.(bool); ok {
                        switch operator {
                        case "==":
                                return bool1 == bool2, nil
                        case "!=":
                                return bool1 != bool2, nil
                        default:
                                return false, nil
                        }
                }
        }

        // 处理数组类型 - RFC 9535 支持深度比较
        if arr1, ok := value1.([]interface{}); ok {
                if arr2, ok := value2.([]interface{}); ok {
                        switch operator {
                        case "==":
                                return deepCompareValues(arr1, arr2), nil
                        case "!=":
                                return !deepCompareValues(arr1, arr2), nil
                        default:
                                return false, nil
                        }
                }
        }

        // 处理对象类型 - RFC 9535 支持深度比较
        if obj1, ok := value1.(map[string]interface{}); ok {
                if obj2, ok := value2.(map[string]interface{}); ok {
                        switch operator {
                        case "==":
                                return deepCompareValues(obj1, obj2), nil
                        case "!=":
                                return !deepCompareValues(obj1, obj2), nil
                        default:
                                return false, nil
                        }
                }
        }

        // RFC 9535: comparison between incompatible types
        // == returns false, != returns true
        if operator == "!=" {
                return true, nil
        }
        return false, nil
}

// deepCompareValues performs deep comparison of two values
func deepCompareValues(a, b interface{}) bool {
        switch v1 := a.(type) {
        case []interface{}:
                v2, ok := b.([]interface{})
                if !ok || len(v1) != len(v2) {
                        return false
                }
                for i := range v1 {
                        if !deepCompareValues(v1[i], v2[i]) {
                                return false
                        }
                }
                return true
        case map[string]interface{}:
                v2, ok := b.(map[string]interface{})
                if !ok || len(v1) != len(v2) {
                        return false
                }
                for k, val1 := range v1 {
                        val2, exists := v2[k]
                        if !exists || !deepCompareValues(val1, val2) {
                                return false
                        }
                }
                return true
        default:
                return a == b
        }
}

// normalizeNumbers 将两个值转换为 float64 类型
func normalizeNumbers(value1, value2 interface{}) (float64, float64, bool) {
        var num1, num2 float64
        var ok1, ok2 bool

        // 尝试将 value1 转换为 float64
        switch v := value1.(type) {
        case float64:
                num1, ok1 = v, true
        case int64:
                num1, ok1 = float64(v), true
        case int:
                num1, ok1 = float64(v), true
        }

        // 尝试将 value2 转换为 float64
        switch v := value2.(type) {
        case float64:
                num2, ok2 = v, true
        case int64:
                num2, ok2 = float64(v), true
        case int:
                num2, ok2 = float64(v), true
        }

        return num1, num2, ok1 && ok2
}

// compareStrings compares two strings using the specified operator
func compareStrings(a string, operator string, b string) bool {
        return standardCompareStrings(a, operator, b)
}

// getFieldValue 获取对象中指定字段的值
func getFieldValue(obj interface{}, field string) (interface{}, error) {
        // 移除 @ 和前导点
        field = strings.TrimPrefix(field, "@")
        field = strings.TrimPrefix(field, ".")

        // 如果字段为空，返回对象本身
        if field == "" {
                return obj, nil
        }

        // 分割字段路径
        parts := strings.Split(field, ".")
        current := obj

        for _, part := range parts {
                // 确保当前是对象
                m, ok := current.(map[string]interface{})
                if !ok {
                        return nil, fmt.Errorf("value is not an object")
                }

                // 获取下一级字段值
                var exists bool
                current, exists = m[part]
                if !exists {
                        return nil, fmt.Errorf("field %s not found", part)
                }
        }

        return current, nil
}

// 解析多索引选择 - RFC 9535 支持混合选择器类型
func parseMultiIndexSegment(content string) (segment, error) {
        // 检查前导和尾随逗号
        if strings.HasPrefix(content, ",") {
                return nil, NewError(ErrInvalidPath, "leading comma in multi-index segment", content)
        }
        if strings.HasSuffix(content, ",") {
                return nil, NewError(ErrInvalidPath, "trailing comma in multi-index segment", content)
        }

        parts := strings.Split(content, ",")

        // 检查空索引
        for _, part := range parts {
                if strings.TrimSpace(part) == "" {
                        return nil, NewError(ErrInvalidPath, "empty index in multi-index segment", content)
                }
        }

        // RFC 9535: 每个部分独立解析，支持混合选择器类型
        // 先尝试解析每个部分
        selectors := make([]segment, 0, len(parts))
        allIndices := true
        allNames := true

        for _, part := range parts {
                trimmed := strings.TrimSpace(part)

                // 检查是否是通配符
                if trimmed == "*" {
                        selectors = append(selectors, &wildcardSegment{})
                        allIndices = false
                        allNames = false
                        continue
                }

                // 检查是否是切片
                if strings.Contains(trimmed, ":") {
                        slice, err := parseSliceSegment(trimmed)
                        if err != nil {
                                return nil, err
                        }
                        selectors = append(selectors, slice)
                        allIndices = false
                        allNames = false
                        continue
                }

                // 检查是否是带引号的字符串
                if (strings.HasPrefix(trimmed, "'") && strings.HasSuffix(trimmed, "'")) ||
                        (strings.HasPrefix(trimmed, "\"") && strings.HasSuffix(trimmed, "\"")) {
                        quoteChar := trimmed[0]
                        name := trimmed[1 : len(trimmed)-1]
                        if !validateQuotedString(name, quoteChar) {
                                return nil, NewError(ErrSyntax, fmt.Sprintf("invalid string literal: %s", trimmed), trimmed)
                        }
                        unescaped, err := unescapeString(name, quoteChar)
                        if err != nil {
                                return nil, NewError(ErrSyntax, fmt.Sprintf("invalid string literal: %s", trimmed), trimmed)
                        }
                        selectors = append(selectors, &nameSegment{name: unescaped})
                        allIndices = false
                        continue
                }

                // 尝试解析为数字索引
                if idx, err := strconv.Atoi(trimmed); err == nil {
                        selectors = append(selectors, &indexSegment{index: idx})
                        allNames = false
                        continue
                }

                // 不是数字也不是带引号的字符串，可能是不带引号的字段名
                selectors = append(selectors, &nameSegment{name: trimmed})
                allIndices = false
        }

        // 如果所有部分都是索引，返回多索引段
        if allIndices {
                indices := make([]int, len(selectors))
                for i, sel := range selectors {
                        indices[i] = sel.(*indexSegment).index
                }
                return &multiIndexSegment{indices: indices}, nil
        }

        // 如果所有部分都是名称，返回多名称段
        if allNames {
                names := make([]string, len(selectors))
                for i, sel := range selectors {
                        names[i] = sel.(*nameSegment).name
                }
                return &multiNameSegment{names: names}, nil
        }

        // 混合类型，返回联合段
        return &unionSegment{selectors: selectors}, nil
}

// 解析切片表达式
func parseSliceSegment(content string) (segment, error) {
        parts := strings.Split(content, ":")
        if len(parts) > 3 {
                return nil, NewError(ErrSyntax, "slice has too many colons", content)
        }

        slice := &sliceSegment{start: 0, end: 0, step: 1}

        // 解析起始索引
        if parts[0] != "" {
                if !validateIntegerLiteral(parts[0]) {
                        return nil, NewError(ErrSyntax, fmt.Sprintf("invalid slice start index: %s", parts[0]), parts[0])
                }
                start, err := strconv.Atoi(parts[0])
                if err != nil {
                        return nil, NewError(ErrSyntax, fmt.Sprintf("invalid slice start index: %s", parts[0]), parts[0])
                }
                if start < -9007199254740991 || start > 9007199254740991 {
                        return nil, NewError(ErrSyntax, fmt.Sprintf("slice start index out of range: %d", start), parts[0])
                }
                slice.start = start
        }

        // 解析结束索引
        if len(parts) > 1 && parts[1] != "" {
                if !validateIntegerLiteral(parts[1]) {
                        return nil, NewError(ErrSyntax, fmt.Sprintf("invalid slice end index: %s", parts[1]), parts[1])
                }
                end, err := strconv.Atoi(parts[1])
                if err != nil {
                        return nil, NewError(ErrSyntax, fmt.Sprintf("invalid slice end index: %s", parts[1]), parts[1])
                }
                if end < -9007199254740991 || end > 9007199254740991 {
                        return nil, NewError(ErrSyntax, fmt.Sprintf("slice end index out of range: %d", end), parts[1])
                }
                slice.end = end
        }

        // 解析步长
        if len(parts) > 2 && parts[2] != "" {
                if !validateIntegerLiteral(parts[2]) {
                        return nil, NewError(ErrSyntax, fmt.Sprintf("invalid slice step: %s", parts[2]), parts[2])
                }
                step, err := strconv.Atoi(parts[2])
                if err != nil {
                        return nil, NewError(ErrSyntax, fmt.Sprintf("invalid slice step: %s", parts[2]), parts[2])
                }
                if step == 0 {
                        return nil, NewError(ErrSyntax, "slice step cannot be zero", parts[2])
                }
                if step < -9007199254740991 || step > 9007199254740991 {
                        return nil, NewError(ErrSyntax, fmt.Sprintf("slice step out of range: %d", step), parts[2])
                }
                slice.step = step
        }

        return slice, nil
}

// validateIntegerLiteral validates an integer literal per RFC 9535.
// Returns true if the string is a valid integer- or decimal-number.
func validateIntegerLiteral(s string) bool {
        if s == "" {
                return false
        }
        i := 0
        // Optional minus (no plus sign allowed)
        if i < len(s) && s[i] == '-' {
                i++
        }
        if i >= len(s) {
                return false
        }
        // Must start with a digit
        if s[i] < '0' || s[i] > '9' {
                return false
        }
        // Leading zero check: if first digit is '0', no more digits allowed
        if s[i] == '0' && i+1 < len(s) && s[i+1] >= '0' && s[i+1] <= '9' {
                return false
        }
        // Consume digits
        for i < len(s) && s[i] >= '0' && s[i] <= '9' {
                i++
        }
        // Must have consumed all characters
        return i == len(s)
}

// looksLikeNumber checks if content looks like it could be a number (starts with digit, -digit, or +digit)
func looksLikeNumber(s string) bool {
        if s == "" {
                return false
        }
        if s[0] >= '0' && s[0] <= '9' {
                return true
        }
        if (s[0] == '-' || s[0] == '+') && len(s) > 1 && s[1] >= '0' && s[1] <= '9' {
                return true
        }
        return false
}

// validateQuotedString validates a quoted string content per RFC 9535.
// Checks for invalid escape sequences and embedded control characters.
// The input should be the string content WITHOUT the surrounding quotes.
// quoteChar is the character used for quoting (' or ").
func validateQuotedString(s string, quoteChar byte) bool {
        i := 0
        for i < len(s) {
                ch := s[i]
                if ch == '\\' {
                        // Escape sequence
                        i++
                        if i >= len(s) {
                                return false // incomplete escape
                        }
                        esc := s[i]
                        switch esc {
                        case '\\', '/', 'b', 'f', 'n', 'r', 't':
                                // Valid simple escapes (same for both quote types)
                                i++
                        case '"':
                                // Double quote escape only valid in double-quoted strings
                                if quoteChar != '"' {
                                        return false
                                }
                                i++
                        case '\'':
                                // Single quote escape only valid in single-quoted strings
                                if quoteChar != '\'' {
                                        return false
                                }
                                i++
                        case 'u':
                                // Unicode escape: \uXXXX
                                i++
                                if i+4 > len(s) {
                                        return false // not enough hex digits
                                }
                                for j := 0; j < 4; j++ {
                                        if i+j >= len(s) || !isHexDigit(s[i+j]) {
                                                return false
                                        }
                                }
                                i += 4
                        default:
                                return false // invalid escape sequence
                        }
                } else if ch == quoteChar {
                        // Unescaped quote character - invalid
                        return false
                } else if ch < 0x20 {
                        // Control characters (U+0000-U+001F) are not allowed unescaped
                        return false
                } else {
                        i++
                }
        }
        return true
}

// unescapeString processes escape sequences in a quoted string per RFC 9535.
// The input should be the string content WITHOUT the surrounding quotes.
// quoteChar is the character used for quoting (' or ").
func unescapeString(s string, quoteChar byte) (string, error) {
        var result strings.Builder
        result.Grow(len(s))
        i := 0
        for i < len(s) {
                ch := s[i]
                if ch == '\\' {
                        i++
                        if i >= len(s) {
                                return "", fmt.Errorf("incomplete escape")
                        }
                        esc := s[i]
                        switch esc {
                        case '"':
                                if quoteChar != '"' {
                                        return "", fmt.Errorf("invalid escape: \\\" in single-quoted string")
                                }
                                result.WriteByte('"')
                        case '\'':
                                if quoteChar != '\'' {
                                        return "", fmt.Errorf("invalid escape: \\' in double-quoted string")
                                }
                                result.WriteByte('\'')
                        case '\\':
                                result.WriteByte('\\')
                        case '/':
                                result.WriteByte('/')
                        case 'b':
                                result.WriteByte('\b')
                        case 'f':
                                result.WriteByte('\f')
                        case 'n':
                                result.WriteByte('\n')
                        case 'r':
                                result.WriteByte('\r')
                        case 't':
                                result.WriteByte('\t')
                        case 'u':
                                // Unicode escape: \uXXXX
                                i++
                                if i+4 > len(s) {
                                        return "", fmt.Errorf("incomplete unicode escape")
                                }
                                hexStr := s[i : i+4]
                                codePoint, err := strconv.ParseUint(hexStr, 16, 32)
                                if err != nil {
                                        return "", fmt.Errorf("invalid unicode escape: %s", hexStr)
                                }
                                // Check for surrogate pairs
                                if codePoint >= 0xD800 && codePoint <= 0xDFFF {
                                        // High surrogate: must be followed by low surrogate
                                        if codePoint <= 0xDBFF && i+10 <= len(s) && s[i+4] == '\\' && s[i+5] == 'u' {
                                                lowHex := s[i+6 : i+10]
                                                lowPoint, err := strconv.ParseUint(lowHex, 16, 32)
                                                if err == nil && lowPoint >= 0xDC00 && lowPoint <= 0xDFFF {
                                                        // Valid surrogate pair
                                                        combined := 0x10000 + (codePoint-0xD800)*0x400 + (lowPoint - 0xDC00)
                                                        result.WriteRune(rune(combined))
                                                        i += 10
                                                        continue
                                                }
                                        }
                                        return "", fmt.Errorf("invalid surrogate pair")
                                }
                                result.WriteRune(rune(codePoint))
                                i += 4
                                continue
                        default:
                                return "", fmt.Errorf("invalid escape: \\%c", esc)
                        }
                        i++
                } else if ch == quoteChar {
                        return "", fmt.Errorf("unescaped quote character")
                } else if ch < 0x20 {
                        return "", fmt.Errorf("control character")
                } else {
                        result.WriteByte(ch)
                        i++
                }
        }
        return result.String(), nil
}

// isHexDigit checks if a byte is a hexadecimal digit
func isHexDigit(ch byte) bool {
        return (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F')
}

// parseIndexOrName parses a bracket content as an index or name selector
func parseIndexOrName(content string) (segment, error) {
        // 处理函数调用
        if strings.HasSuffix(content, ")") {
                return parseFunctionCall(content)
        }

        // Try to parse as an integer index with RFC 9535 validation
        if validateIntegerLiteral(content) {
                idx, err := strconv.Atoi(content)
                if err != nil {
                        return nil, NewError(ErrSyntax, fmt.Sprintf("invalid index: %s", content), content)
                }
                // Reject -0 (negative zero)
                if content == "-0" {
                        return nil, NewError(ErrSyntax, "negative zero is not a valid index", content)
                }
                // RFC 9535: index must be within IEEE 754 double precision range
                if idx < -9007199254740991 || idx > 9007199254740991 {
                        return nil, NewError(ErrSyntax, fmt.Sprintf("index out of range: %d", idx), content)
                }
                return &indexSegment{index: idx}, nil
        }

        // If content looks like a number but fails validation, it's an invalid index
        if looksLikeNumber(content) {
                return nil, NewError(ErrSyntax, fmt.Sprintf("invalid index: %s", content), content)
        }

        // 处理字符串字面量
        if strings.HasPrefix(content, "'") && strings.HasSuffix(content, "'") && len(content) > 1 {
                inner := content[1 : len(content)-1]
                if !validateQuotedString(inner, '\'') {
                        return nil, NewError(ErrSyntax, fmt.Sprintf("invalid string literal: %s", content), content)
                }
                unescaped, err := unescapeString(inner, '\'')
                if err != nil {
                        return nil, NewError(ErrSyntax, fmt.Sprintf("invalid string literal: %s", content), content)
                }
                return &nameSegment{name: unescaped}, nil
        }

        // 处理双引号字符串字面量
        if strings.HasPrefix(content, "\"") && strings.HasSuffix(content, "\"") && len(content) > 1 {
                inner := content[1 : len(content)-1]
                if !validateQuotedString(inner, '"') {
                        return nil, NewError(ErrSyntax, fmt.Sprintf("invalid string literal: %s", content), content)
                }
                unescaped, err := unescapeString(inner, '"')
                if err != nil {
                        return nil, NewError(ErrSyntax, fmt.Sprintf("invalid string literal: %s", content), content)
                }
                return &nameSegment{name: unescaped}, nil
        }

        return &nameSegment{name: content}, nil
}

// 解析函数调用
func parseFunctionCall(content string) (segment, error) {
        // 找到函数名和参数列表
        openParen := strings.Index(content, "(")
        if openParen == -1 {
                return nil, fmt.Errorf("invalid function call syntax: missing opening parenthesis")
        }

        // 检查闭合括号
        if !strings.HasSuffix(content, ")") {
                return nil, fmt.Errorf("invalid function call syntax: missing closing parenthesis")
        }

        name := content[:openParen]
        argsStr := content[openParen+1 : len(content)-1]

        // 解析参数
        args := make([]interface{}, 0)
        if argsStr != "" {
                // 简单参数解析，暂时只支持数字和字符串
                argParts := strings.Split(argsStr, ",")
                for _, arg := range argParts {
                        arg = strings.TrimSpace(arg)
                        if arg == "" {
                                continue // 跳过空参数
                        }
                        // 尝试解析为数字
                        if num, err := strconv.ParseFloat(arg, 64); err == nil {
                                args = append(args, num)
                                continue
                        }
                        // 处理字符串参数
                        if strings.HasPrefix(arg, "'") && strings.HasSuffix(arg, "'") {
                                // 处理转义引号
                                str := arg[1 : len(arg)-1]
                                str = strings.ReplaceAll(str, "''", "'")
                                args = append(args, str)
                                continue
                        }
                        return nil, fmt.Errorf("unsupported argument type: %s", arg)
                }
        }

        return &functionSegment{name: name, args: args}, nil
}

// validateNumberLiteral validates a number literal per RFC 9535 grammar.
// number = ["-"] (int / (int "." 1*DIGIT))
// int = "0" / (DIGIT1 *DIGIT)
func validateNumberLiteral(s string) bool {
        if s == "" {
                return false
        }
        i := 0
        // Optional minus
        if s[i] == '-' {
                i++
        }
        if i >= len(s) {
                return false
        }
        // Must have integer part
        if s[i] < '0' || s[i] > '9' {
                return false
        }
        // Leading zero check
        if s[i] == '0' {
                i++
                if i < len(s) && s[i] >= '0' && s[i] <= '9' {
                        return false // leading zero
                }
        } else {
                // Non-zero digit, consume all digits
                for i < len(s) && s[i] >= '0' && s[i] <= '9' {
                        i++
                }
        }
        // Optional fractional part
        if i < len(s) && s[i] == '.' {
                i++
                if i >= len(s) || s[i] < '0' || s[i] > '9' {
                        return false // must have digit after decimal
                }
                for i < len(s) && s[i] >= '0' && s[i] <= '9' {
                        i++
                }
        }
        // Optional exponent
        if i < len(s) && (s[i] == 'e' || s[i] == 'E') {
                i++
                if i < len(s) && (s[i] == '+' || s[i] == '-') {
                        i++
                }
                if i >= len(s) || s[i] < '0' || s[i] > '9' {
                        return false // must have digit after e/E
                }
                for i < len(s) && s[i] >= '0' && s[i] <= '9' {
                        i++
                }
        }
        // Must have consumed all characters
        return i == len(s)
}

// parseFilterValue parses a filter value string into an appropriate type
func parseFilterValue(valueStr string) (interface{}, error) {
        valueStr = strings.TrimSpace(valueStr)

        // 处理 null
        if valueStr == "null" {
                return nil, nil
        }

        // 处理布尔值
        if valueStr == "true" {
                return true, nil
        }
        if valueStr == "false" {
                return false, nil
        }

        // 处理字符串（带引号）
        if (strings.HasPrefix(valueStr, "'") && strings.HasSuffix(valueStr, "'")) ||
                (strings.HasPrefix(valueStr, "\"") && strings.HasSuffix(valueStr, "\"")) {
                return valueStr[1 : len(valueStr)-1], nil
        }

        // Try to parse as number with RFC 9535 validation
        if validateNumberLiteral(valueStr) {
                num, err := strconv.ParseFloat(valueStr, 64)
                if err != nil {
                        return nil, fmt.Errorf("invalid number: %s", valueStr)
                }
                return num, nil
        }

        // 处理 $ 引用（根节点）
        if valueStr == "$" {
                return "$", nil
        }

        // 处理 @ 引用（当前元素）
        if valueStr == "@" {
                return "@", nil
        }

        // 处理 $.path 引用（根节点路径）
        if strings.HasPrefix(valueStr, "$.") || strings.HasPrefix(valueStr, "$[") {
                return valueStr, nil
        }

        // 处理 @.path 引用（当前元素路径）
        if strings.HasPrefix(valueStr, "@.") || strings.HasPrefix(valueStr, "@[") {
                return valueStr, nil
        }

        // 如果不是其他类型，返回错误
        return nil, fmt.Errorf("invalid value: %s", valueStr)
}

davidhoo / jsonpath / 25476724141

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous