linguist/samples/Assembly/macros.inc

BLARGG_MACROS_INCLUDED = 1

; Allows extra error checking with modified version
; of ca65. Otherwise acts like a constant of 0.
ADDR = 0

; Switches to Segment and places Line there.
; Line can be an .align directive, .res, .byte, etc.
; Examples:
; seg_data BSS, .align 256
; seg_data RODATA, {message: .byte "Test",0}
.macro seg_data Segment, Line
	.pushseg
	.segment .string(Segment)
		Line
	.popseg
.endmacro

; Reserves Size bytes in Segment for Name.
; If Size is omitted, reserves one byte.
.macro seg_res Segment, Name, Size
	.ifblank Size
		seg_data Segment, Name: .res 1
	.else
		seg_data Segment, Name: .res Size
	.endif
.endmacro

; Shortcuts for zeropage, bss, and stack
.define zp_res  seg_res ZEROPAGE,
.define nv_res  seg_res NVRAM,
.define bss_res seg_res BSS,
.define sp_res  seg_res STACK,
.define zp_byte zp_res

; Copies byte from Src to Addr. If Src begins with #,
; it sets Addr to the immediate value.
; Out: A = byte copied
; Preserved: X, Y
.macro mov Addr, Src
	lda Src
	sta Addr
.endmacro

; Copies word from Src to Addr. If Src begins with #,
; it sets Addr the immediate value.
; Out: A = high byte of word
; Preserved: X, Y
.macro movw Addr, Src
	.if .match( .left( 1, {Src} ), # )
		lda #<(.right( .tcount( {Src} )-1, {Src} ))
		sta Addr
		lda #>(.right( .tcount( {Src} )-1, {Src} ))
		sta 1+(Addr)
	.else
		lda Src
		sta Addr
		lda 1+(Src)
		sta 1+(Addr)
	.endif
.endmacro

; Increments 16-bit value at Addr.
; Out: EQ/NE based on resulting 16-bit value
; Preserved: A, X, Y
.macro incw Addr
	.local @Skip
	inc Addr
	bne @Skip
	inc 1+(Addr)
@Skip:
.endmacro

; Adds Src to word at Addr.
; Out: A = high byte of result, carry set appropriately
; Preserved: X, Y
.macro addw Addr, Src
	.if .match( .left( 1, {Src} ), # )
		addw_ Addr,(.right( .tcount( {Src} )-1, {Src} ))
	.else
		lda Addr
		clc
		adc Src
		sta Addr
		
		lda 1+(Addr)
		adc 1+(Src)
		sta 1+(Addr)
	.endif
.endmacro
.macro addw_ Addr, Imm
	lda Addr
	clc
	adc #<Imm
	sta Addr
	
	;.if (Imm >> 8) <> 0
		lda 1+(Addr)
		adc #>Imm
		sta 1+(Addr)
	;.else
	;   .local @Skip
	;   bcc @Skip
	;   inc 1+(Addr)
	;@Skip:
	;.endif
.endmacro

; Splits list of words into tables of low and high bytes
; Example: split_words foo, {$1234, $5678}
; expands to:
; foo_l: $34, $78
; foo_h: $12, $56
; foo_count = 2
.macro split_words Label, Words
	.ident (.concat (.string(Label), "_l")): .lobytes Words
	.ident (.concat (.string(Label), "_h")): .hibytes Words
	.ident (.concat (.string(Label), "_count")) = * - .ident (.concat (.string(Label), "_h"))
.endmacro

.macro SELECT Bool, True, False, Extra
	.ifndef Bool
		False Extra
	.elseif Bool <> 0
		True Extra
	.else
		False Extra
	.endif
.endmacro

.macro DEFAULT Name, Value
	.ifndef Name
		Name = Value
	.endif
.endmacro

.ifp02
	; 6502 doesn't define these alternate names
	.define blt bcc
	.define bge bcs
.endif
.define jlt jcc
.define jge jcs

; Jxx Target = Bxx Target, except it can go farther than
; 128 bytes. Implemented via branch around a JMP.

; Don't use ca65's longbranch, because they fail for @labels
;.macpack longbranch

.macro jeq Target
	bne *+5
	jmp Target
.endmacro

.macro jne Target
	beq *+5
	jmp Target
.endmacro

.macro jmi Target
	bpl *+5
	jmp Target
.endmacro

.macro jpl Target
	bmi *+5
	jmp Target
.endmacro

.macro jcs Target
	bcc *+5
	jmp Target
.endmacro

.macro jcc Target
	bcs *+5
	jmp Target
.endmacro

.macro jvs Target
	bvc *+5
	jmp Target
.endmacro

.macro jvc Target
	bvs *+5
	jmp Target
.endmacro


; Passes constant data to routine in addr
; Preserved: A, X, Y
.macro jsr_with_addr routine,data
	.local Addr
	pha
	lda #<Addr
	sta addr
	lda #>Addr
	sta addr+1
	pla
	jsr routine
	seg_data RODATA,{Addr: data}
.endmacro

; Calls routine multiple times, with A having the
; value 'start' the first time, 'start+step' the
; second time, up to 'end' for the last time.
.macro for_loop routine,start,end,step
	.local @for_loop
	lda #start
@for_loop:
	pha
	jsr routine
	pla
	clc
	adc #step
	cmp #<((end)+(step))
	bne @for_loop
.endmacro

; Calls routine n times. The value of A in the routine
; counts from 0 to n-1.
.macro loop_n_times routine,n
	for_loop routine,0,n-1,+1
.endmacro

; Same as for_loop, except uses 16-bit value in YX.
; -256 <= step <= 255
.macro for_loop16 routine,start,end,step
.if (step) < -256 || (step) > 255
	.error "Step must be within -256 to 255"
.endif
	.local @for_loop_skip
	.local @for_loop
	ldy #>(start)
	lda #<(start)
@for_loop:
	tax
	pha
	tya
	pha
	jsr routine
	pla
	tay
	pla
	clc
	adc #step
.if (step) > 0
	bcc @for_loop_skip
	iny
.else
	bcs @for_loop_skip
	dey
.endif
@for_loop_skip:
	cmp #<((end)+(step))
	bne @for_loop
	cpy #>((end)+(step))
	bne @for_loop
.endmacro

; Stores byte at addr
; Preserved: X, Y
.macro setb addr, byte
	lda #byte
	sta addr
.endmacro

; Stores word at addr
; Preserved: X, Y
.macro setw addr, word
	lda #<(word)
	sta addr
	lda #>(word)
	sta addr+1
.endmacro

; Loads XY with 16-bit immediate or value at address
.macro ldxy Arg
	.if .match( .left( 1, {Arg} ), # )
		ldy #<(.right( .tcount( {Arg} )-1, {Arg} ))
		ldx #>(.right( .tcount( {Arg} )-1, {Arg} ))
	.else
		ldy (Arg)
		ldx (Arg)+1
	.endif
.endmacro

; Increments XY as 16-bit register, in CONSTANT time.
; Z flag set based on entire result.
; Preserved: A
; Time: 7 clocks
.macro inxy
	iny ; 2
	beq *+4 ; 3
		; -1
	bne *+3 ; 3
		; -1
	inx ; 2
.endmacro

; Negates A and adds it to operand
.macro subaf Operand
	eor #$FF
	sec
	adc Operand
.endmacro

; Initializes CPU registers to reasonable values
; Preserved: A, Y
.macro init_cpu_regs
	sei
	cld     ; unnecessary on NES, but might help on clone
	ldx #$FF
	txs
	.ifndef BUILD_NSF
		inx
		stx PPUCTRL
	.endif
.endmacro