111

Author: lvan100

lib/vidl/parser.go

@@ -32,7 +32,7 @@ type Expr interface {
 // BinaryExpr represents a binary expression (e.g., a && b, x == y).
 type BinaryExpr struct {
 	Left  Expr   // Left-hand side expression
-	Op    string // Operator (e.g., &&, ||, ==, <)
+	Op    string // Binary operator (e.g., &&, ||, ==, <)
 	Right Expr   // Right-hand side expression
 }
 
@@ -48,7 +48,7 @@ func (e BinaryExpr) Text() string {
 
 // UnaryExpr represents a unary expression (e.g., !x).
 type UnaryExpr struct {
-	Op   string // Operator (e.g., !)
+	Op   string // Unary operator (e.g., !)
 	Expr Expr   // Operand expression
 }
 
@@ -59,10 +59,10 @@ func (e UnaryExpr) Text() string {
 	return fmt.Sprintf("%s%s", e.Op, e.Expr.Text())
 }
 
-// PrimaryExpr represents an atomic expression, which can be a literal,
-// identifier, function call, or parenthesized expression.
+// PrimaryExpr represents an atomic expression:
+// a literal, identifier, function call, or a parenthesized expression.
 type PrimaryExpr struct {
-	Value string     // Literal value or identifier
+	Value string     // Literal or identifier text
 	Call  *FuncCall  // Optional function call
 	Inner *InnerExpr // Optional parenthesized expression
 }
@@ -80,7 +80,7 @@ func (e PrimaryExpr) Text() string {
 // FuncCall represents a function call expression with arguments.
 type FuncCall struct {
 	Name string // Function name
-	Args []Expr // Arguments
+	Args []Expr // Function arguments
 }
 
 func (f FuncCall) Text() string {
@@ -94,7 +94,7 @@ func (f FuncCall) Text() string {
 	return fmt.Sprintf("%s(%s)", f.Name, strings.Join(args, ", "))
 }
 
-// InnerExpr represents a parenthesized expression.
+// InnerExpr represents a parenthesized subexpression, e.g., "(a && b)".
 type InnerExpr struct {
 	Expr Expr
 }
@@ -138,9 +138,7 @@ func Parse(data string) (expr Expr, err error) {
 	p.AddErrorListener(e)
 
 	// Step 3: Walk parse tree with custom listener
-	l := &ParseTreeListener{
-		Tokens: tokens,
-	}
+	l := &ParseTreeListener{Tokens: tokens}
 	antlr.ParseTreeWalkerDefault.Walk(l, p.ValidateExpr())
 
 	// Step 4: Return parsed expression or error
@@ -185,7 +183,7 @@ func parseValidateExpr(ctx IValidateExprContext) Expr {
 	return parseLogicalOrExpr(ctx.LogicalOrExpr())
 }
 
-// parseLogicalOrExpr converts a LogicalOrExprContext into an Expr.
+// parseLogicalOrExpr handles logical OR expressions (e.g., a || b || c).
 func parseLogicalOrExpr(ctx ILogicalOrExprContext) Expr {
 	left := parseLogicalAndExpr(ctx.LogicalAndExpr(0))
 	for i, o := range ctx.AllLOGICAL_OR() {
@@ -198,7 +196,7 @@ func parseLogicalOrExpr(ctx ILogicalOrExprContext) Expr {
 	return left
 }
 
-// parseLogicalAndExpr converts a LogicalAndExprContext into an Expr.
+// parseLogicalAndExpr handles logical AND expressions (e.g., a && b && c).
 func parseLogicalAndExpr(ctx ILogicalAndExprContext) Expr {
 	left := parseEqualityExpr(ctx.EqualityExpr(0))
 	for i, o := range ctx.AllLOGICAL_AND() {
@@ -211,7 +209,7 @@ func parseLogicalAndExpr(ctx ILogicalAndExprContext) Expr {
 	return left
 }
 
-// parseEqualityExpr converts an EqualityExprContext into an Expr.
+// parseEqualityExpr handles equality and inequality comparisons (==, !=).
 func parseEqualityExpr(ctx IEqualityExprContext) Expr {
 	left := parseRelationalExpr(ctx.RelationalExpr(0))
 
@@ -231,7 +229,7 @@ func parseEqualityExpr(ctx IEqualityExprContext) Expr {
 	}
 }
 
-// parseRelationalExpr converts a RelationalExprContext into an Expr.
+// parseRelationalExpr handles <, <=, >, >= expressions.
 func parseRelationalExpr(ctx IRelationalExprContext) Expr {
 	left := parseUnaryExpr(ctx.UnaryExpr(0))
 
@@ -255,7 +253,7 @@ func parseRelationalExpr(ctx IRelationalExprContext) Expr {
 	}
 }
 
-// parseUnaryExpr converts a UnaryExprContext into an Expr.
+// parseUnaryExpr handles unary operators like !expr.
 func parseUnaryExpr(ctx IUnaryExprContext) Expr {
 	if ctx.LOGICAL_NOT() != nil {
 		return UnaryExpr{
@@ -266,7 +264,8 @@ func parseUnaryExpr(ctx IUnaryExprContext) Expr {
 	return parsePrimaryExpr(ctx.PrimaryExpr())
 }
 
-// parsePrimaryExpr converts a PrimaryExprContext into an Expr.
+// parsePrimaryExpr handles literals, identifiers, function calls,
+// and parenthesized expressions.
 func parsePrimaryExpr(ctx IPrimaryExprContext) Expr {
 	if ctx == nil {
 		return nil