Simplified file structure

src/ast/AST.go

@@ -0,0 +1,4 @@
+package ast
+
+type Node any
+type AST []Node

src/ast/Assert.go

@@ -0,0 +1,10 @@
+package ast
+
+import (
+	"git.akyoto.dev/cli/q/src/expression"
+)
+
+// Assert represents a condition that must be true, otherwise the program stops.
+type Assert struct {
+	Condition *expression.Expression
+}

src/ast/Assign.go

@@ -0,0 +1,10 @@
+package ast
+
+import (
+	"git.akyoto.dev/cli/q/src/expression"
+)
+
+// Assign represents an assignment to an existing variable or memory location.
+type Assign struct {
+	Expression *expression.Expression
+}

src/ast/Call.go

@@ -0,0 +1,8 @@
+package ast
+
+import "git.akyoto.dev/cli/q/src/expression"
+
+// Call represents a function call.
+type Call struct {
+	Expression *expression.Expression
+}

src/ast/Count.go

@@ -0,0 +1,51 @@
+package ast
+
+import "git.akyoto.dev/cli/q/src/token"
+
+// Count counts how often the given token appears in the AST.
+func Count(body AST, buffer []byte, kind token.Kind, name string) uint8 {
+	count := uint8(0)
+
+	for _, node := range body {
+		switch node := node.(type) {
+		case *Assert:
+			count += node.Condition.Count(buffer, kind, name)
+
+		case *Assign:
+			count += node.Expression.Count(buffer, kind, name)
+
+		case *Call:
+			count += node.Expression.Count(buffer, kind, name)
+
+		case *Define:
+			count += node.Expression.Count(buffer, kind, name)
+
+		case *If:
+			count += node.Condition.Count(buffer, kind, name)
+			count += Count(node.Body, buffer, kind, name)
+			count += Count(node.Else, buffer, kind, name)
+
+		case *Loop:
+			count += Count(node.Body, buffer, kind, name)
+
+		case *Return:
+			for _, value := range node.Values {
+				count += value.Count(buffer, kind, name)
+			}
+
+		case *Switch:
+			for _, c := range node.Cases {
+				if c.Condition != nil {
+					count += c.Condition.Count(buffer, kind, name)
+				}
+
+				count += Count(c.Body, buffer, kind, name)
+			}
+
+		default:
+			panic("unknown AST type")
+		}
+	}
+
+	return count
+}

src/ast/Define.go

@@ -0,0 +1,10 @@
+package ast
+
+import (
+	"git.akyoto.dev/cli/q/src/expression"
+)
+
+// Define represents a variable definition.
+type Define struct {
+	Expression *expression.Expression
+}

src/ast/EachInstruction.go

@@ -0,0 +1,62 @@
+package ast
+
+import "git.akyoto.dev/cli/q/src/token"
+
+// EachInstruction calls the function on each instruction.
+func EachInstruction(body token.List, call func(token.List) error) error {
+	start := 0
+	groupLevel := 0
+	blockLevel := 0
+
+	for i, t := range body {
+		if start == i && t.Kind == token.NewLine {
+			start = i + 1
+			continue
+		}
+
+		switch t.Kind {
+		case token.NewLine:
+			if groupLevel > 0 || blockLevel > 0 {
+				continue
+			}
+
+			err := call(body[start:i])
+
+			if err != nil {
+				return err
+			}
+
+			start = i + 1
+
+		case token.GroupStart:
+			groupLevel++
+
+		case token.GroupEnd:
+			groupLevel--
+
+		case token.BlockStart:
+			blockLevel++
+
+		case token.BlockEnd:
+			blockLevel--
+
+			if groupLevel > 0 || blockLevel > 0 {
+				continue
+			}
+
+			err := call(body[start : i+1])
+
+			if err != nil {
+				return err
+			}
+
+			start = i + 1
+		}
+	}
+
+	if start != len(body) {
+		return call(body[start:])
+	}
+
+	return nil
+}

src/ast/If.go

