ast

type BinOpNode ¶

type BinOpNode struct {
	Op    string // binary operator
	Left  Node   // left operand
	Right Node   // right operand
}

BinOpNode is a binary operation of the form "left op right".

type CallNode ¶

type CallNode struct {
	Name string // function name
	Args []Node // function arguments, can be empty
}

CallNode is a function call.

type CellScanner ¶

type CellScanner struct {
	// contains filtered or unexported fields
}

CellScanner scans through cells in the inclusive range [from, to].

It supports inverted range, e.g. "A3:A1". In either case, the scanner generates a sequence of cell IDs, sorted by row and column.

func NewCellScanner(from, to string) (*CellScanner, error)

func (sc *CellScanner) Len() int

func (sc *CellScanner) Scan() iter.Seq[string]

type Engine ¶

type Engine struct{}

Engine uses AST for intermediate representation.

func (Engine) Calculate(data any, refcal func(string) (float64, error)) (float64, error)

func (Engine) Parse(s string) (any, error)

func (Engine) WriteIR() bool

type IfNode ¶

type IfNode struct {
	Cond   *RelOpNode // a comparison binary expression
	IfPass Node       // an expression to be executed when if-condition is true
	IfFail Node       // an expression to be executed when if-condition is false
}

IfNode is if-clause, e.g. IF(Cond, IfPassExpr, IfFailExpr).

type Node ¶

type Node any

Node represents any node.

func Parse(s string) (Node, error)

type NumberNode ¶

type NumberNode struct {
	Number string // number text value
}

NumberNode is a number value.

type RangeNode ¶

type RangeNode struct {
	From string // from cell
	To   string // to cell (inclusive)
}

RangeNode represents a cells rang, e.g. A1:A5

type RefNode ¶

type RefNode struct {
	Ref string // cell reference
}

RefNode is a cell reference.

type RelOpNode ¶

type RelOpNode struct {
	Op    string // comparison operator: ==, !=, <, <=, >, >=
	Left  Node   // left operand
	Right Node   // right operand
}

RelOpNode is a comparison binary operation, e.g. "A1 < 5".