rtmleval

func (*parser) next()
{
	p.skipWhitespace()
	if p.ch == 0 {
		p.cur = token{tEOF, ""}
		return
	}
	switch p.ch {
	case '(':
		p.cur = token{tLParen, "("}
		p.readChar()
		return
	case ')':
		p.cur = token{tRParen, ")"}
		p.readChar()
		return
	case '+':
		p.cur = token{tPlus, "+"}
		p.readChar()
		return
	case '-':
		p.cur = token{tMinus, "-"}
		p.readChar()
		return
	case '*':
		p.cur = token{tStar, "*"}
		p.readChar()
		return
	case '/':
		p.cur = token{tSlash, "/"}
		p.readChar()
		return
	case '.':
		p.cur = token{tDot, "."}
		p.readChar()
		return
	case ':':
		p.cur = token{tColon, ":"}
		p.readChar()
		return
	case '"':
		p.readString('"')
		return
	case '\'':
		p.readString('\'')
		return
	case '=':
		if p.peek() == '=' {
			p.readChar()
			p.readChar()
			p.cur = token{tEq, "=="}
			return
		}
		// Single '=' is not an operator in our grammar; skip it.
		p.readChar()
		p.next()
		return
	case '!':
		if p.peek() == '=' {
			p.readChar()
			p.readChar()
			p.cur = token{tNeq, "!="}
			return
		}
		p.cur = token{tNot, "!"}
		p.readChar()
		return
	case '<':
		if p.peek() == '=' {
			p.readChar()
			p.readChar()
			p.cur = token{tLte, "<="}
			return
		}
		p.cur = token{tLt, "<"}
		p.readChar()
		return
	case '>':
		if p.peek() == '=' {
			p.readChar()
			p.readChar()
			p.cur = token{tGte, ">="}
			return
		}
		p.cur = token{tGt, ">"}
		p.readChar()
		return
	case '&':
		if p.peek() == '&' {
			p.readChar()
			p.readChar()
			p.cur = token{tAnd, "&&"}
			return
		}
		// Single '&' is not an operator; skip it.
		p.readChar()
		p.next()
		return
	case '|':
		if p.peek() == '|' {
			p.readChar()
			p.readChar()
			p.cur = token{tOr, "||"}
			return
		}
		// Single '|' is not an operator; skip it.
		p.readChar()
		p.next()
		return
	case '?':
		p.cur = token{tQuestion, "?"}
		p.readChar()
		return
	}

	if p.ch == '"' {
		p.readString('"')
		return
	}
	if p.ch == '\'' {
		p.readString('\'')
		return
	}
	if isDigit(p.ch) || (p.ch == '.' && isDigit(p.peek())) {
		p.readNumber()
		return
	}
	if isIdentStart(p.ch) {
		p.readIdent()
		return
	}

	// Unknown character: skip and continue.
	p.readChar()
	p.next()
}

func (*parser) readString(quote byte)
{
	var sb strings.Builder
	p.readChar()
	for p.ch != quote && p.ch != 0 {
		if p.ch == '\\' {
			p.readChar()
			switch p.ch {
			case 'n':
				sb.WriteByte('\n')
			case 't':
				sb.WriteByte('\t')
			case 'r':
				sb.WriteByte('\r')
			case '\\':
				sb.WriteByte('\\')
			case '"':
				sb.WriteByte('"')
			case '\'':
				sb.WriteByte('\'')
			default:
				sb.WriteByte(p.ch)
			}
		} else {
			sb.WriteByte(p.ch)
		}
		p.readChar()
	}
	if p.ch == quote {
		p.readChar()
	}
	p.cur = token{tString, sb.String()}
}

