Method VisitLiteralOrFml

parse/parse.go:398–467

VisitLiteralOrFml visits a parse tree produced by literalOrFml

(ctx *gen.LiteralOrFmlContext)

// VisitLiteralOrFml visits a parse tree produced by literalOrFml
func (p Parser) VisitLiteralOrFml(ctx *gen.LiteralOrFmlContext) any {
	term := p.Visit(ctx.Term(0)).(ast.Term)
	atom, ok := term.(ast.Atom)

	// Handle negation
	if ctx.BANG() != nil {
		if !ok {
			p.errors.Add(fmt.Sprintf("not a literal or fml: %v", ctx.Term(0).GetText()), ctx.Term(0).GetStart().GetLine(), ctx.Term(0).GetStart().GetColumn())
		}
		return ast.NegAtom{atom}
	}

	// Check for temporal operator
	var tempOp *ast.TemporalOperator
	if tempOpCtx := ctx.TemporalOperator(); tempOpCtx != nil {
		tempOp = p.Visit(tempOpCtx).(*ast.TemporalOperator)
	}

	// Check for temporal annotation
	var tempAnnot *ast.Interval
	if tempAnnotCtx := ctx.TemporalAnnotation(); tempAnnotCtx != nil {
		tempAnnot = p.Visit(tempAnnotCtx).(*ast.Interval)
	}

	// If no comparison operator, it's a simple literal (possibly with temporal annotations)
	if ctx.EQ() == nil && ctx.BANGEQ() == nil && ctx.LESS() == nil && ctx.LESSEQ() == nil && ctx.GREATER() == nil && ctx.GREATEREQ() == nil {
		if ok {
			// If there's a temporal operator or annotation, wrap in TemporalLiteral
			if tempOp != nil || tempAnnot != nil {
				return ast.TemporalLiteral{
					Literal:  atom,
					Operator: tempOp,
					Interval: tempAnnot,
				}
			}
			return atom
		}
		p.errors.Add(fmt.Sprintf("parse error: %v", ctx.GetText()), ctx.GetStart().GetLine(), ctx.GetStart().GetColumn())
		return ast.NewAtom("br0ken")
	}

	// Handle comparison operators
	left := p.Visit(ctx.Term(0)).(ast.Term)
	leftBase, ok := left.(ast.BaseTerm)
	if !ok {
		p.errors.Add(fmt.Sprintf("not a base term: %v", ctx.Term(0).GetText()), ctx.Term(0).GetStart().GetLine(), ctx.Term(0).GetStart().GetColumn())
	}
	right := p.Visit(ctx.Term(1)).(ast.Term)
	rightBase, ok := right.(ast.BaseTerm)
	if !ok {
		p.errors.Add(fmt.Sprintf("not a base term: %v", ctx.Term(1).GetText()), ctx.Term(1).GetStart().GetLine(), ctx.Term(1).GetStart().GetColumn())
	}

	if ctx.EQ() != nil {
		return ast.Eq{leftBase, rightBase}
	}
	if ctx.BANGEQ() != nil {
		return ast.Ineq{leftBase, rightBase}