cli/q
Code Issues 1 Pull Requests Activity

Implemented for loops

Browse Source
This commit is contained in:
Eduard Urbach
2025-02-19 23:46:17 +01:00
parent 7922cff7ba
commit 45a36a645a
16 changed files with 142 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/ast/For.go Normal file
View File

@ -0,0 +1,9 @@
package ast
import "git.akyoto.dev/cli/q/src/expression"
// For is a loop with a defined iteration limit.
type For struct {
Head *expression.Expression
Body AST
}

5
src/ast/Loop.go
View File

@ -1,9 +1,6 @@
package ast
import "git.akyoto.dev/cli/q/src/expression"
// Loop represents a block of repeatable statements.
// Loop is a block of infinitely repeating instructions.
type Loop struct {
Head *expression.Expression
Body AST
}

8
src/ast/parseKeyword.go
View File

@ -39,17 +39,21 @@ func parseKeyword(tokens token.List, source []byte, nodes AST) (Node, error) {
ifNode.Else = body
return nil, err
case token.Loop:
case token.For:
blockStart, _, body, err := block(tokens, source)
head := tokens[1:blockStart]
loop := &Loop{
loop := &For{
Head: expression.Parse(head),
Body: body,
}
return loop, err
case token.Loop:
_, _, body, err := block(tokens, source)
return &Loop{Body: body}, err
case token.Return:
if len(tokens) == 1 {
return &Return{}, nil

4
src/core/CompileASTNode.go
View File

@ -28,6 +28,10 @@ func (f *Function) CompileASTNode(node ast.Node) error {
f.Fold(node.Condition)
return f.CompileIf(node)
case *ast.For:
f.Fold(node.Head)
return f.CompileFor(node)
case *ast.Loop:
return f.CompileLoop(node)

92
src/core/CompileFor.go Normal file
View File

@ -0,0 +1,92 @@
package core
import (
"fmt"
"git.akyoto.dev/cli/q/src/asm"
"git.akyoto.dev/cli/q/src/ast"
"git.akyoto.dev/cli/q/src/cpu"
"git.akyoto.dev/cli/q/src/expression"
"git.akyoto.dev/cli/q/src/token"
)
// CompileFor compiles a for loop.
func (f *Function) CompileFor(loop *ast.For) error {
for _, register := range f.CPU.Input {
f.SaveRegister(register)
}
f.count.loop++
var (
label = fmt.Sprintf("%s_loop_%d", f.UniqueName, f.count.loop)
labelEnd = fmt.Sprintf("%s_loop_%d_end", f.UniqueName, f.count.loop)
counter cpu.Register
from *expression.Expression
to *expression.Expression
)
scope := f.PushScope(loop.Body, f.File.Bytes)
scope.InLoop = true
switch loop.Head.Token.Kind {
case token.Define:
variable, err := f.Define(loop.Head.Children[0])
if err != nil {
return err
}
counter = variable.Register
from = loop.Head.Children[1].Children[0]
to = loop.Head.Children[1].Children[1]
f.AddVariable(variable)
case token.Range:
counter = f.NewRegister()
defer f.FreeRegister(counter)
from = loop.Head.Children[0]
to = loop.Head.Children[1]
default:
panic("could not recognize loop header")
}
_, err := f.ExpressionToRegister(from, counter)
if err != nil {
return err
}
if to.Token.IsNumeric() {
number, err := f.ToNumber(to.Token)
if err != nil {
return err
}
f.AddLabel(label)
f.RegisterNumber(asm.COMPARE, counter, number)
} else {
_, register, isTemporary, err := f.Evaluate(to)
if err != nil {
return err
}
if isTemporary {
defer f.FreeRegister(register)
}
f.AddLabel(label)
f.RegisterRegister(asm.COMPARE, counter, register)
}
f.Jump(asm.JGE, labelEnd)
err = f.CompileAST(loop.Body)
f.RegisterNumber(asm.ADD, counter, 1)
f.Jump(asm.JUMP, label)
f.AddLabel(labelEnd)
f.PopScope()
return err
}

79
src/core/CompileLoop.go
View File

@ -5,92 +5,21 @@ import (
"git.akyoto.dev/cli/q/src/asm"
"git.akyoto.dev/cli/q/src/ast"
"git.akyoto.dev/cli/q/src/cpu"
"git.akyoto.dev/cli/q/src/expression"
"git.akyoto.dev/cli/q/src/token"
)
// CompileLoop compiles a loop instruction.
// CompileLoop compiles an infinite loop.
func (f *Function) CompileLoop(loop *ast.Loop) error {
if loop.Head == nil {
return f.CompileLoopInfinite(loop)
}
for _, register := range f.CPU.Input {
f.SaveRegister(register)
}
f.count.loop++
var (
label = fmt.Sprintf("%s_loop_%d", f.UniqueName, f.count.loop)
labelEnd = fmt.Sprintf("%s_loop_%d_end", f.UniqueName, f.count.loop)
counter cpu.Register
from *expression.Expression
to *expression.Expression
)
label := fmt.Sprintf("%s_loop_%d", f.UniqueName, f.count.loop)
f.AddLabel(label)
scope := f.PushScope(loop.Body, f.File.Bytes)
scope.InLoop = true
switch loop.Head.Token.Kind {
case token.Define:
variable, err := f.Define(loop.Head.Children[0])
if err != nil {
return err
}
counter = variable.Register
from = loop.Head.Children[1].Children[0]
to = loop.Head.Children[1].Children[1]
f.AddVariable(variable)
case token.Range:
counter = f.NewRegister()
defer f.FreeRegister(counter)
from = loop.Head.Children[0]
to = loop.Head.Children[1]
default:
panic("could not recognize loop header")
}
_, err := f.ExpressionToRegister(from, counter)
if err != nil {
return err
}
if to.Token.IsNumeric() {
number, err := f.ToNumber(to.Token)
if err != nil {
return err
}
f.AddLabel(label)
f.RegisterNumber(asm.COMPARE, counter, number)
} else {
_, register, isTemporary, err := f.Evaluate(to)
if err != nil {
return err
}
if isTemporary {
defer f.FreeRegister(register)
}
f.AddLabel(label)
f.RegisterRegister(asm.COMPARE, counter, register)
}
f.Jump(asm.JGE, labelEnd)
err = f.CompileAST(loop.Body)
f.RegisterNumber(asm.ADD, counter, 1)
err := f.CompileAST(loop.Body)
f.Jump(asm.JUMP, label)
f.AddLabel(labelEnd)
f.PopScope()
return err
}

25
src/core/CompileLoopInfinite.go
View File

@ -1,25 +0,0 @@
package core
import (
"fmt"
"git.akyoto.dev/cli/q/src/asm"
"git.akyoto.dev/cli/q/src/ast"
)
// CompileLoopInfinite compiles an infinite loop.
func (f *Function) CompileLoopInfinite(loop *ast.Loop) error {
for _, register := range f.CPU.Input {
f.SaveRegister(register)
}
f.count.loop++
label := fmt.Sprintf("%s_loop_%d", f.UniqueName, f.count.loop)
f.AddLabel(label)
scope := f.PushScope(loop.Body, f.File.Bytes)
scope.InLoop = true
err := f.CompileAST(loop.Body)
f.Jump(asm.JUMP, label)
f.PopScope()
return err
}

1
src/token/Kind.go
View File

@ -69,6 +69,7 @@ const (
Const // const
Else // else
Extern // extern
For // for
If // if
Import // import
Loop // loop

7
src/token/Tokenize_test.go
View File

@ -25,15 +25,16 @@ func TestFunction(t *testing.T) {
}
func TestKeyword(t *testing.T) {
tokens := token.Tokenize([]byte("assert const if import else extern loop return struct switch"))
tokens := token.Tokenize([]byte("assert const else extern if import for loop return struct switch"))
expected := []token.Kind{
token.Assert,
token.Const,
token.If,
token.Import,
token.Else,
token.Extern,
token.If,
token.Import,
token.For,
token.Loop,
token.Return,
token.Struct,

2
src/token/identifier.go
View File

@ -23,6 +23,8 @@ func identifier(tokens List, buffer []byte, i Position) (List, Position) {
kind = Else
case "extern":
kind = Extern
case "for":
kind = For
case "import":
kind = Import
case "loop":