106 lines
2.5 KiB
Go
106 lines
2.5 KiB
Go
package commands
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
|
|
"c65gm/internal/compiler"
|
|
"c65gm/internal/preproc"
|
|
"c65gm/internal/utils"
|
|
)
|
|
|
|
// GotoCommand handles GOTO statements
|
|
// Syntax: GOTO <target>
|
|
// Where target is:
|
|
// - Label name (naked identifier)
|
|
// - Word variable (indirect jump via jmp (var))
|
|
// - Expression/address (numeric constant or expression)
|
|
//
|
|
// Note: Byte variable jumps not supported - use inline asm for zero-page jumps
|
|
type GotoCommand struct {
|
|
targetName string
|
|
targetKind compiler.VarKind
|
|
address uint16
|
|
isVar bool
|
|
isLabel bool // true if neither var nor expression
|
|
}
|
|
|
|
func (c *GotoCommand) WillHandle(line preproc.Line) bool {
|
|
params, err := utils.ParseParams(line.Text)
|
|
if err != nil || len(params) == 0 {
|
|
return false
|
|
}
|
|
return strings.ToUpper(params[0]) == "GOTO"
|
|
}
|
|
|
|
func (c *GotoCommand) Interpret(line preproc.Line, ctx *compiler.CompilerContext) error {
|
|
// Clear state
|
|
c.targetName = ""
|
|
c.address = 0
|
|
c.isVar = false
|
|
c.isLabel = false
|
|
|
|
params, err := utils.ParseParams(line.Text)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if len(params) != 2 {
|
|
return fmt.Errorf("GOTO: expected 2 parameters, got %d", len(params))
|
|
}
|
|
|
|
targetParam := params[1]
|
|
scope := ctx.CurrentScope()
|
|
|
|
constLookup := func(name string) (int64, bool) {
|
|
sym := ctx.SymbolTable.Lookup(name, scope)
|
|
if sym != nil && sym.IsConst() {
|
|
return int64(sym.Value), true
|
|
}
|
|
return 0, false
|
|
}
|
|
|
|
// Try ParseOperandParam - handles variables, constants, expressions
|
|
varName, varKind, value, isVar, err := compiler.ParseOperandParam(
|
|
targetParam, ctx.SymbolTable, scope, constLookup)
|
|
|
|
if err != nil {
|
|
// Not a variable or expression -> treat as label
|
|
c.targetName = targetParam
|
|
c.isLabel = true
|
|
return nil
|
|
}
|
|
|
|
// It's either a variable or expression/constant
|
|
if isVar {
|
|
// It's a variable
|
|
if varKind == compiler.KindByte {
|
|
return fmt.Errorf("GOTO: cannot jump to byte variable %q (use inline assembler for zero-page jumps)", targetParam)
|
|
}
|
|
c.targetName = varName
|
|
c.targetKind = varKind
|
|
c.isVar = true
|
|
return nil
|
|
}
|
|
|
|
// It's an expression/constant
|
|
c.address = value
|
|
c.isVar = false
|
|
c.isLabel = false
|
|
return nil
|
|
}
|
|
|
|
func (c *GotoCommand) Generate(_ *compiler.CompilerContext) ([]string, error) {
|
|
if c.isVar {
|
|
// Indirect jump through word variable
|
|
return []string{fmt.Sprintf("\tjmp (%s)", c.targetName)}, nil
|
|
}
|
|
|
|
if c.isLabel {
|
|
// Jump to label
|
|
return []string{fmt.Sprintf("\tjmp %s", c.targetName)}, nil
|
|
}
|
|
|
|
// Jump to computed address
|
|
return []string{fmt.Sprintf("\tjmp $%04x", c.address)}, nil
|
|
}
|