Aw, no one's even looked at my lovely macros! Very well, I'll take my cue from these other posts and inflict them anyway
; Garth Wilson's 6502 Structure Macros
; - reference: http://wilsonminesco.com/StructureMacros/index.html
; by Anton Treuenfels
; first created: 12/03/12
; last revised: 12/28/12
; - externally these versions behave the same way as GWilson's
; - internally these versions are modified for use with HXA65x assemblers
; - additional modifications:
; - changed BRA (65C02) to JMP (6502) where BRA used
; - changed REPEAT to REPEAT_ to avoid built-in pseudo op name conflict
; - added do-nothing CASE_ELSE macro (see CASE structure notes)
; INCLUDE this file to use these macros
; -------------------------------
.if ver() < $0191
.fatal "HXA version 0.191 or higher required"
.endif
.readonce
; -------------------------------
; 51 macros:
; IF_EQ
; IF_ZERO
; IF_NEQ
; IF_NOT_ZERO
; IF_PLUS
; IF_MINUS
; IF_NEG
; IF_C_SET
; IF_C_CLR
; IF_V_SET
; IF_V_CLR
; IF_GE ; These two should refer
; IF_LT ; to the C flag.
; ELSE_
; END_IF
;
; BEGIN
; WHILE_EQ
; WHILE_ZERO
; WHILE_NOT_ZERO
; WHILE_NEQ
; WHILE_PLUS
; WHILE_MINUS
; WHILE_NEG
; WHILE_C_CLR
; WHILE_LT
; WHILE_C_SET
; WHILE_GE
; WHILE_V_CLR
; WHILE_V_SET
; REPEAT
; AGAIN
; UNTIL_EQ
; UNTIL_ZERO
; UNTIL_NEQ
; UNTIL_NOT_ZERO
; UNTIL_PLUS
; UNTIL_MINUS
; UNTIL_NEG
; UNTIL_C_CLR
; UNTIL_LT
; UNTIL_C_SET
; UNTIL_GE
; UNTIL_V_CLR
; UNTIL_V_SET
;
; CASE
; CASE_OF
; END_OF
; CASE_ELSE
; END_CASE
;
; FOR
; NEXT
; -------------------------------
; - GWilson's macros dynamically manipulate the program counter
; in order to make sure control transfers happen properly
; - these versions instead use dynamically generated labels
; to let HXA handle control transfers properly at assembly time
; - GWilson's macros "fake" a stack (used to make sure nested
; control structures unwind properly) by re-defining the
; contents of certain numeric labels in a particular order
; - these versions instead "fake" a stack using a single string,
; adding and taking away labels from one end
; the basic approach here (aka the "trick") makes use of some of HXA's features:
; - first, because all labels are sequences of characters,
; they themselves are strings, and can be manipulated as strings:
; - 1) we can create strings on the fly and,
; - 2) we can create strings which have the form of labels, and
; - 3) we can store and recall them to and from variable string labels, and
; - 4) a variable string label used in a string expression evaluates to its contents
; - second, HXA's ".putbacks" pseudo op evaluates its argument as a string expression
; and then "puts back" the result onto the input stream
; - the evaluated string expression thus becomes the next input line
; - so: we can create, store, recall, manipulate and use labels at will
; -------------------------------
; "housekeeping" macros
; -------------------------------
; dynamic labels have the form "__xxxxx", where "xxxxx"
; is an ever-increasing number starting at ten thousand (10000)
; - the form is a "global numeric" label having global scope
; (variable, local and anonymous won't do for this purpose)
; - HXA will assign the current value of the program counter
; to them when they appear on an input line by themselves
; internal tracking variables (don't access directly!)
; - labels beginning with "]" are "variable"
; and can be assigned new values at any time
; - labels ending in "$" are string values,
; otherwise they are numeric (integer, actually)
]DYNCNT = 9999 ; incremented for each new label
DYNLEN = 7 ; the length of a dynamic label
]DYNSTK$ = "" ; the label "stack"
]DYNLBL$ = "" ; the current dynamic label name
]DYNTMP$ = "" ; temporary storage for label name
; create the next dynamic label
; - increment count, then convert to string and add underscores
.macro dyn.makelabel
]DYNCNT = ]DYNCNT+1
]DYNLBL$ = "__" str$(]DYNCNT)
.endm
; stack the current dynamic label
; - "pushes" by concatenation
; - max depth is at least int(2000/DYNLEN) (MS-DOS version)
.macro dyn.pushlabel
]DYNSTK$ = ]DYNLBL$ ]DYNSTK$
.endm
; unstack the top dynamic label to a named label
; - up to 90000 dynamic labels can be generated before
; their length changes and this code won't work
.macro dyn.poplabel
.if !]DYNSTK$ ; stack empty?
.fatal "Label stack empty"
.else
]DYNLBL$ = mid$( ]DYNSTK$, 1, DYNLEN ) ; copy top label to current label
]DYNSTK$ = mid$( ]DYNSTK$, DYNLEN+1 ) ; "pop" it from "stack"
.endif
.endm
; -------------------------------
; push back 6502 branch instruction with (implied) label argument to input stream
; - "?mnemonic __xxxxx" will become next input line
.macro dyn.ins.bra, ?mnemonic
.putbacks "?mnemonic " ]DYNLBL$
.endm
; push back (implied) label argument to input stream
; - "__xxxxx" will become next input line
.macro dyn.ins.labelhere
.putbacks ]DYNLBL$
.endm
; -------------------------------
; +--------------------------+
; | IF_xx...ELSE_...END_IF |
; +--------------------------+
IF_EQ: MACRO
dyn.makelabel ; make a new label for end of TRUE branch
dyn.ins.bra BNE ; write a forward branch to it
dyn.pushlabel ; save it for future reference
ENDM
;----------------
ELSE_: MACRO ; Don't forget the "_" in "ELSE_" ! ! ! (to differentiate from the assembler's conditional)
dyn.makelabel ; make a new label for end of FALSE branch
dyn.ins.bra JMP ; write a forward branch to it
]DYNTMP$ = ]DYNLBL$ ; save new label for a moment
dyn.poplabel ; get label for end of TRUE branch back
dyn.ins.labelhere ; mark this spot
]DYNLBL$ = ]DYNTMP$ ; restore new label
dyn.pushlabel ; save it for future reference
ENDM
;----------------
END_IF: MACRO ; The similar directive in the HXA assembler is ENDIF, so there's no mix-up here.
dyn.poplabel ; get label for end of "IF__" block back (TRUE or FALSE branch; doesn't matter)
dyn.ins.labelhere ; mark this spot (no code generated)
ENDM
;----------------
IF_ZERO: MACRO ; same as IF_EQ
IF_EQ
ENDM
;----------------
IF_NEQ: MACRO
dyn.makelabel ; make a new label for end of TRUE branch
dyn.ins.bra BEQ ; write a forward branch to it
dyn.pushlabel ; stack it
ENDM
;----------------
IF_NOT_ZERO: MACRO ; same as IF_NEQ
IF_NEQ
ENDM
;----------------
IF_PLUS MACRO ; uses N flag
dyn.makelabel ; make a new label for end of TRUE branch
dyn.ins.bra BMI ; write a forward branch to it
dyn.pushlabel ; stack it
ENDM
;----------------
IF_MINUS: MACRO ; uses N flag
dyn.makelabel ; make a new label for end of TRUE branch
dyn.ins.bra BPL ; write a forward branch to it
dyn.pushlabel ; stack it
ENDM
;----------------
IF_NEG: MACRO ; same as IF_MINUS
IF_MINUS
ENDM
;----------------
IF_C_SET: MACRO
dyn.makelabel ; make a new label for end of TRUE branch
dyn.ins.bra BCC ; write a forward branch to it
dyn.pushlabel ; stack it
ENDM
;----------------
IF_C_CLR: MACRO
dyn.makelabel ; make a new label for end of TRUE branch
dyn.ins.bra BCS ; write a forward branch to it
dyn.pushlabel ; stack it
ENDM
;----------------
IF_GE: MACRO ; same as IF_C_SET
IF_C_SET
ENDM
;----------------
IF_LT: MACRO ; same as IF_C_CLEAR
IF_C_CLR
ENDM
;----------------
IF_V_SET: MACRO
dyn.makelabel ; make a new label for end of TRUE branch
dyn.ins.bra BVC ; write a forward branch to it
dyn.pushlabel ; stack it
ENDM
;----------------
IF_V_CLR: MACRO
dyn.makelabel ; make a new label for end of TRUE branch
dyn.ins.bra BVS ; write a forward branch to it
dyn.pushlabel ; stack it
ENDM
; -------------------------------
; +--------------------------+
; | BEGIN...AGAIN |
; | BEGIN...UNTIL |
; | BEGIN...WHILE...REPEAT |
; +--------------------------+
BEGIN: MACRO ; For use with AGAIN, REPEAT, and any of the UNTIL_xx and WHILE_xx macros.
dyn.makelabel ; make a new label
dyn.ins.labelhere ; use it to mark this spot
dyn.pushlabel ; save it for future reference
ENDM
;----------------
UNTIL_EQ: MACRO ; Continue loop until Z flag is set.
dyn.poplabel ; get BEGIN label back
dyn.ins.bra BNE ; write a backward branch to it
ENDM
;----------------
AGAIN: MACRO ; Continue loop unconditionally. Similar to REPEAT, but not for use with WHILE_xx.
dyn.poplabel ; get BEGIN label back
dyn.ins.bra JMP ; write a backward branch to it
ENDM
;----------------
WHILE_NEQ: MACRO ; Continue while Z flag is clear. For use with BEGIN and REPEAT.
dyn.makelabel ; make a new label for end of REPEAT
dyn.ins.bra BEQ ; write a forward branch to it
dyn.pushlabel ; save it for future reference
ENDM
;----------------
REPEAT_: MACRO ; Similar to AGAIN, but for use with WHILE_xx.
dyn.poplabel ; get back forward WHILE label
]DYNTMP$ = ]DYNLBL$ ; save it for a moment
dyn.poplabel ; get back backward BEGIN label
dyn.ins.bra JMP ; write a backward branch to it
]DYNLBL$ = ]DYNTMP$ ; restore WHILE label
dyn.ins.labelhere ; mark this spot
ENDM
;----------------
WHILE_EQ: MACRO ; Continue while Z flag is set. For use with BEGIN and REPEAT.
dyn.makelabel ; make a new label for end of REPEAT
dyn.ins.bra BNE ; write a forward branch to it
dyn.pushlabel ; save it for future reference
ENDM
;----------------
WHILE_ZERO: MACRO ; same as WHILE_EQ
WHILE_EQ
ENDM
;----------------
WHILE_NOT_ZERO: MACRO ; same as WHILE_NEQ
WHILE_NEQ
ENDM
;----------------
WHILE_MINUS: MACRO ; Continue while N flag is set. For use with BEGIN and REPEAT.
dyn.makelabel ; make a new label for end of REPEAT
dyn.ins.bra BPL ; write a forward branch to it
dyn.pushlabel ; save it for future reference
ENDM
;----------------
WHILE_NEG: MACRO ; same as WHILE_MINUS
WHILE_MINUS
ENDM
;----------------
WHILE_PLUS: MACRO ; Continue while N flag is clear. For use with BEGIN and REPEAT.
dyn.makelabel ; make a new label for end of REPEAT
dyn.ins.bra BMI ; write a forward branch to it
dyn.pushlabel ; save it for future reference
ENDM
;----------------
WHILE_C_SET: MACRO ; Continue while C flag is set. For use with BEGIN and REPEAT.
dyn.makelabel ; make a new label for end of REPEAT
dyn.ins.bra BCC ; write a forward branch to it
dyn.pushlabel ; save it for future reference
ENDM
;----------------
WHILE_GE: MACRO ; same as WHILE_C_SET
WHILE_C_SET
ENDM
;----------------
WHILE_C_CLR: MACRO ; Continue while C flag is clear. For use with BEGIN and REPEAT.
dyn.makelabel ; make a new label for end of REPEAT
dyn.ins.bra BCS ; write a forward branch to it
dyn.pushlabel ; save it for future reference
ENDM
;----------------
WHILE_LT: MACRO ; same as WHILE_C_CLR
WHILE_C_CLR
ENDM
;----------------
WHILE_V_SET: MACRO ; Continue while V flag is set. For use with BEGIN and REPEAT.
dyn.makelabel ; make a new label for end of REPEAT
dyn.ins.bra BVC ; write a forward branch to it
dyn.pushlabel ; save it for future reference
ENDM
;----------------
WHILE_V_CLR: MACRO ; Continue while V flag is clear. For use with BEGIN and REPEAT.
dyn.makelabel ; make a new label for end of REPEAT
dyn.ins.bra BVS ; write a forward branch to it
dyn.pushlabel ; save it for future reference
ENDM
;----------------
UNTIL_ZERO: MACRO ; same as UNTIL_EQ
UNTIL_EQ
ENDM
;----------------
UNTIL_MINUS: MACRO ; Continue loop until N flag is set
dyn.poplabel ; get BEGIN label back
dyn.ins.bra BPL ; write a backward branch to it
ENDM
;----------------
UNTIL_NEG: MACRO ; same as UNTIL_MINUS
UNTIL_MINUS
ENDM
;----------------
UNTIL_PLUS: MACRO ; Continue loop until N flag is clear
dyn.poplabel ; get BEGIN label back
dyn.ins.bra BPL ; write a backward branch to it
ENDM
;----------------
UNTIL_C_SET: MACRO ; Continue loop until C flag is set
dyn.poplabel ; get BEGIN label back
dyn.ins.bra BCC ; write a backward branch to it
ENDM
;----------------
UNTIL_GE: MACRO ; same as UNTIL_C_SET
UNTIL_C_SET
ENDM
;----------------
UNTIL_C_CLR: MACRO ; Continue loop until C flag is clear
dyn.poplabel ; get BEGIN label back
dyn.ins.bra BCC ; write a backward branch to it
ENDM
;----------------
UNTIL_LT: MACRO ; same as UNTIL_C_CLR
UNTIL_C_CLR
ENDM
;----------------
UNTIL_V_SET: MACRO ; Continue loop until V flag is set
dyn.poplabel ; get BEGIN label back
dyn.ins.bra BVC ; write a backward branch to it
ENDM
;----------------
UNTIL_V_CLR: MACRO ; Continue loop until V flag is clear
dyn.poplabel ; get BEGIN label back
dyn.ins.bra BVS ; write a backward branch to it
ENDM
; -------------------------------
; +--------------------+
; | CASE...END_CASE |
; +--------------------+
; For this version using JMPs at the END_OFs, the only places that branch distances might be excessive is the BNEs in CASE_OF,
; and it's pretty unlikey that those would be a problem.
; Nested CASE statements are not permitted; ie, between CASE and END_CASE, you can't have another CASE...
; You can however nest a CASE structure with other types of structures.
]CASINS$ = "" ; CMP, CPX or CPY
]CASEND$ = "" ; label for the end of case structure (END_CASE macro)
; this version behaves much as GWilson's original:
; - the CASE_OF "no match" branch leads to the next END_OF (to just after the "JMP" instruction it writes)
; - if a CASE_OF immediately follows an END_OF all will be well
; - however if code follows an END_OF it will be executed:
; - 1) if not the last END_OF, care must be taken to preserve the register value being compared so the next CASE_OF works
; - 2) if it is the last END_OF, the code amounts to default processing which happens if no CASE_OF is matched
; - unless code follows the last END_OF, the "JMP" instruction it writes is spurious, since it only goes to END_CASE
; - a difference: CASE_ELSE is added, which does nothing but mark that spot in the source code (no object code produced)
; - its purpose is simply to clearly mark the control transfer point of the last CASE_OF (ie., after the last END_OF)
; - a difference: only one CASE_OF..END_OF structure is required (not minimum two)
; - a difference: an unlimited number of CASE_OF..END_OF structures allowed (not maximum ten)
CASE: MACRO ?register
]CASINS$ = upper$("?register") ; determine the comparison instruction to use
.if ]CASINS$ == "ACCUM"
]CASINS$ = "CMP"
.elseif ]CASINS$ == "X_REG"
]CASINS$ = "CPX"
.elseif ]CASINS$ == "Y_REG"
]CASINS$ = "CPY"
.else
.fatal "Register name not recognized: ?register"
.endif
dyn.makelabel ; make a label for END_CASE
]CASEND$ = ]DYNLBL$ ; save it for future reference
ENDM
;----------------
CASE_OF: MACRO ?value
.putbacks ]CASINS$ " #?value" ; write a compare instruction
dyn.makelabel ; make the next "no match" label
dyn.ins.bra BNE ; write a forward branch to it
dyn.pushlabel ; save it for future reference
ENDM
;----------------
END_OF: MACRO
]DYNLBL$ = ]CASEND$ ; get end of case structure label back
dyn.ins.bra JMP ; write a forward branch to it
dyn.poplabel ; get the previous "no match" label back
dyn.ins.labelhere ; mark this spot
ENDM
;----------------
CASE_ELSE MACRO ; does nothing (optional, can be omitted)
ENDM
;----------------
END_CASE: MACRO
]DYNLBL$ = ]CASEND$ ; get end of case structure label back
dyn.ins.labelhere ; mark this spot
ENDM
; -------------------------------
; +----------------+
; | FOR...NEXT |
; +----------------+
; FOR...NEXT below is more of a suggestion of one way to do it than anything. As stated in the
; macros.html page, there are a lot of different possibilities to implement in a FOR...NEXT,
; and it's perhaps not possible to implement them all in the same macros. This pair is for
; when the index begins and ends with constants, and it increments by 1 unless you put something
; between the FOR and NEXT to modify the index variable.
]FORLIM = 0 ; save limit for NEXT macro (scalar, so FOR..NEXT cannot nest)
; example usage:
;
; FOR varname, 1, TO, 1000 ; (Unfotunately HXA macros require commas between the parameters)
; <actions>
; <actions>
; NEXT varname
; NOTE: FOR and NEXT will change the accumulator value (and the status).
FOR: MACRO ?varname, ?index, ?to, ?limit
LDA #<(?index) ; store the starting index value into the index variable
STA ?varname
LDA #>(?index)
STA 1+?varname
.if "?to" != "TO" ; a warning because this value doesn't really matter anyway
.warn "Irregular syntax: ?to"
.endif
]FORLIM = ?limit ; save limit value for NEXT
dyn.makelabel ; make a label for NEXT to come back to
dyn.ins.labelhere ; mark this spot
dyn.pushlabel ; save it for future reference
ENDM
;----------------
NEXT: MACRO ?varname
INC ?varname ; increment the index variable by one
BNE +
INC 1+?varname
+
dyn.poplabel ; get FOR location back
LDA ?varname ; low byte of index variable
CMP #<]FORLIM ; matches low byte of limit ?
dyn.ins.bra BNE ; b:no - back to loop top
LDA 1+?varname ; same for high byte
CMP #>]FORLIM
dyn.ins.bra BNE ; watch the branch distance here !
ENDM ; drops through when loop complete
;----------------
Login
Register
FAQ
Search
Thanks!
).