@@ -0,0 +1,12 @@
+package ast
+
+import (
+	"git.akyoto.dev/cli/q/src/expression"
+)
+
+// If represents an if statement.
+type If struct {
+	Condition *expression.Expression
+	Body      AST
+	Else      AST
+}

src/ast/Loop.go

@@ -0,0 +1,6 @@
+package ast
+
+// Loop represents a block of repeatable statements.
+type Loop struct {
+	Body AST
+}

src/ast/Parse.go

@@ -0,0 +1,38 @@
+package ast
+
+import (
+	"git.akyoto.dev/cli/q/src/expression"
+	"git.akyoto.dev/cli/q/src/token"
+)
+
+// Parse generates an AST from a list of tokens.
+func Parse(tokens []token.Token, source []byte) (AST, error) {
+	nodes := make(AST, 0, len(tokens)/64)
+
+	err := EachInstruction(tokens, func(instruction token.List) error {
+		node, err := parseNode(instruction, source, nodes)
+
+		if err == nil && node != nil {
+			nodes = append(nodes, node)
+		}
+
+		return err
+	})
+
+	return nodes, err
+}
+
+// IsAssignment returns true if the expression is an assignment.
+func IsAssignment(expr *expression.Expression) bool {
+	return expr.Token.IsAssignment()
+}
+
+// IsFunctionCall returns true if the expression is a function call.
+func IsFunctionCall(expr *expression.Expression) bool {
+	return expr.Token.Kind == token.Call
+}
+
+// IsVariableDefinition returns true if the expression is a variable definition.
+func IsVariableDefinition(expr *expression.Expression) bool {
+	return expr.Token.Kind == token.Define
+}

src/ast/Return.go

@@ -0,0 +1,10 @@
+package ast
+
+import (
+	"git.akyoto.dev/cli/q/src/expression"
+)
+
+// Return represents a return statement.
+type Return struct {
+	Values []*expression.Expression
+}

src/ast/Switch.go

@@ -0,0 +1,16 @@
+package ast
+
+import (
+	"git.akyoto.dev/cli/q/src/expression"
+)
+
+// Switch represents a switch statement.
+type Switch struct {
+	Cases []Case
+}
+
+// Case represents a case inside a switch.
+type Case struct {
+	Condition *expression.Expression
+	Body      AST
+}

src/ast/parseKeyword.go

@@ -0,0 +1,97 @@
+package ast
+
+import (
+	"git.akyoto.dev/cli/q/src/errors"
+	"git.akyoto.dev/cli/q/src/expression"
+	"git.akyoto.dev/cli/q/src/token"
+)
+
+// parseKeyword generates a keyword node from an instruction.
+func parseKeyword(tokens token.List, source []byte, nodes AST) (Node, error) {
+	switch tokens[0].Kind {
+	case token.Assert:
+		if len(tokens) == 1 {
+			return nil, errors.New(errors.MissingExpression, nil, tokens[0].End())
+		}
+
+		condition := expression.Parse(tokens[1:])
+		return &Assert{Condition: condition}, nil
+
+	case token.If:
+		blockStart, _, body, err := block(tokens, source)
+		condition := expression.Parse(tokens[1:blockStart])
+		return &If{Condition: condition, Body: body}, err
+
+	case token.Else:
+		_, _, body, err := block(tokens, source)
+
+		if len(nodes) == 0 {
+			return nil, errors.New(errors.ExpectedIfBeforeElse, nil, tokens[0].Position)
+		}
+
+		last := nodes[len(nodes)-1]
+		ifNode, exists := last.(*If)
+
+		if !exists {
+			return nil, errors.New(errors.ExpectedIfBeforeElse, nil, tokens[0].Position)
+		}
+
+		ifNode.Else = body
+		return nil, err
+
+	case token.Loop:
+		_, _, body, err := block(tokens, source)
+		return &Loop{Body: body}, err
+
+	case token.Return:
+		if len(tokens) == 1 {
+			return &Return{}, nil
+		}
+
+		values := expression.NewList(tokens[1:])
+		return &Return{Values: values}, nil
+
+	case token.Switch:
+		blockStart := tokens.IndexKind(token.BlockStart)
+		blockEnd := tokens.LastIndexKind(token.BlockEnd)
+
+		if blockStart == -1 {
+			return nil, errors.New(errors.MissingBlockStart, nil, tokens[0].End())
+		}
+
+		if blockEnd == -1 {
+			return nil, errors.New(errors.MissingBlockEnd, nil, tokens[len(tokens)-1].End())
+		}
+
+		body := tokens[blockStart+1 : blockEnd]
+
+		if len(body) == 0 {
+			return nil, errors.New(errors.EmptySwitch, nil, tokens[0].Position)
+		}
+
+		cases, err := parseSwitch(body, source)
+		return &Switch{Cases: cases}, err
+
+	default:
+		return nil, errors.New(&errors.KeywordNotImplemented{Keyword: tokens[0].Text(source)}, nil, tokens[0].Position)
+	}
+}
+
+// block retrieves the start and end position of a block.
+func block(tokens token.List, source []byte) (blockStart int, blockEnd int, body AST, err error) {
+	blockStart = tokens.IndexKind(token.BlockStart)
+	blockEnd = tokens.LastIndexKind(token.BlockEnd)
+
+	if blockStart == -1 {
+		err = errors.New(errors.MissingBlockStart, nil, tokens[0].End())
+		return
+	}
+
+	if blockEnd == -1 {
+		err = errors.New(errors.MissingBlockEnd, nil, tokens[len(tokens)-1].End())
+		return
+	}
+
+	body, err = Parse(tokens[blockStart+1:blockEnd], source)
+	return
+}

