Cleaned up function type
This commit is contained in:
@ -1,44 +1,26 @@
|
||||
package build
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strconv"
|
||||
|
||||
"git.akyoto.dev/cli/q/src/build/arch/x64"
|
||||
"git.akyoto.dev/cli/q/src/build/asm"
|
||||
"git.akyoto.dev/cli/q/src/build/config"
|
||||
"git.akyoto.dev/cli/q/src/build/cpu"
|
||||
"git.akyoto.dev/cli/q/src/build/expression"
|
||||
"git.akyoto.dev/cli/q/src/build/fs"
|
||||
"git.akyoto.dev/cli/q/src/build/token"
|
||||
"git.akyoto.dev/cli/q/src/errors"
|
||||
"git.akyoto.dev/go/color/ansi"
|
||||
)
|
||||
|
||||
// Function represents a function.
|
||||
type Function struct {
|
||||
Name string
|
||||
File *fs.File
|
||||
Body token.List
|
||||
Variables map[string]*Variable
|
||||
Assembler asm.Assembler
|
||||
CPU cpu.CPU
|
||||
Error error
|
||||
count struct{ loop int }
|
||||
debug []debug
|
||||
Name string
|
||||
File *fs.File
|
||||
Body token.List
|
||||
compiler
|
||||
}
|
||||
|
||||
// Compile turns a function into machine code.
|
||||
func (f *Function) Compile() {
|
||||
f.Assembler.Label(f.Name)
|
||||
err := f.CompileTokens(f.Body)
|
||||
|
||||
if err != nil {
|
||||
f.Error = err
|
||||
return
|
||||
}
|
||||
|
||||
f.Assembler.Return()
|
||||
f.assembler.Label(f.Name)
|
||||
f.err = f.CompileTokens(f.Body)
|
||||
f.assembler.Return()
|
||||
}
|
||||
|
||||
// CompileTokens compiles a token list.
|
||||
@ -59,21 +41,19 @@ func (f *Function) CompileTokens(body token.List) error {
|
||||
continue
|
||||
}
|
||||
|
||||
if start != -1 {
|
||||
instruction := body[start:i]
|
||||
instruction := body[start:i]
|
||||
|
||||
if config.Verbose {
|
||||
f.debug = append(f.debug, debug{
|
||||
position: len(f.Assembler.Instructions),
|
||||
instruction: instruction,
|
||||
})
|
||||
}
|
||||
if config.Verbose {
|
||||
f.debug = append(f.debug, debug{
|
||||
position: len(f.assembler.Instructions),
|
||||
source: instruction,
|
||||
})
|
||||
}
|
||||
|
||||
err := f.CompileInstruction(instruction)
|
||||
err := f.CompileInstruction(instruction)
|
||||
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
start = i + 1
|
||||
@ -113,152 +93,21 @@ func (f *Function) CompileInstruction(line token.List) error {
|
||||
|
||||
defer expr.Close()
|
||||
|
||||
if isVariableDefinition(expr) {
|
||||
switch true {
|
||||
case isVariableDefinition(expr):
|
||||
return f.CompileVariableDefinition(expr)
|
||||
}
|
||||
|
||||
if isAssignment(expr) {
|
||||
case isAssignment(expr):
|
||||
return f.CompileAssignment(expr)
|
||||
}
|
||||
|
||||
if isFunctionCall(expr) {
|
||||
return f.ExecuteFunctionCall(expr)
|
||||
}
|
||||
|
||||
return errors.New(&errors.InvalidInstruction{Instruction: expr.Token.Text()}, f.File, expr.Token.Position)
|
||||
}
|
||||
|
||||
// ExpressionToRegister moves the result of an expression into the given register.
|
||||
func (f *Function) ExpressionToRegister(root *expression.Expression, register cpu.Register) error {
|
||||
operation := root.Token
|
||||
|
||||
if root.IsLeaf() {
|
||||
return f.TokenToRegister(operation, register)
|
||||
}
|
||||
|
||||
left := root.Children[0]
|
||||
right := root.Children[1]
|
||||
|
||||
err := f.ExpressionToRegister(left, register)
|
||||
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return f.Execute(operation, register, right)
|
||||
}
|
||||
|
||||
// ExpressionsToRegisters moves multiple expressions into the specified registers.
|
||||
func (f *Function) ExpressionsToRegisters(expressions []*expression.Expression, registers []cpu.Register) error {
|
||||
var destinations []cpu.Register
|
||||
|
||||
for i := len(expressions) - 1; i >= 0; i-- {
|
||||
original := registers[i]
|
||||
expression := expressions[i]
|
||||
|
||||
if expression.IsLeaf() {
|
||||
variable, exists := f.Variables[expression.Token.Text()]
|
||||
|
||||
if exists && variable.Register == original {
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
register := original
|
||||
save := !f.CPU.IsFree(register)
|
||||
|
||||
if save {
|
||||
register = x64.RAX
|
||||
}
|
||||
|
||||
err := f.ExpressionToRegister(expression, register)
|
||||
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if save {
|
||||
destinations = append(destinations, original)
|
||||
f.Assembler.Register(asm.PUSH, x64.RAX)
|
||||
}
|
||||
}
|
||||
|
||||
for i := len(destinations) - 1; i >= 0; i-- {
|
||||
f.Assembler.Register(asm.POP, destinations[i])
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// TokenToRegister moves a token into a register.
|
||||
// It only works with identifiers, numbers and strings.
|
||||
func (f *Function) TokenToRegister(t token.Token, register cpu.Register) error {
|
||||
switch t.Kind {
|
||||
case token.Identifier:
|
||||
name := t.Text()
|
||||
variable, exists := f.Variables[name]
|
||||
|
||||
if !exists {
|
||||
return errors.New(&errors.UnknownIdentifier{Name: name}, f.File, t.Position)
|
||||
}
|
||||
|
||||
if register != variable.Register {
|
||||
f.Assembler.RegisterRegister(asm.MOVE, register, variable.Register)
|
||||
}
|
||||
|
||||
f.useVariable(variable)
|
||||
return nil
|
||||
|
||||
case token.Number:
|
||||
value := t.Text()
|
||||
n, err := strconv.Atoi(value)
|
||||
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
f.Assembler.RegisterNumber(asm.MOVE, register, n)
|
||||
return nil
|
||||
|
||||
case token.String:
|
||||
return errors.New(errors.NotImplemented, f.File, t.Position)
|
||||
case isFunctionCall(expr):
|
||||
return f.CompileFunctionCall(expr)
|
||||
|
||||
default:
|
||||
return errors.New(errors.InvalidExpression, f.File, t.Position)
|
||||
return errors.New(&errors.InvalidInstruction{Instruction: expr.Token.Text()}, f.File, expr.Token.Position)
|
||||
}
|
||||
}
|
||||
|
||||
// PrintAsm shows the assembly instructions.
|
||||
func (f *Function) PrintAsm() {
|
||||
ansi.Dim.Println("╭──────────────────────────────────────╮")
|
||||
|
||||
for i, x := range f.Assembler.Instructions {
|
||||
instruction := f.instructionAt(i)
|
||||
|
||||
if instruction != nil {
|
||||
ansi.Dim.Println("├──────────────────────────────────────┤")
|
||||
}
|
||||
|
||||
ansi.Dim.Print("│ ")
|
||||
|
||||
if x.Mnemonic == asm.LABEL {
|
||||
ansi.Yellow.Printf("%-36s", x.Data.String()+":")
|
||||
} else {
|
||||
ansi.Green.Printf("%-8s", x.Mnemonic.String())
|
||||
|
||||
if x.Data != nil {
|
||||
fmt.Printf("%-28s", x.Data.String())
|
||||
} else {
|
||||
fmt.Printf("%-28s", "")
|
||||
}
|
||||
}
|
||||
|
||||
ansi.Dim.Print(" │\n")
|
||||
}
|
||||
|
||||
ansi.Dim.Println("╰──────────────────────────────────────╯")
|
||||
}
|
||||
|
||||
// String returns the function name.
|
||||
func (f *Function) String() string {
|
||||
return f.Name
|
||||
@ -266,7 +115,7 @@ func (f *Function) String() string {
|
||||
|
||||
// identifierExists returns true if the identifier has been defined.
|
||||
func (f *Function) identifierExists(name string) bool {
|
||||
_, exists := f.Variables[name]
|
||||
_, exists := f.variables[name]
|
||||
return exists
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user