func (*parser) readIdent()
{
	start := p.pos - 1
	for isIdentPart(p.ch) || p.ch == '-' {
		p.readChar()
	}
	val := p.input[start : p.pos-1]
	// Allow qualified store:/signal:/prop: references as a single identifier so
	// @if/@expr conditions can reference reactive sources (same refs @for uses).
	// The ternary ':' always follows an expression/space, never one of these
	// bare prefixes immediately, so this does not clash with ternary parsing.
	if (val == "store" || val == "signal" || val == "prop") && p.ch == ':' {
		p.readChar()
		for isIdentPart(p.ch) || p.ch == '-' {
			p.readChar()
		}
		p.cur = token{tIdent, p.input[start : p.pos-1]}
		return
	}
	switch val {
	case "true":
		p.cur = token{tTrue, val}
	case "false":
		p.cur = token{tFalse, val}
	case "and":
		p.cur = token{tAnd, val}
	case "or":
		p.cur = token{tOr, val}
	case "not":
		p.cur = token{tNot, val}
	case "is":
		p.cur = token{tIs, val}
	case "then":
		p.cur = token{tThen, val}
	case "else":
		p.cur = token{tElse, val}
	default:
		p.cur = token{tIdent, val}
	}
}

func (*parser) parseTernary() (any, error)
{
	cond, err := p.parseOr()
	if err != nil {
		return nil, err
	}
	if p.cur.typ == tThen {
		p.next()
		thenVal, err := p.parseOr()
		if err != nil {
			return nil, err
		}
		if p.cur.typ != tElse {
			return nil, fmt.Errorf("expected 'else' in ternary expression")
		}
		p.next()
		elseVal, err := p.parseTernary()
		if err != nil {
			return nil, err
		}
		if toBool(cond) {
			return thenVal, nil
		}
		return elseVal, nil
	}
	// Backward compat: symbol ? X : Y
	if p.cur.typ == tQuestion {
		p.next()
		thenVal, err := p.parseOr()
		if err != nil {
			return nil, err
		}
		if p.cur.typ != tColon {
			return nil, fmt.Errorf("expected ':' in ternary expression")
		}
		p.next()
		elseVal, err := p.parseTernary()
		if err != nil {
			return nil, err
		}
		if toBool(cond) {
			return thenVal, nil
		}
		return elseVal, nil
	}
	return cond, nil
}

func (*parser) parseOr() (any, error)
{
	lhs, err := p.parseAnd()
	if err != nil {
		return nil, err
	}
	for p.cur.typ == tOr {
		p.next()
		rhs, err := p.parseAnd()
		if err != nil {
			return nil, err
		}
		lhs = toBool(lhs) || toBool(rhs)
	}
	return lhs, nil
}

func (*parser) parseAnd() (any, error)
{
	lhs, err := p.parseEquality()
	if err != nil {
		return nil, err
	}
	for p.cur.typ == tAnd {
		p.next()
		rhs, err := p.parseEquality()
		if err != nil {
			return nil, err
		}
		lhs = toBool(lhs) && toBool(rhs)
	}
	return lhs, nil
}

func (*parser) parseEquality() (any, error)
{
	lhs, err := p.parseRelational()
	if err != nil {
		return nil, err
	}
	for {
		switch p.cur.typ {
		case tEq:
			p.next()
			rhs, err := p.parseRelational()
			if err != nil {
				return nil, err
			}
			lhs = cmpEqual(lhs, rhs)
		case tNeq:
			p.next()
			rhs, err := p.parseRelational()
			if err != nil {
				return nil, err
			}
			lhs = !cmpEqual(lhs, rhs)
		case tIs:
			p.next()
			// Check for "is not" (negated equality)
			if p.cur.typ == tNot {
				p.next()
				rhs, err := p.parseRelational()
				if err != nil {
					return nil, err
				}
				lhs = !cmpEqual(lhs, rhs)
			} else {
				rhs, err := p.parseRelational()
				if err != nil {
					return nil, err
				}
				lhs = cmpEqual(lhs, rhs)
			}
		default:
			return lhs, nil
		}
	}
}