src/ast/parseNode.go

@@ -0,0 +1,42 @@
+package ast
+
+import (
+	"git.akyoto.dev/cli/q/src/errors"
+	"git.akyoto.dev/cli/q/src/expression"
+	"git.akyoto.dev/cli/q/src/token"
+)
+
+// parseNode generates an AST node from an instruction.
+func parseNode(tokens token.List, source []byte, nodes AST) (Node, error) {
+	if tokens[0].IsKeyword() {
+		return parseKeyword(tokens, source, nodes)
+	}
+
+	expr := expression.Parse(tokens)
+
+	if expr == nil {
+		return nil, nil
+	}
+
+	switch {
+	case IsVariableDefinition(expr):
+		if len(expr.Children) < 2 {
+			return nil, errors.New(errors.MissingOperand, nil, expr.Token.End())
+		}
+
+		return &Define{Expression: expr}, nil
+
+	case IsAssignment(expr):
+		if len(expr.Children) < 2 {
+			return nil, errors.New(errors.MissingOperand, nil, expr.Token.End())
+		}
+
+		return &Assign{Expression: expr}, nil
+
+	case IsFunctionCall(expr):
+		return &Call{Expression: expr}, nil
+
+	default:
+		return nil, errors.New(&errors.InvalidInstruction{Instruction: expr.Token.Text(source)}, nil, expr.Token.Position)
+	}
+}

src/ast/parseSwitch.go

@@ -0,0 +1,37 @@
+package ast
+
+import (
+	"git.akyoto.dev/cli/q/src/expression"
+	"git.akyoto.dev/cli/q/src/token"
+)
+
+// parseSwitch generates the cases inside a switch statement.
+func parseSwitch(tokens token.List, source []byte) ([]Case, error) {
+	var cases []Case
+
+	err := EachInstruction(tokens, func(caseTokens token.List) error {
+		blockStart, _, body, err := block(caseTokens, source)
+
+		if err != nil {
+			return err
+		}
+
+		conditionTokens := caseTokens[:blockStart]
+		var condition *expression.Expression
+
+		if len(conditionTokens) == 1 && conditionTokens[0].Kind == token.Identifier && conditionTokens[0].Text(source) == "_" {
+			condition = nil
+		} else {
+			condition = expression.Parse(conditionTokens)
+		}
+
+		cases = append(cases, Case{
+			Condition: condition,
+			Body:      body,
+		})
+
+		return nil
+	})
+
+	return cases, err
+}