320 lines
9.1 KiB
Go
320 lines
9.1 KiB
Go
package commands
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
|
|
"c65gm/internal/compiler"
|
|
"c65gm/internal/preproc"
|
|
"c65gm/internal/utils"
|
|
)
|
|
|
|
// PokeWCommand handles POKEW statements (writes a word/2 bytes to memory)
|
|
// Syntax: POKEW <address>[offset] WITH|, <value>
|
|
// Where address is:
|
|
// - Byte variable (zero-page indexed addressing)
|
|
// - Word variable (self-modifying code or ZP pointer with offset)
|
|
// - Expression (direct addressing)
|
|
//
|
|
// Value must be a word variable or word literal (0-65535)
|
|
type PokeWCommand struct {
|
|
addrVarName string
|
|
addrVarKind compiler.VarKind
|
|
addrValue uint16
|
|
isAddrVar bool
|
|
isZPPointer bool
|
|
|
|
offsetVarName string
|
|
offsetValue uint8
|
|
hasOffset bool
|
|
isOffsetVar bool
|
|
|
|
valueVarName string
|
|
valueLiteral uint16
|
|
isValueVar bool
|
|
|
|
pragmaSet preproc.PragmaSet
|
|
}
|
|
|
|
func (c *PokeWCommand) WillHandle(line preproc.Line) bool {
|
|
params, err := utils.ParseParams(line.Text)
|
|
if err != nil || len(params) != 4 {
|
|
return false
|
|
}
|
|
return strings.ToUpper(params[0]) == "POKEW"
|
|
}
|
|
|
|
func (c *PokeWCommand) Interpret(line preproc.Line, ctx *compiler.CompilerContext) error {
|
|
// Clear state
|
|
c.addrVarName = ""
|
|
c.addrValue = 0
|
|
c.isAddrVar = false
|
|
c.isZPPointer = false
|
|
c.offsetVarName = ""
|
|
c.offsetValue = 0
|
|
c.hasOffset = false
|
|
c.isOffsetVar = false
|
|
c.valueVarName = ""
|
|
c.valueLiteral = 0
|
|
c.isValueVar = false
|
|
|
|
// Store pragma set for Generate phase
|
|
c.pragmaSet = ctx.Pragma.GetPragmaSetByIndex(line.PragmaSetIndex)
|
|
|
|
params, err := utils.ParseParams(line.Text)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if len(params) != 4 {
|
|
return fmt.Errorf("POKEW: expected 4 parameters, got %d", len(params))
|
|
}
|
|
|
|
scope := ctx.CurrentScope()
|
|
|
|
// Validate separator (param 3)
|
|
sep := strings.ToUpper(params[2])
|
|
if sep != "WITH" && sep != "," {
|
|
return fmt.Errorf("POKEW: parameter #3 must be 'WITH' or ',', got %q", params[2])
|
|
}
|
|
|
|
// Parse address (param 2) - may have [offset]
|
|
addrParam := params[1]
|
|
baseAddr, offsetParam := parsePOKEWOffset(addrParam)
|
|
|
|
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 to parse base address
|
|
varName, varKind, value, isVar, err := compiler.ParseOperandParam(
|
|
baseAddr, ctx.SymbolTable, scope, constLookup)
|
|
|
|
if err != nil {
|
|
return fmt.Errorf("POKEW: invalid address: %w", err)
|
|
}
|
|
|
|
if isVar {
|
|
// It's a variable
|
|
c.addrVarName = varName
|
|
c.addrVarKind = varKind
|
|
c.isAddrVar = true
|
|
|
|
// Check if it's a ZP pointer
|
|
addrSym := ctx.SymbolTable.Lookup(baseAddr, scope)
|
|
if addrSym != nil {
|
|
c.isZPPointer = addrSym.IsZeroPagePointer()
|
|
}
|
|
} else {
|
|
// It's an expression/constant
|
|
c.addrValue = value
|
|
c.isAddrVar = false
|
|
}
|
|
|
|
// Parse offset if present
|
|
if offsetParam != "" {
|
|
// Offset only allowed with ZP pointers
|
|
if !c.isZPPointer {
|
|
return fmt.Errorf("POKEW: offset [%s] only allowed with zero-page word pointer", offsetParam)
|
|
}
|
|
|
|
c.hasOffset = true
|
|
|
|
// Try to parse offset as variable or expression
|
|
offsetVarName, _, offsetValue, isOffsetVar, err := compiler.ParseOperandParam(
|
|
offsetParam, ctx.SymbolTable, scope, constLookup)
|
|
|
|
if err != nil {
|
|
return fmt.Errorf("POKEW: invalid offset: %w", err)
|
|
}
|
|
|
|
if isOffsetVar {
|
|
// Check it's a byte variable
|
|
offsetSym := ctx.SymbolTable.Lookup(offsetParam, scope)
|
|
if offsetSym != nil && !offsetSym.IsByte() {
|
|
return fmt.Errorf("POKEW: offset variable %q must be byte type", offsetParam)
|
|
}
|
|
c.offsetVarName = offsetVarName
|
|
c.isOffsetVar = true
|
|
} else {
|
|
// Numeric offset - must fit in byte
|
|
if offsetValue > 255 {
|
|
return fmt.Errorf("POKEW: offset value %d out of byte range", offsetValue)
|
|
}
|
|
c.offsetValue = uint8(offsetValue)
|
|
c.isOffsetVar = false
|
|
}
|
|
}
|
|
|
|
// Parse value (param 4)
|
|
valueParam := params[3]
|
|
|
|
// Try to parse as variable or expression
|
|
valVarName, valVarKind, valLiteral, isValVar, err := compiler.ParseOperandParam(
|
|
valueParam, ctx.SymbolTable, scope, constLookup)
|
|
|
|
if err != nil {
|
|
return fmt.Errorf("POKEW: invalid value: %w", err)
|
|
}
|
|
|
|
if isValVar {
|
|
// It's a variable - must be word
|
|
if valVarKind == compiler.KindByte {
|
|
return fmt.Errorf("POKEW: cannot use byte variable %q (use word variable or literal)", valueParam)
|
|
}
|
|
c.valueVarName = valVarName
|
|
c.isValueVar = true
|
|
} else {
|
|
// It's a literal word value
|
|
c.valueLiteral = valLiteral
|
|
c.isValueVar = false
|
|
}
|
|
|
|
// Check for self-referential POKEW (writing pointer through itself)
|
|
if c.isZPPointer && c.isValueVar && c.addrVarName == c.valueVarName {
|
|
return fmt.Errorf("POKEW: writing pointer %q through itself - pointer is both address and value", c.valueVarName)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (c *PokeWCommand) Generate(ctx *compiler.CompilerContext) ([]string, error) {
|
|
var asm []string
|
|
|
|
// Check for immutable code pragma when using self-modifying code
|
|
if c.isAddrVar && c.addrVarKind == compiler.KindWord && !c.isZPPointer {
|
|
if c.pragmaSet.GetPragma("_P_USE_IMMUTABLE_CODE") != "" {
|
|
return nil, fmt.Errorf("POKEW: USE_IMMUTABLE_CODE pragma set but construct requires self-modifying code (consider using zero page word for address)")
|
|
}
|
|
}
|
|
|
|
// Case 1: ZP pointer with offset
|
|
if c.isZPPointer {
|
|
// Load offset into Y
|
|
if c.hasOffset {
|
|
if c.isOffsetVar {
|
|
asm = append(asm, fmt.Sprintf("\tldy %s", c.offsetVarName))
|
|
} else {
|
|
asm = append(asm, fmt.Sprintf("\tldy #%d", c.offsetValue))
|
|
}
|
|
} else {
|
|
asm = append(asm, "\tldy #0")
|
|
}
|
|
|
|
// Store low byte
|
|
if c.isValueVar {
|
|
asm = append(asm, fmt.Sprintf("\tlda %s", c.valueVarName))
|
|
} else {
|
|
asm = append(asm, fmt.Sprintf("\tlda #$%02x", uint8(c.valueLiteral&0xFF)))
|
|
}
|
|
asm = append(asm, fmt.Sprintf("\tsta (%s),y", c.addrVarName))
|
|
|
|
// Increment Y and store high byte
|
|
asm = append(asm, "\tiny")
|
|
if c.isValueVar {
|
|
asm = append(asm, fmt.Sprintf("\tlda %s+1", c.valueVarName))
|
|
} else {
|
|
asm = append(asm, fmt.Sprintf("\tlda #$%02x", uint8((c.valueLiteral>>8)&0xFF)))
|
|
}
|
|
asm = append(asm, fmt.Sprintf("\tsta (%s),y", c.addrVarName))
|
|
return asm, nil
|
|
}
|
|
|
|
// Case 2: Byte variable (zero-page indexed addressing)
|
|
if c.isAddrVar && c.addrVarKind == compiler.KindByte {
|
|
asm = append(asm, fmt.Sprintf("\tldx %s", c.addrVarName))
|
|
|
|
// Store low byte
|
|
if c.isValueVar {
|
|
asm = append(asm, fmt.Sprintf("\tlda %s", c.valueVarName))
|
|
} else {
|
|
asm = append(asm, fmt.Sprintf("\tlda #$%02x", uint8(c.valueLiteral&0xFF)))
|
|
}
|
|
asm = append(asm, "\tsta $00,x")
|
|
|
|
// Increment X and store high byte
|
|
asm = append(asm, "\tinx")
|
|
if c.isValueVar {
|
|
asm = append(asm, fmt.Sprintf("\tlda %s+1", c.valueVarName))
|
|
} else {
|
|
asm = append(asm, fmt.Sprintf("\tlda #$%02x", uint8((c.valueLiteral>>8)&0xFF)))
|
|
}
|
|
asm = append(asm, "\tsta $00,x")
|
|
return asm, nil
|
|
}
|
|
|
|
// Case 3: Word variable (self-modifying code)
|
|
if c.isAddrVar && c.addrVarKind == compiler.KindWord {
|
|
label1 := ctx.GeneralStack.Push()
|
|
label2 := ctx.GeneralStack.Push()
|
|
|
|
// Setup both labels with base address
|
|
asm = append(asm, fmt.Sprintf("\tlda %s", c.addrVarName))
|
|
asm = append(asm, fmt.Sprintf("\tsta %s+1", label1))
|
|
asm = append(asm, fmt.Sprintf("\tsta %s+1", label2))
|
|
asm = append(asm, fmt.Sprintf("\tlda %s+1", c.addrVarName))
|
|
asm = append(asm, fmt.Sprintf("\tsta %s+2", label1))
|
|
asm = append(asm, fmt.Sprintf("\tsta %s+2", label2))
|
|
|
|
// Store low byte
|
|
if c.isValueVar {
|
|
asm = append(asm, fmt.Sprintf("\tlda %s", c.valueVarName))
|
|
} else {
|
|
asm = append(asm, fmt.Sprintf("\tlda #$%02x", uint8(c.valueLiteral&0xFF)))
|
|
}
|
|
asm = append(asm, label1)
|
|
asm = append(asm, "\tsta $ffff")
|
|
|
|
// Increment address in label2
|
|
asm = append(asm, fmt.Sprintf("\tinc %s+1", label2))
|
|
asm = append(asm, fmt.Sprintf("\tbne %s", label2))
|
|
asm = append(asm, fmt.Sprintf("\tinc %s+2", label2))
|
|
|
|
// Store high byte
|
|
asm = append(asm, label2)
|
|
if c.isValueVar {
|
|
asm = append(asm, fmt.Sprintf("\tlda %s+1", c.valueVarName))
|
|
} else {
|
|
asm = append(asm, fmt.Sprintf("\tlda #$%02x", uint8((c.valueLiteral>>8)&0xFF)))
|
|
}
|
|
asm = append(asm, "\tsta $ffff")
|
|
return asm, nil
|
|
}
|
|
|
|
// Case 4: Expression/constant address (direct addressing)
|
|
if c.isValueVar {
|
|
asm = append(asm, fmt.Sprintf("\tlda %s", c.valueVarName))
|
|
asm = append(asm, fmt.Sprintf("\tsta %d", c.addrValue))
|
|
asm = append(asm, fmt.Sprintf("\tlda %s+1", c.valueVarName))
|
|
asm = append(asm, fmt.Sprintf("\tsta %d", c.addrValue+1))
|
|
} else {
|
|
asm = append(asm, fmt.Sprintf("\tlda #$%02x", uint8(c.valueLiteral&0xFF)))
|
|
asm = append(asm, fmt.Sprintf("\tsta %d", c.addrValue))
|
|
asm = append(asm, fmt.Sprintf("\tlda #$%02x", uint8((c.valueLiteral>>8)&0xFF)))
|
|
asm = append(asm, fmt.Sprintf("\tsta %d", c.addrValue+1))
|
|
}
|
|
|
|
return asm, nil
|
|
}
|
|
|
|
// parsePOKEWOffset extracts offset from syntax like "var[offset]"
|
|
// Returns (base, offset) where offset is empty if no brackets found
|
|
func parsePOKEWOffset(param string) (base string, offset string) {
|
|
openBracket := strings.IndexByte(param, '[')
|
|
closeBracket := strings.IndexByte(param, ']')
|
|
|
|
if openBracket == -1 || closeBracket == -1 {
|
|
return param, ""
|
|
}
|
|
|
|
if closeBracket <= openBracket || closeBracket != len(param)-1 {
|
|
return param, ""
|
|
}
|
|
|
|
base = param[:openBracket]
|
|
offset = param[openBracket+1 : closeBracket]
|
|
return base, offset
|
|
}
|