feat: support for @ operator

Author: link-duan

ast.go

@@ -27,34 +27,35 @@ const (
 	Ident TokenType = iota + 1
 	Number
 	String
-	BoolLiteral        // TRUE or FALSE
-	EValue             // Error value (e.g., #DIV/0!, #VALUE!, etc)
-	Exclamation        // !
-	BraceOpen          // {
-	BraceClose         // }
-	BracketOpen        // [
-	BracketClose       // ]
-	ParenOpen          // (
-	ParenClose         // )
-	Comma              // ,
-	Semicolon          // ;
-	Percent            // %
-	Exponentiation     // ^
-	Multiply           // *
-	Divide             // /
-	Plus               // +
-	Colon              // :
-	Minus              // -
-	Concat             // &
-	Equal              // =
-	NotEqual           // <>
-	LessThan           // <
-	GreaterThan        // >
-	LessThanOrEqual    // <=
-	GreaterThanOrEqual // >=
-	Cell               // e.g., A1, B2, etc
-	AbsoluteRow        // Absolute row reference (e.g., $1, $2)
-	AbsoluteColumn     // Absolute column reference (e.g., $A, $B)
+	BoolLiteral          // TRUE or FALSE
+	EValue               // Error value (e.g., #DIV/0!, #VALUE!, etc)
+	Exclamation          // !
+	BraceOpen            // {
+	BraceClose           // }
+	BracketOpen          // [
+	BracketClose         // ]
+	ParenOpen            // (
+	ParenClose           // )
+	Comma                // ,
+	Semicolon            // ;
+	ImplicitIntersection // @
+	Percent              // %
+	Exponentiation       // ^
+	Multiply             // *
+	Divide               // /
+	Plus                 // +
+	Colon                // :
+	Minus                // -
+	Concat               // &
+	Equal                // =
+	NotEqual             // <>
+	LessThan             // <
+	GreaterThan          // >
+	LessThanOrEqual      // <=
+	GreaterThanOrEqual   // >=
+	Cell                 // e.g., A1, B2, etc
+	AbsoluteRow          // Absolute row reference (e.g., $1, $2)
+	AbsoluteColumn       // Absolute column reference (e.g., $A, $B)
 )
 
 type Pos struct {

lexer.go

@@ -32,67 +32,68 @@ func (l *lexer) next() (*Token, error) {
 	for l.ch == ' ' || l.ch == '\n' || l.ch == '\t' {
 		l.nextch()
 	}
+	var start = l.pos
 	switch l.ch {
 	case '"':
 		return l.stringLiteral(l.ch)
 	case '\'':
 		return l.stringLiteral(l.ch)
 	case '=':
 		l.nextch()
-		return newToken(l.pos, l.pos, Equal, "="), nil
+		return newToken(start, start, Equal, "="), nil
 	case '!':
 		l.nextch()
-		return newToken(l.pos, l.pos, Exclamation, "!"), nil
+		return newToken(start, start, Exclamation, "!"), nil
 	case ',':
 		l.nextch()
-		return newToken(l.pos, l.pos, Comma, ","), nil
+		return newToken(start, start, Comma, ","), nil
 	case '(':
 		l.nextch()
-		return newToken(l.pos, l.pos, ParenOpen, "("), nil
+		return newToken(start, start, ParenOpen, "("), nil
 	case ')':
 		l.nextch()
-		return newToken(l.pos, l.pos, ParenClose, ")"), nil
+		return newToken(start, start, ParenClose, ")"), nil
 	case '{':
 		l.nextch()
-		return newToken(l.pos, l.pos, BraceOpen, "{"), nil
+		return newToken(start, start, BraceOpen, "{"), nil
 	case '}':
 		l.nextch()
-		return newToken(l.pos, l.pos, BraceClose, "}"), nil
+		return newToken(start, start, BraceClose, "}"), nil
 	case '[':
 		l.nextch()
-		return newToken(l.pos, l.pos, BracketOpen, "["), nil
+		return newToken(start, start, BracketOpen, "["), nil
 	case ']':
 		l.nextch()
-		return newToken(l.pos, l.pos, BracketClose, "]"), nil
+		return newToken(start, start, BracketClose, "]"), nil
 	case ':':
 		l.nextch()
-		return newToken(l.pos, l.pos, Colon, ":"), nil
+		return newToken(start, start, Colon, ":"), nil
 	case ';':
 		l.nextch()
-		return newToken(l.pos, l.pos, Semicolon, ";"), nil
+		return newToken(start, start, Semicolon, ";"), nil
 	case '+':
 		l.nextch()
-		return newToken(l.pos, l.pos, Plus, "+"), nil
+		return newToken(start, start, Plus, "+"), nil
 	case '-':
 		l.nextch()
-		return newToken(l.pos, l.pos, Minus, "-"), nil
+		return newToken(start, start, Minus, "-"), nil
 	case '*':
 		l.nextch()
-		return newToken(l.pos, l.pos, Multiply, "*"), nil
+		return newToken(start, start, Multiply, "*"), nil
 	case '/':
 		l.nextch()
-		return newToken(l.pos, l.pos, Divide, "/"), nil
+		return newToken(start, start, Divide, "/"), nil
 	case '$':
 		return l.absoluteReference()
 	case '&':
 		l.nextch()
-		return newToken(l.pos, l.pos, Concat, "&"), nil
+		return newToken(start, start, Concat, "&"), nil
 	case '^':
 		l.nextch()
-		return newToken(l.pos, l.pos, Exponentiation, "^"), nil
+		return newToken(start, start, Exponentiation, "^"), nil
 	case '%':
 		l.nextch()
-		return newToken(l.pos, l.pos, Percent, "%"), nil
+		return newToken(start, start, Percent, "%"), nil
 	case '<':
 		var start = l.pos
 		l.nextch()
@@ -118,6 +119,9 @@ func (l *lexer) next() (*Token, error) {
 		}
 	case '#':
 		return l.errValue()
+	case '@':
+		l.nextch()
+		return newToken(start, start, ImplicitIntersection, "@"), nil
 	default:
 		if isDigit(l.ch) {
 			return l.number()
@@ -224,16 +228,15 @@ func (l *lexer) errValue() (*Token, error) {
 		"#N/A",
 	}
 	for _, value := range values {
+		_len := utf8.RuneCountInString(value)
 		// check length
-		if l.offset-1+len(value) > len(l.src) {
+		if l.offset-1+_len > len(l.src) {
 			continue // Not enough characters left for this error value
 		}
-		if string(l.src[l.offset-1:l.offset-1+len(value)]) == value {
+		if string(l.src[l.offset-1:l.offset-1+_len]) == value {
 			var start = l.pos
-			l.eat(len(value) - 1) // Consume the error value
+			l.eat(_len) // Consume the error value
 			var end = l.pos
-			l.offset += len(value) - 1 // Adjust offset to skip the error value
-			l.ch = l.peekChar()        // Update current character
 			return newToken(start, end, EValue, value), nil
 		}
 	}
@@ -244,25 +247,21 @@ func (l *lexer) stringLiteral(quote rune) (*Token, error) {
 	var start = l.pos
 	var end = start
 	l.nextch() // Consume the opening quote
-	for l.ch != quote && l.ch >= 0 {
+	for l.ch >= 0 {
 		if l.ch == '\n' {
 			return nil, newLexError(l.pos, "newline in string literal")
 		}
-		if l.ch == '\\' {
-			l.nextch()
-			switch {
-			case l.ch < 0:
-				return nil, newLexError(l.pos, "unclosed string literal")
-			case l.ch == quote || l.ch == '\\':
-				// Consume the escaped character
-			default:
-				return nil, newLexError(l.pos, "invalid escape sequence in string literal")
+		if l.ch == quote {
+			if l.peekChar() == quote {
+				l.nextch()
+			} else {
+				break
 			}
 		}
 		end = l.pos
 		l.nextch()
 	}
-	if l.ch < 0 {
+	if l.ch != quote {
 		return nil, newLexError(l.pos, "unclosed string literal")
 	}
 	end = l.pos // Update end to the position after the closing quote
@@ -315,7 +314,7 @@ func (l *lexer) ident() (*Token, error) {
 LOOP:
 	for l.ch >= 0 {
 		switch {
-		case isASCIILetter(l.ch) || isDigit(l.ch):
+		case isASCIILetter(l.ch) || isDigit(l.ch) || l.ch == '.':
 			end = l.pos
 			endOffset = l.offset
 			l.nextch()

lexer_test.go

@@ -10,6 +10,9 @@ func TestLexer(t *testing.T) {
 		src      string
 		expected TokenType
 	}{
+		{"ERROR.TYPE", Ident},
+		{"@", ImplicitIntersection},
+		{`"""str"""`, String},
 		{"#DIV/0!", EValue},
 		{"#VALUE!", EValue},
 		{"#N/A", EValue},
@@ -27,8 +30,6 @@ func TestLexer(t *testing.T) {
 		{"0.230000", Number},
 		{`"hello"`, String},
 		{`'world'`, String},
-		{`'with quote\''`, String},
-		{`"with quote\""`, String},
 		{"=", Equal},
 		{"!", Exclamation},
 		{",", Comma},

parser.go

@@ -226,6 +226,26 @@ func (p *Parser) negation() (Node, error) {
 	if p.token != nil && p.token.Type == BraceOpen {
 		return p.arrayExpr()
 	}
+	return p.implicitIntersection()
+}
+
+func (p *Parser) implicitIntersection() (Node, error) {
+	if p.token != nil && p.token.Type == ImplicitIntersection {
+		var start = p.token.Start
+		var op = p.token
+		if err := p.advance(); err != nil { // consume the token
+			return nil, err
+		}
+		operand, err := p.rangeExpr()
+		if err != nil {
+			return nil, err
+		}
+		return &UnaryExpr{
+			baseNode: newBaseNode(start, operand.End()),
+			Operator: op,
+			Operand:  operand,
+		}, nil
+	}
 	return p.rangeExpr()
 }
 

parser_test.go

@@ -7,6 +7,10 @@ func TestParse(t *testing.T) {
 		src      string
 		expected string
 	}{
+		{`=+ AName- (-+-+-2^6) = {"A","B"} + @SUM(A1) + (@ERROR.TYPE(#VALUE!) = 2)`, `BinaryExpr(Left: BinaryExpr(Left: UnaryExpr(Operator: +, Operand: IdentExpr(Name: AName)), Operator: -, Right: ParenthesizedExpr(Inner: BinaryExpr(Left: UnaryExpr(Operator: -, Operand: UnaryExpr(Operator: +, Operand: UnaryExpr(Operator: -, Operand: UnaryExpr(Operator: +, Operand: LiteralExpr(Value: -2))))), Operator: ^, Right: LiteralExpr(Value: 6)))), Operator: =, Right: BinaryExpr(Left: BinaryExpr(Left: ArrayExpr([LiteralExpr(Value: "A"), LiteralExpr(Value: "B")]), Operator: +, Right: UnaryExpr(Operator: @, Operand: FunCallExpr(Name: SUM, Arguments: [CellExpr(A1)]))), Operator: +, Right: ParenthesizedExpr(Inner: BinaryExpr(Left: UnaryExpr(Operator: @, Operand: FunCallExpr(Name: ERROR.TYPE, Arguments: [LiteralExpr(Value: #VALUE!)])), Operator: =, Right: LiteralExpr(Value: 2)))))`},
+		{"=@A:A", "UnaryExpr(Operator: @, Operand: RangeExpr(CellExpr(A):CellExpr(A)))"},
+		{`=IF("a"={"a","b";"c",#N/A;-1,TRUE}, "yes", "no") &   "  more ""test"" text"`, `BinaryExpr(Left: FunCallExpr(Name: IF, Arguments: [BinaryExpr(Left: LiteralExpr(Value: "a"), Operator: =, Right: ArrayExpr([LiteralExpr(Value: "a"), LiteralExpr(Value: "b")], [LiteralExpr(Value: "c"), LiteralExpr(Value: #N/A)], [LiteralExpr(Value: -1), LiteralExpr(Value: TRUE)])), LiteralExpr(Value: "yes"), LiteralExpr(Value: "no")]), Operator: &, Right: LiteralExpr(Value: "  more ""test"" text"))`},
+		{"={#N/A}", "ArrayExpr([LiteralExpr(Value: #N/A)])"},
 		{"={1,2;3,4}", "ArrayExpr([LiteralExpr(Value: 1), LiteralExpr(Value: 2)], [LiteralExpr(Value: 3), LiteralExpr(Value: 4)])"},
 		{"=-{-1}", "UnaryExpr(Operator: -, Operand: ArrayExpr([LiteralExpr(Value: -1)]))"},
 		{"=--1", "UnaryExpr(Operator: -, Operand: LiteralExpr(Value: -1))"},