136 lines
2.8 KiB
Go
136 lines
2.8 KiB
Go
package build
|
|
|
|
import (
|
|
"git.akyoto.dev/cli/q/src/build/config"
|
|
"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"
|
|
)
|
|
|
|
// Function represents a function.
|
|
type Function struct {
|
|
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)
|
|
f.err = f.CompileTokens(f.Body)
|
|
f.assembler.Return()
|
|
}
|
|
|
|
// CompileTokens compiles a token list.
|
|
func (f *Function) CompileTokens(body token.List) 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
|
|
}
|
|
|
|
instruction := body[start:i]
|
|
|
|
if config.Verbose {
|
|
f.debug = append(f.debug, debug{
|
|
position: len(f.assembler.Instructions),
|
|
source: instruction,
|
|
})
|
|
}
|
|
|
|
err := f.CompileInstruction(instruction)
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
start = i + 1
|
|
|
|
case token.GroupStart:
|
|
groupLevel++
|
|
|
|
case token.GroupEnd:
|
|
groupLevel--
|
|
|
|
case token.BlockStart:
|
|
blockLevel++
|
|
|
|
case token.BlockEnd:
|
|
blockLevel--
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// CompileInstruction compiles a single instruction.
|
|
func (f *Function) CompileInstruction(line token.List) error {
|
|
if len(line) == 0 {
|
|
return nil
|
|
}
|
|
|
|
if line[0].Kind == token.Keyword {
|
|
return f.CompileKeyword(line)
|
|
}
|
|
|
|
expr := expression.Parse(line)
|
|
|
|
if expr == nil {
|
|
return nil
|
|
}
|
|
|
|
defer expr.Close()
|
|
|
|
switch true {
|
|
case isVariableDefinition(expr):
|
|
return f.CompileVariableDefinition(expr)
|
|
|
|
case isAssignment(expr):
|
|
return f.CompileAssignment(expr)
|
|
|
|
case isFunctionCall(expr):
|
|
return f.CompileFunctionCall(expr)
|
|
|
|
default:
|
|
return errors.New(&errors.InvalidInstruction{Instruction: expr.Token.Text()}, f.File, expr.Token.Position)
|
|
}
|
|
}
|
|
|
|
// String returns the function name.
|
|
func (f *Function) String() string {
|
|
return f.Name
|
|
}
|
|
|
|
// identifierExists returns true if the identifier has been defined.
|
|
func (f *Function) identifierExists(name string) bool {
|
|
_, exists := f.variables[name]
|
|
return exists
|
|
}
|
|
|
|
// isAssignment returns true if the expression is an assignment.
|
|
func isAssignment(expr *expression.Expression) bool {
|
|
return expr.Token.Kind == token.Operator && expr.Token.Bytes[len(expr.Token.Bytes)-1] == '='
|
|
}
|
|
|
|
// isFunctionCall returns true if the expression is a function call.
|
|
func isFunctionCall(expr *expression.Expression) bool {
|
|
return expr.Token.Kind == token.Operator && expr.Token.Text() == "λ"
|
|
}
|
|
|
|
// isVariableDefinition returns true if the expression is a variable definition.
|
|
func isVariableDefinition(expr *expression.Expression) bool {
|
|
return expr.Token.Kind == token.Operator && expr.Token.Text() == ":="
|
|
}
|