func (*parser) parseRelational() (any, error)
{
	lhs, err := p.parseAdditive()
	if err != nil {
		return nil, err
	}
	for p.cur.typ == tLt || p.cur.typ == tLte || p.cur.typ == tGt || p.cur.typ == tGte {
		op := p.cur.typ
		p.next()
		rhs, err := p.parseAdditive()
		if err != nil {
			return nil, err
		}
		a, aok := toFloat(lhs)
		b, bok := toFloat(rhs)
		if !aok || !bok {
			return false, nil
		}
		switch op {
		case tLt:
			lhs = a < b
		case tLte:
			lhs = a <= b
		case tGt:
			lhs = a > b
		case tGte:
			lhs = a >= b
		}
	}
	return lhs, nil
}

func (*parser) parseAdditive() (any, error)
{
	lhs, err := p.parseMultiplicative()
	if err != nil {
		return nil, err
	}
	for p.cur.typ == tPlus || p.cur.typ == tMinus {
		op := p.cur.typ
		p.next()
		rhs, err := p.parseMultiplicative()
		if err != nil {
			return nil, err
		}
		a, aok := toFloat(lhs)
		b, bok := toFloat(rhs)
		if aok && bok {
			if op == tPlus {
				lhs = a + b
			} else {
				lhs = a - b
			}
		} else {
			// String concatenation.
			lhs = toString(lhs) + toString(rhs)
		}
	}
	return lhs, nil
}

func (*parser) parseMultiplicative() (any, error)
{
	lhs, err := p.parseUnary()
	if err != nil {
		return nil, err
	}
	for p.cur.typ == tStar || p.cur.typ == tSlash {
		op := p.cur.typ
		p.next()
		rhs, err := p.parseUnary()
		if err != nil {
			return nil, err
		}
		a, aok := toFloat(lhs)
		b, bok := toFloat(rhs)
		if !aok || !bok {
			return nil, fmt.Errorf("incompatible types for * or /")
		}
		if op == tStar {
			lhs = a * b
		} else {
			lhs = a / b
		}
	}
	return lhs, nil
}

func (*parser) parseUnary() (any, error)
{
	if p.cur.typ == tNot {
		p.next()
		v, err := p.parseUnary()
		if err != nil {
			return nil, err
		}
		return !toBool(v), nil
	}
	if p.cur.typ == tMinus {
		p.next()
		v, err := p.parseUnary()
		if err != nil {
			return nil, err
		}
		f, ok := toFloat(v)
		if !ok {
			return nil, fmt.Errorf("cannot negate non-numeric value")
		}
		return -f, nil
	}
	return p.parsePrimary()
}

func (*parser) parsePrimary() (any, error)
{
	switch p.cur.typ {
	case tString:
		v := p.cur.val
		p.next()
		return v, nil
	case tNumber:
		v, err := strconv.ParseFloat(p.cur.val, 64)
		if err != nil {
			return nil, err
		}
		p.next()
		return v, nil
	case tTrue:
		p.next()
		return true, nil
	case tFalse:
		p.next()
		return false, nil
	case tIdent:
		name := p.cur.val
		p.next()
		// Field access: ident.ident.ident
		for p.cur.typ == tDot {
			p.next()
			if p.cur.typ != tIdent {
				return nil, fmt.Errorf("expected field name after dot")
			}
			name += "." + p.cur.val
			p.next()
		}
		// Variable lookup.
		if p.lookup != nil {
			if v, ok := p.lookup(name); ok {
				return v, nil
			}
		}
		return name, nil // fallback: return the name as a string
	case tLParen:
		p.next()
		expr, err := p.parseTernary()
		if err != nil {
			return nil, err
		}
		if p.cur.typ != tRParen {
			return nil, fmt.Errorf("expected )")
		}
		p.next()
		return expr, nil
	default:
		return nil, fmt.Errorf("unexpected token %q", p.cur.val)
	}
}