Apple-2-Tools/apple2-go
1
0
Fork 0
mirror of https://github.com/freewilll/apple2-go.git synced 2024-11-15 20:10:08 +00:00
Code Issues Projects Releases Wiki Activity
ec44175e62
apple2-go/cpu/6502_functional_test.lst

14358 lines
709 KiB
Plaintext
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 1
---------------------------------------------------- 6502_functional_test.a65 ----------------------------------------------------
6102 lines read, no errors in pass 1.
;
; 6 5 0 2 F U N C T I O N A L T E S T
;
; Copyright (C) 2012-2015 Klaus Dormann
;
; This program is free software: you can redistribute it and/or modify
; it under the terms of the GNU General Public License as published by
; the Free Software Foundation, either version 3 of the License, or
; (at your option) any later version.
;
; This program is distributed in the hope that it will be useful,
; but WITHOUT ANY WARRANTY; without even the implied warranty of
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
; GNU General Public License for more details.
;
; You should have received a copy of the GNU General Public License
; along with this program. If not, see <http://www.gnu.org/licenses/>.
; This program is designed to test all opcodes of a 6502 emulator using all
; addressing modes with focus on propper setting of the processor status
; register bits.
;
; version 04-dec-2017
; contact info at http://2m5.de or email K@2m5.de
;
; assembled with AS65 from http://www.kingswood-consulting.co.uk/assemblers/
; command line switches: -l -m -s2 -w -h0
; | | | | no page headers in listing
; | | | wide listing (133 char/col)
; | | write intel hex file instead of binary
; | expand macros in listing
; generate pass2 listing
;
; No IO - should be run from a monitor with access to registers.
; To run load intel hex image with a load command, than alter PC to 400 hex
; (code_segment) and enter a go command.
; Loop on program counter determines error or successful completion of test.
; Check listing for relevant traps (jump/branch *).
; Please note that in early tests some instructions will have to be used before
; they are actually tested!
;
; RESET, NMI or IRQ should not occur and will be trapped if vectors are enabled.
; Tests documented behavior of the original NMOS 6502 only! No unofficial
; opcodes. Additional opcodes of newer versions of the CPU (65C02, 65816) will
; not be tested. Decimal ops will only be tested with valid BCD operands and
; N V Z flags will be ignored.
;
; Debugging hints:
; Most of the code is written sequentially. if you hit a trap, check the
; immediately preceeding code for the instruction to be tested. Results are
; tested first, flags are checked second by pushing them onto the stack and
; pulling them to the accumulator after the result was checked. The "real"
; flags are no longer valid for the tested instruction at this time!
; If the tested instruction was indexed, the relevant index (X or Y) must
; also be checked. Opposed to the flags, X and Y registers are still valid.
;
; versions:
; 28-jul-2012 1st version distributed for testing
; 29-jul-2012 fixed references to location 0, now #0
; added license - GPLv3
; 30-jul-2012 added configuration options
; 01-aug-2012 added trap macro to allow user to change error handling
; 01-dec-2012 fixed trap in branch field must be a branch
; 02-mar-2013 fixed PLA flags not tested
; 19-jul-2013 allowed ROM vectors to be loaded when load_data_direct = 0
; added test sequence check to detect if tests jump their fence
; 23-jul-2013 added RAM integrity check option
; 16-aug-2013 added error report to standard output option
; 13-dec-2014 added binary/decimal opcode table switch test
; 14-dec-2014 improved relative address test
; 23-aug-2015 added option to disable self modifying tests
; 24-aug-2015 all self modifying immediate opcodes now execute in data RAM
; added small branch offset pretest
; 21-oct-2015 added option to disable decimal mode ADC & SBC tests
; 04-dec-2017 fixed BRK only tested with interrupts enabled
; added option to skip the remainder of a failing test
; in report.i65
; C O N F I G U R A T I O N
;ROM_vectors writable (0=no, 1=yes)
;if ROM vectors can not be used interrupts will not be trapped
;as a consequence BRK can not be tested but will be emulated to test RTI
0001 = ROM_vectors = 1
;load_data_direct (0=move from code segment, 1=load directly)
;loading directly is preferred but may not be supported by your platform
;0 produces only consecutive object code, 1 is not suitable for a binary image
0001 = load_data_direct = 1
;I_flag behavior (0=force enabled, 1=force disabled, 2=prohibit change, 3=allow
;change) 2 requires extra code and is not recommended. SEI & CLI can only be
;tested if you allow changing the interrupt status (I_flag = 3)
0003 = I_flag = 3
;configure memory - try to stay away from memory used by the system
;zero_page memory start address, $50 (80) consecutive Bytes required
; add 2 if I_flag = 2
0000 = zero_page = $0
;data_segment memory start address, $6A (106) consecutive Bytes required
0200 = data_segment = $200
if (data_segment & $ff) != 0
ERROR ERROR ERROR low byte of data_segment MUST be $00 !!
endif
;code_segment memory start address, 13kB of consecutive space required
; add 2.5 kB if I_flag = 2
0800 = code_segment = $800
;self modifying code may be disabled to allow running in ROM
;0=part of the code is self modifying and must reside in RAM
;1=tests disabled: branch range
0000 = disable_selfmod = 0
;report errors through I/O channel (0=use standard self trap loops, 1=include
;report.i65 as I/O channel, add 3.5 kB)
0000 = report = 0
;RAM integrity test option. Checks for undesired RAM writes.
;set lowest non RAM or RAM mirror address page (-1=disable, 0=64k, $40=16k)
;leave disabled if a monitor, OS or background interrupt is allowed to alter RAM
ffff = ram_top = -1
;disable test decimal mode ADC & SBC, 0=enable, 1=disable,
;2=disable including decimal flag in processor status
0000 = disable_decimal = 0
noopt ;do not take shortcuts
;macros for error & success traps to allow user modification
;example:
;trap macro
; jsr my_error_handler
; endm
;trap_eq macro
; bne skip\?
; trap ;failed equal (zero)
;skip\?
; endm
;
; my_error_handler should pop the calling address from the stack and report it.
; putting larger portions of code (more than 3 bytes) inside the trap macro
; may lead to branch range problems for some tests.
if report = 0
trap macro
jmp * ;failed anyway
endm
trap_eq macro
beq * ;failed equal (zero)
endm
trap_ne macro
bne * ;failed not equal (non zero)
endm
trap_cs macro
bcs * ;failed carry set
endm
trap_cc macro
bcc * ;failed carry clear
endm
trap_mi macro
bmi * ;failed minus (bit 7 set)
endm
trap_pl macro
bpl * ;failed plus (bit 7 clear)
endm
trap_vs macro
bvs * ;failed overflow set
endm
trap_vc macro
bvc * ;failed overflow clear
endm
; please observe that during the test the stack gets invalidated
; therefore a RTS inside the success macro is not possible
success macro
jmp * ;test passed, no errors
endm
endif
if report = 1
trap macro
jsr report_error
endm
trap_eq macro
bne skip\?
trap ;failed equal (zero)
skip\?
endm
trap_ne macro
beq skip\?
trap ;failed not equal (non zero)
skip\?
endm
trap_cs macro
bcc skip\?
trap ;failed carry set
skip\?
endm
trap_cc macro
bcs skip\?
trap ;failed carry clear
skip\?
endm
trap_mi macro
bpl skip\?
trap ;failed minus (bit 7 set)
skip\?
endm
trap_pl macro
bmi skip\?
trap ;failed plus (bit 7 clear)
skip\?
endm
trap_vs macro
bvc skip\?
trap ;failed overflow set
skip\?
endm
trap_vc macro
bvs skip\?
trap ;failed overflow clear
skip\?
endm
; please observe that during the test the stack gets invalidated
; therefore a RTS inside the success macro is not possible
success macro
jsr report_success
endm
endif
0001 = carry equ %00000001 ;flag bits in status
0002 = zero equ %00000010
0004 = intdis equ %00000100
0008 = decmode equ %00001000
0010 = break equ %00010000
0020 = reserv equ %00100000
0040 = overfl equ %01000000
0080 = minus equ %10000000
0001 = fc equ carry
0002 = fz equ zero
0003 = fzc equ carry+zero
0040 = fv equ overfl
0042 = fvz equ overfl+zero
0080 = fn equ minus
0081 = fnc equ minus+carry
0082 = fnz equ minus+zero
0083 = fnzc equ minus+zero+carry
00c0 = fnv equ minus+overfl
0030 = fao equ break+reserv ;bits always on after PHP, BRK
0034 = fai equ fao+intdis ;+ forced interrupt disable
0038 = faod equ fao+decmode ;+ ignore decimal
003c = faid equ fai+decmode ;+ ignore decimal
00ff = m8 equ $ff ;8 bit mask
00fb = m8i equ $ff&~intdis ;8 bit mask - interrupt disable
;macros to allow masking of status bits.
;masking test of decimal bit
;masking of interrupt enable/disable on load and compare
;masking of always on bits after PHP or BRK (unused & break) on compare
if disable_decimal < 2
if I_flag = 0
load_flag macro
lda #\1&m8i ;force enable interrupts (mask I)
endm
cmp_flag macro
cmp #(\1|fao)&m8i ;I_flag is always enabled + always on bits
endm
eor_flag macro
eor #(\1&m8i|fao) ;mask I, invert expected flags + always on bits
endm
endif
if I_flag = 1
load_flag macro
lda #\1|intdis ;force disable interrupts
endm
cmp_flag macro
cmp #(\1|fai)&m8 ;I_flag is always disabled + always on bits
endm
eor_flag macro
eor #(\1|fai) ;invert expected flags + always on bits + I
endm
endif
if I_flag = 2
load_flag macro
lda #\1
ora flag_I_on ;restore I-flag
and flag_I_off
endm
cmp_flag macro
eor flag_I_on ;I_flag is never changed
cmp #(\1|fao)&m8i ;expected flags + always on bits, mask I
endm
eor_flag macro
eor flag_I_on ;I_flag is never changed
eor #(\1&m8i|fao) ;mask I, invert expected flags + always on bits
endm
endif
if I_flag = 3
load_flag macro
lda #\1 ;allow test to change I-flag (no mask)
endm
cmp_flag macro
cmp #(\1|fao)&m8 ;expected flags + always on bits
endm
eor_flag macro
eor #\1|fao ;invert expected flags + always on bits
endm
endif
else
if I_flag = 0
load_flag macro
lda #\1&m8i ;force enable interrupts (mask I)
endm
cmp_flag macro
ora #decmode ;ignore decimal mode bit
cmp #(\1|faod)&m8i ;I_flag is always enabled + always on bits
endm
eor_flag macro
ora #decmode ;ignore decimal mode bit
eor #(\1&m8i|faod) ;mask I, invert expected flags + always on bits
endm
endif
if I_flag = 1
load_flag macro
lda #\1|intdis ;force disable interrupts
endm
cmp_flag macro
ora #decmode ;ignore decimal mode bit
cmp #(\1|faid)&m8 ;I_flag is always disabled + always on bits
endm
eor_flag macro
ora #decmode ;ignore decimal mode bit
eor #(\1|faid) ;invert expected flags + always on bits + I
endm
endif
if I_flag = 2
load_flag macro
lda #\1
ora flag_I_on ;restore I-flag
and flag_I_off
endm
cmp_flag macro
eor flag_I_on ;I_flag is never changed
ora #decmode ;ignore decimal mode bit
cmp #(\1|faod)&m8i ;expected flags + always on bits, mask I
endm
eor_flag macro
eor flag_I_on ;I_flag is never changed
ora #decmode ;ignore decimal mode bit
eor #(\1&m8i|faod) ;mask I, invert expected flags + always on bits
endm
endif
if I_flag = 3
load_flag macro
lda #\1 ;allow test to change I-flag (no mask)
endm
cmp_flag macro
ora #decmode ;ignore decimal mode bit
cmp #(\1|faod)&m8 ;expected flags + always on bits
endm
eor_flag macro
ora #decmode ;ignore decimal mode bit
eor #\1|faod ;invert expected flags + always on bits
endm
endif
endif
;macros to set (register|memory|zeropage) & status
set_stat macro ;setting flags in the processor status register
load_flag \1
pha ;use stack to load status
plp
endm
set_a macro ;precharging accu & status
load_flag \2
pha ;use stack to load status
lda #\1 ;precharge accu
plp
endm
set_x macro ;precharging index & status
load_flag \2
pha ;use stack to load status
ldx #\1 ;precharge index x
plp
endm
set_y macro ;precharging index & status
load_flag \2
pha ;use stack to load status
ldy #\1 ;precharge index y
plp
endm
set_ax macro ;precharging indexed accu & immediate status
load_flag \2
pha ;use stack to load status
lda \1,x ;precharge accu
plp
endm
set_ay macro ;precharging indexed accu & immediate status
load_flag \2
pha ;use stack to load status
lda \1,y ;precharge accu
plp
endm
set_z macro ;precharging indexed zp & immediate status
load_flag \2
pha ;use stack to load status
lda \1,x ;load to zeropage
sta zpt
plp
endm
set_zx macro ;precharging zp,x & immediate status
load_flag \2
pha ;use stack to load status
lda \1,x ;load to indexed zeropage
sta zpt,x
plp
endm
set_abs macro ;precharging indexed memory & immediate status
load_flag \2
pha ;use stack to load status
lda \1,x ;load to memory
sta abst
plp
endm
set_absx macro ;precharging abs,x & immediate status
load_flag \2
pha ;use stack to load status
lda \1,x ;load to indexed memory
sta abst,x
plp
endm
;macros to test (register|memory|zeropage) & status & (mask)
tst_stat macro ;testing flags in the processor status register
php ;save status
pla ;use stack to retrieve status
pha
cmp_flag \1
trap_ne
plp ;restore status
endm
tst_a macro ;testing result in accu & flags
php ;save flags
cmp #\1 ;test result
trap_ne
pla ;load status
pha
cmp_flag \2
trap_ne
plp ;restore status
endm
tst_x macro ;testing result in x index & flags
php ;save flags
cpx #\1 ;test result
trap_ne
pla ;load status
pha
cmp_flag \2
trap_ne
plp ;restore status
endm
tst_y macro ;testing result in y index & flags
php ;save flags
cpy #\1 ;test result
trap_ne
pla ;load status
pha
cmp_flag \2
trap_ne
plp ;restore status
endm
tst_ax macro ;indexed testing result in accu & flags
php ;save flags
cmp \1,x ;test result
trap_ne
pla ;load status
eor_flag \3
cmp \2,x ;test flags
trap_ne ;
endm
tst_ay macro ;indexed testing result in accu & flags
php ;save flags
cmp \1,y ;test result
trap_ne ;
pla ;load status
eor_flag \3
cmp \2,y ;test flags
trap_ne
endm
tst_z macro ;indexed testing result in zp & flags
php ;save flags
lda zpt
cmp \1,x ;test result
trap_ne
pla ;load status
eor_flag \3
cmp \2,x ;test flags
trap_ne
endm
tst_zx macro ;testing result in zp,x & flags
php ;save flags
lda zpt,x
cmp \1,x ;test result
trap_ne
pla ;load status
eor_flag \3
cmp \2,x ;test flags
trap_ne
endm
tst_abs macro ;indexed testing result in memory & flags
php ;save flags
lda abst
cmp \1,x ;test result
trap_ne
pla ;load status
eor_flag \3
cmp \2,x ;test flags
trap_ne
endm
tst_absx macro ;testing result in abs,x & flags
php ;save flags
lda abst,x
cmp \1,x ;test result
trap_ne
pla ;load status
eor_flag \3
cmp \2,x ;test flags
trap_ne
endm
; RAM integrity test
; verifies that none of the previous tests has altered RAM outside of the
; designated write areas.
; uses zpt word as indirect pointer, zpt+2 word as checksum
if ram_top > -1
check_ram macro
cld
lda #0
sta zpt ;set low byte of indirect pointer
sta zpt+3 ;checksum high byte
if disable_selfmod = 0
sta range_adr ;reset self modifying code
endif
clc
ldx #zp_bss-zero_page ;zeropage - write test area
ccs3\? adc zero_page,x
bcc ccs2\?
inc zpt+3 ;carry to high byte
clc
ccs2\? inx
bne ccs3\?
ldx #hi(abs1) ;set high byte of indirect pointer
stx zpt+1
ldy #lo(abs1) ;data after write & execute test area
ccs5\? adc (zpt),y
bcc ccs4\?
inc zpt+3 ;carry to high byte
clc
ccs4\? iny
bne ccs5\?
inx ;advance RAM high address
stx zpt+1
cpx #ram_top
bne ccs5\?
sta zpt+2 ;checksum low is
cmp ram_chksm ;checksum low expected
trap_ne ;checksum mismatch
lda zpt+3 ;checksum high is
cmp ram_chksm+1 ;checksum high expected
trap_ne ;checksum mismatch
endm
else
check_ram macro
;RAM check disabled - RAM size not set
endm
endif
next_test macro ;make sure, tests don't jump the fence
lda test_case ;previous test
cmp #test_num
trap_ne ;test is out of sequence
test_num = test_num + 1
lda #test_num ;*** next tests' number
sta test_case
;check_ram ;uncomment to find altered RAM after each test
endm
if load_data_direct = 1
data
else
bss ;uninitialized segment, copy of data at end of code!
endif
0000 = org zero_page
;break test interrupt save
0000 : 00 irq_a ds 1 ;a register
0001 : 00 irq_x ds 1 ;x register
if I_flag = 2
;masking for I bit in status
flag_I_on ds 1 ;or mask to load flags
flag_I_off ds 1 ;and mask to load flags
endif
0002 : zpt ;5 bytes store/modify test area
;add/subtract operand generation and result/flag prediction
0002 : 00 adfc ds 1 ;carry flag before op
0003 : 00 ad1 ds 1 ;operand 1 - accumulator
0004 : 00 ad2 ds 1 ;operand 2 - memory / immediate
0005 : 00 adrl ds 1 ;expected result bits 0-7
0006 : 00 adrh ds 1 ;expected result bit 8 (carry)
0007 : 00 adrf ds 1 ;expected flags NV0000ZC (only binary mode)
0008 : 00 sb2 ds 1 ;operand 2 complemented for subtract
0009 : zp_bss
0009 : c3824100 zp1 db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR
000d : 7f zp7f db $7f ;test pattern for compare
;logical zeropage operands
000e : 001f7180 zpOR db 0,$1f,$71,$80 ;test pattern for OR
0012 : 0fff7f80 zpAN db $0f,$ff,$7f,$80 ;test pattern for AND
0016 : ff0f8f8f zpEO db $ff,$0f,$8f,$8f ;test pattern for EOR
;indirect addressing pointers
001a : 1702 ind1 dw abs1 ;indirect pointer to pattern in absolute memory
001c : 1802 dw abs1+1
001e : 1902 dw abs1+2
0020 : 1a02 dw abs1+3
0022 : 1b02 dw abs7f
0024 : 1f01 inw1 dw abs1-$f8 ;indirect pointer for wrap-test pattern
0026 : 0302 indt dw abst ;indirect pointer to store area in absolute memory
0028 : 0402 dw abst+1
002a : 0502 dw abst+2
002c : 0602 dw abst+3
002e : 0b01 inwt dw abst-$f8 ;indirect pointer for wrap-test store
0030 : 4e02 indAN dw absAN ;indirect pointer to AND pattern in absolute memory
0032 : 4f02 dw absAN+1
0034 : 5002 dw absAN+2
0036 : 5102 dw absAN+3
0038 : 5202 indEO dw absEO ;indirect pointer to EOR pattern in absolute memory
003a : 5302 dw absEO+1
003c : 5402 dw absEO+2
003e : 5502 dw absEO+3
0040 : 4a02 indOR dw absOR ;indirect pointer to OR pattern in absolute memory
0042 : 4b02 dw absOR+1
0044 : 4c02 dw absOR+2
0046 : 4d02 dw absOR+3
;add/subtract indirect pointers
0048 : 0302 adi2 dw ada2 ;indirect pointer to operand 2 in absolute memory
004a : 0402 sbi2 dw sba2 ;indirect pointer to complemented operand 2 (SBC)
004c : 0401 adiy2 dw ada2-$ff ;with offset for indirect indexed
004e : 0501 sbiy2 dw sba2-$ff
0050 : zp_bss_end
0200 = org data_segment
0200 : 00 test_case ds 1 ;current test number
0201 : 0000 ram_chksm ds 2 ;checksum for RAM integrity test
;add/subtract operand copy - abs tests write area
0203 : abst ;5 bytes store/modify test area
0203 : 00 ada2 ds 1 ;operand 2
0204 : 00 sba2 ds 1 ;operand 2 complemented for subtract
0205 : 000000 ds 3 ;fill remaining bytes
0208 : data_bss
if load_data_direct = 1
0208 : 2900 ex_andi and #0 ;execute immediate opcodes
020a : 60 rts
020b : 4900 ex_eori eor #0 ;execute immediate opcodes
020d : 60 rts
020e : 0900 ex_orai ora #0 ;execute immediate opcodes
0210 : 60 rts
0211 : 6900 ex_adci adc #0 ;execute immediate opcodes
0213 : 60 rts
0214 : e900 ex_sbci sbc #0 ;execute immediate opcodes
0216 : 60 rts
else
ex_andi ds 3
ex_eori ds 3
ex_orai ds 3
ex_adci ds 3
ex_sbci ds 3
endif
0217 : c3824100 abs1 db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR
021b : 7f abs7f db $7f ;test pattern for compare
;loads
021c : 80800002 fLDx db fn,fn,0,fz ;expected flags for load
;shifts
0220 : rASL ;expected result ASL & ROL -carry
0220 : 86048200 rROL db $86,$04,$82,0 ; "
0224 : 87058301 rROLc db $87,$05,$83,1 ;expected result ROL +carry
0228 : rLSR ;expected result LSR & ROR -carry
0228 : 61412000 rROR db $61,$41,$20,0 ; "
022c : e1c1a080 rRORc db $e1,$c1,$a0,$80 ;expected result ROR +carry
0230 : fASL ;expected flags for shifts
0230 : 81018002 fROL db fnc,fc,fn,fz ;no carry in
0234 : 81018000 fROLc db fnc,fc,fn,0 ;carry in
0238 : fLSR
0238 : 01000102 fROR db fc,0,fc,fz ;no carry in
023c : 81808180 fRORc db fnc,fn,fnc,fn ;carry in
;increments (decrements)
0240 : 7f80ff0001 rINC db $7f,$80,$ff,0,1 ;expected result for INC/DEC
0245 : 0080800200 fINC db 0,fn,fn,fz,0 ;expected flags for INC/DEC
;logical memory operand
024a : 001f7180 absOR db 0,$1f,$71,$80 ;test pattern for OR
024e : 0fff7f80 absAN db $0f,$ff,$7f,$80 ;test pattern for AND
0252 : ff0f8f8f absEO db $ff,$0f,$8f,$8f ;test pattern for EOR
;logical accu operand
0256 : 00f11f00 absORa db 0,$f1,$1f,0 ;test pattern for OR
025a : f0ffffff absANa db $f0,$ff,$ff,$ff ;test pattern for AND
025e : fff0f00f absEOa db $ff,$f0,$f0,$0f ;test pattern for EOR
;logical results
0262 : 00ff7f80 absrlo db 0,$ff,$7f,$80
0266 : 02800080 absflo db fz,fn,0,fn
026a : data_bss_end
code
0800 = org code_segment
0800 : d8 start cld
0801 : a2ff ldx #$ff
0803 : 9a txs
0804 : a900 lda #0 ;*** test 0 = initialize
0806 : 8d0002 sta test_case
0000 = test_num = 0
;stop interrupts before initializing BSS
if I_flag = 1
sei
endif
;initialize I/O for report channel
if report = 1
jsr report_init
endif
;pretest small branch offset
0809 : a205 ldx #5
080b : 4c3308 jmp psb_test
080e : psb_bwok
080e : a005 ldy #5
0810 : d008 bne psb_forw
trap ;branch should be taken
0812 : 4c1208 > jmp * ;failed anyway
0815 : 88 dey ;forward landing zone
0816 : 88 dey
0817 : 88 dey
0818 : 88 dey
0819 : 88 dey
081a : psb_forw
081a : 88 dey
081b : 88 dey
081c : 88 dey
081d : 88 dey
081e : 88 dey
081f : f017 beq psb_fwok
trap ;forward offset
0821 : 4c2108 > jmp * ;failed anyway
0824 : ca dex ;backward landing zone
0825 : ca dex
0826 : ca dex
0827 : ca dex
0828 : ca dex
0829 : psb_back
0829 : ca dex
082a : ca dex
082b : ca dex
082c : ca dex
082d : ca dex
082e : f0de beq psb_bwok
trap ;backward offset
0830 : 4c3008 > jmp * ;failed anyway
0833 : psb_test
0833 : d0f4 bne psb_back
trap ;branch should be taken
0835 : 4c3508 > jmp * ;failed anyway
0838 : psb_fwok
;initialize BSS segment
if load_data_direct != 1
ldx #zp_end-zp_init-1
ld_zp lda zp_init,x
sta zp_bss,x
dex
bpl ld_zp
ldx #data_end-data_init-1
ld_data lda data_init,x
sta data_bss,x
dex
bpl ld_data
if ROM_vectors = 1
ldx #5
ld_vect lda vec_init,x
sta vec_bss,x
dex
bpl ld_vect
endif
endif
;retain status of interrupt flag
if I_flag = 2
php
pla
and #4 ;isolate flag
sta flag_I_on ;or mask
eor #lo(~4) ;reverse
sta flag_I_off ;and mask
endif
;generate checksum for RAM integrity test
if ram_top > -1
lda #0
sta zpt ;set low byte of indirect pointer
sta ram_chksm+1 ;checksum high byte
if disable_selfmod = 0
sta range_adr ;reset self modifying code
endif
clc
ldx #zp_bss-zero_page ;zeropage - write test area
gcs3 adc zero_page,x
bcc gcs2
inc ram_chksm+1 ;carry to high byte
clc
gcs2 inx
bne gcs3
ldx #hi(abs1) ;set high byte of indirect pointer
stx zpt+1
ldy #lo(abs1) ;data after write & execute test area
gcs5 adc (zpt),y
bcc gcs4
inc ram_chksm+1 ;carry to high byte
clc
gcs4 iny
bne gcs5
inx ;advance RAM high address
stx zpt+1
cpx #ram_top
bne gcs5
sta ram_chksm ;checksum complete
endif
next_test
0838 : ad0002 > lda test_case ;previous test
083b : c900 > cmp #test_num
> trap_ne ;test is out of sequence
083d : d0fe > bne * ;failed not equal (non zero)
>
0001 = >test_num = test_num + 1
083f : a901 > lda #test_num ;*** next tests' number
0841 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
if disable_selfmod = 0
;testing relative addressing with BEQ
0844 : a0fe ldy #$fe ;testing maximum range, not -1/-2 (invalid/self adr)
0846 : range_loop
0846 : 88 dey ;next relative address
0847 : 98 tya
0848 : aa tax ;precharge count to end of loop
0849 : 1008 bpl range_fw ;calculate relative address
084b : 18 clc ;avoid branch self or to relative address of branch
084c : 6902 adc #2
084e : ea nop ;offset landing zone - tolerate +/-5 offset to branch
084f : ea nop
0850 : ea nop
0851 : ea nop
0852 : ea nop
0853 : range_fw
0853 : ea nop
0854 : ea nop
0855 : ea nop
0856 : ea nop
0857 : ea nop
0858 : 497f eor #$7f ;complement except sign
085a : 8de608 sta range_adr ;load into test target
085d : a900 lda #0 ;should set zero flag in status register
085f : 4ce508 jmp range_op
0862 : ca dex ; offset landing zone - backward branch too far
0863 : ca dex
0864 : ca dex
0865 : ca dex
0866 : ca dex
;relative address target field with branch under test in the middle
0867 : ca dex ;-128 - max backward
0868 : ca dex
0869 : ca dex
086a : ca dex
086b : ca dex
086c : ca dex
086d : ca dex
086e : ca dex
086f : ca dex ;-120
0870 : ca dex
0871 : ca dex
0872 : ca dex
0873 : ca dex
0874 : ca dex
0875 : ca dex
0876 : ca dex
0877 : ca dex
0878 : ca dex
0879 : ca dex ;-110
087a : ca dex
087b : ca dex
087c : ca dex
087d : ca dex
087e : ca dex
087f : ca dex
0880 : ca dex
0881 : ca dex
0882 : ca dex
0883 : ca dex ;-100
0884 : ca dex
0885 : ca dex
0886 : ca dex
0887 : ca dex
0888 : ca dex
0889 : ca dex
088a : ca dex
088b : ca dex
088c : ca dex
088d : ca dex ;-90
088e : ca dex
088f : ca dex
0890 : ca dex
0891 : ca dex
0892 : ca dex
0893 : ca dex
0894 : ca dex
0895 : ca dex
0896 : ca dex
0897 : ca dex ;-80
0898 : ca dex
0899 : ca dex
089a : ca dex
089b : ca dex
089c : ca dex
089d : ca dex
089e : ca dex
089f : ca dex
08a0 : ca dex
08a1 : ca dex ;-70
08a2 : ca dex
08a3 : ca dex
08a4 : ca dex
08a5 : ca dex
08a6 : ca dex
08a7 : ca dex
08a8 : ca dex
08a9 : ca dex
08aa : ca dex
08ab : ca dex ;-60
08ac : ca dex
08ad : ca dex
08ae : ca dex
08af : ca dex
08b0 : ca dex
08b1 : ca dex
08b2 : ca dex
08b3 : ca dex
08b4 : ca dex
08b5 : ca dex ;-50
08b6 : ca dex
08b7 : ca dex
08b8 : ca dex
08b9 : ca dex
08ba : ca dex
08bb : ca dex
08bc : ca dex
08bd : ca dex
08be : ca dex
08bf : ca dex ;-40
08c0 : ca dex
08c1 : ca dex
08c2 : ca dex
08c3 : ca dex
08c4 : ca dex
08c5 : ca dex
08c6 : ca dex
08c7 : ca dex
08c8 : ca dex
08c9 : ca dex ;-30
08ca : ca dex
08cb : ca dex
08cc : ca dex
08cd : ca dex
08ce : ca dex
08cf : ca dex
08d0 : ca dex
08d1 : ca dex
08d2 : ca dex
08d3 : ca dex ;-20
08d4 : ca dex
08d5 : ca dex
08d6 : ca dex
08d7 : ca dex
08d8 : ca dex
08d9 : ca dex
08da : ca dex
08db : ca dex
08dc : ca dex
08dd : ca dex ;-10
08de : ca dex
08df : ca dex
08e0 : ca dex
08e1 : ca dex
08e2 : ca dex
08e3 : ca dex
08e4 : ca dex ;-3
08e5 : range_op ;test target with zero flag=0, z=1 if previous dex
08e6 = range_adr = *+1 ;modifiable relative address
08e5 : f03e beq *+64 ;+64 if called without modification
08e7 : ca dex ;+0
08e8 : ca dex
08e9 : ca dex
08ea : ca dex
08eb : ca dex
08ec : ca dex
08ed : ca dex
08ee : ca dex
08ef : ca dex
08f0 : ca dex
08f1 : ca dex ;+10
08f2 : ca dex
08f3 : ca dex
08f4 : ca dex
08f5 : ca dex
08f6 : ca dex
08f7 : ca dex
08f8 : ca dex
08f9 : ca dex
08fa : ca dex
08fb : ca dex ;+20
08fc : ca dex
08fd : ca dex
08fe : ca dex
08ff : ca dex
0900 : ca dex
0901 : ca dex
0902 : ca dex
0903 : ca dex
0904 : ca dex
0905 : ca dex ;+30
0906 : ca dex
0907 : ca dex
0908 : ca dex
0909 : ca dex
090a : ca dex
090b : ca dex
090c : ca dex
090d : ca dex
090e : ca dex
090f : ca dex ;+40
0910 : ca dex
0911 : ca dex
0912 : ca dex
0913 : ca dex
0914 : ca dex
0915 : ca dex
0916 : ca dex
0917 : ca dex
0918 : ca dex
0919 : ca dex ;+50
091a : ca dex
091b : ca dex
091c : ca dex
091d : ca dex
091e : ca dex
091f : ca dex
0920 : ca dex
0921 : ca dex
0922 : ca dex
0923 : ca dex ;+60
0924 : ca dex
0925 : ca dex
0926 : ca dex
0927 : ca dex
0928 : ca dex
0929 : ca dex
092a : ca dex
092b : ca dex
092c : ca dex
092d : ca dex ;+70
092e : ca dex
092f : ca dex
0930 : ca dex
0931 : ca dex
0932 : ca dex
0933 : ca dex
0934 : ca dex
0935 : ca dex
0936 : ca dex
0937 : ca dex ;+80
0938 : ca dex
0939 : ca dex
093a : ca dex
093b : ca dex
093c : ca dex
093d : ca dex
093e : ca dex
093f : ca dex
0940 : ca dex
0941 : ca dex ;+90
0942 : ca dex
0943 : ca dex
0944 : ca dex
0945 : ca dex
0946 : ca dex
0947 : ca dex
0948 : ca dex
0949 : ca dex
094a : ca dex
094b : ca dex ;+100
094c : ca dex
094d : ca dex
094e : ca dex
094f : ca dex
0950 : ca dex
0951 : ca dex
0952 : ca dex
0953 : ca dex
0954 : ca dex
0955 : ca dex ;+110
0956 : ca dex
0957 : ca dex
0958 : ca dex
0959 : ca dex
095a : ca dex
095b : ca dex
095c : ca dex
095d : ca dex
095e : ca dex
095f : ca dex ;+120
0960 : ca dex
0961 : ca dex
0962 : ca dex
0963 : ca dex
0964 : ca dex
0965 : ca dex
0966 : ea nop ;offset landing zone - forward branch too far
0967 : ea nop
0968 : ea nop
0969 : ea nop
096a : ea nop
096b : f008 beq range_ok ;+127 - max forward
trap ; bad range
096d : 4c6d09 > jmp * ;failed anyway
0970 : ea nop ;offset landing zone - tolerate +/-5 offset to branch
0971 : ea nop
0972 : ea nop
0973 : ea nop
0974 : ea nop
0975 : range_ok
0975 : ea nop
0976 : ea nop
0977 : ea nop
0978 : ea nop
0979 : ea nop
097a : c000 cpy #0
097c : f003 beq range_end
097e : 4c4608 jmp range_loop
0981 : range_end ;range test successful
endif
next_test
0981 : ad0002 > lda test_case ;previous test
0984 : c901 > cmp #test_num
> trap_ne ;test is out of sequence
0986 : d0fe > bne * ;failed not equal (non zero)
>
0002 = >test_num = test_num + 1
0988 : a902 > lda #test_num ;*** next tests' number
098a : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
;partial test BNE & CMP, CPX, CPY immediate
098d : c001 cpy #1 ;testing BNE true
098f : d003 bne test_bne
trap
0991 : 4c9109 > jmp * ;failed anyway
0994 : test_bne
0994 : a900 lda #0
0996 : c900 cmp #0 ;test compare immediate
trap_ne
0998 : d0fe > bne * ;failed not equal (non zero)
trap_cc
099a : 90fe > bcc * ;failed carry clear
trap_mi
099c : 30fe > bmi * ;failed minus (bit 7 set)
099e : c901 cmp #1
trap_eq
09a0 : f0fe > beq * ;failed equal (zero)
trap_cs
09a2 : b0fe > bcs * ;failed carry set
trap_pl
09a4 : 10fe > bpl * ;failed plus (bit 7 clear)
09a6 : aa tax
09a7 : e000 cpx #0 ;test compare x immediate
trap_ne
09a9 : d0fe > bne * ;failed not equal (non zero)
trap_cc
09ab : 90fe > bcc * ;failed carry clear
trap_mi
09ad : 30fe > bmi * ;failed minus (bit 7 set)
09af : e001 cpx #1
trap_eq
09b1 : f0fe > beq * ;failed equal (zero)
trap_cs
09b3 : b0fe > bcs * ;failed carry set
trap_pl
09b5 : 10fe > bpl * ;failed plus (bit 7 clear)
09b7 : a8 tay
09b8 : c000 cpy #0 ;test compare y immediate
trap_ne
09ba : d0fe > bne * ;failed not equal (non zero)
trap_cc
09bc : 90fe > bcc * ;failed carry clear
trap_mi
09be : 30fe > bmi * ;failed minus (bit 7 set)
09c0 : c001 cpy #1
trap_eq
09c2 : f0fe > beq * ;failed equal (zero)
trap_cs
09c4 : b0fe > bcs * ;failed carry set
trap_pl
09c6 : 10fe > bpl * ;failed plus (bit 7 clear)
next_test
09c8 : ad0002 > lda test_case ;previous test
09cb : c902 > cmp #test_num
> trap_ne ;test is out of sequence
09cd : d0fe > bne * ;failed not equal (non zero)
>
0003 = >test_num = test_num + 1
09cf : a903 > lda #test_num ;*** next tests' number
09d1 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
;testing stack operations PHA PHP PLA PLP
09d4 : a2ff ldx #$ff ;initialize stack
09d6 : 9a txs
09d7 : a955 lda #$55
09d9 : 48 pha
09da : a9aa lda #$aa
09dc : 48 pha
09dd : cdfe01 cmp $1fe ;on stack ?
trap_ne
09e0 : d0fe > bne * ;failed not equal (non zero)
09e2 : ba tsx
09e3 : 8a txa ;overwrite accu
09e4 : c9fd cmp #$fd ;sp decremented?
trap_ne
09e6 : d0fe > bne * ;failed not equal (non zero)
09e8 : 68 pla
09e9 : c9aa cmp #$aa ;successful retreived from stack?
trap_ne
09eb : d0fe > bne * ;failed not equal (non zero)
09ed : 68 pla
09ee : c955 cmp #$55
trap_ne
09f0 : d0fe > bne * ;failed not equal (non zero)
09f2 : cdff01 cmp $1ff ;remains on stack?
trap_ne
09f5 : d0fe > bne * ;failed not equal (non zero)
09f7 : ba tsx
09f8 : e0ff cpx #$ff ;sp incremented?
trap_ne
09fa : d0fe > bne * ;failed not equal (non zero)
next_test
09fc : ad0002 > lda test_case ;previous test
09ff : c903 > cmp #test_num
> trap_ne ;test is out of sequence
0a01 : d0fe > bne * ;failed not equal (non zero)
>
0004 = >test_num = test_num + 1
0a03 : a904 > lda #test_num ;*** next tests' number
0a05 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
;testing branch decisions BPL BMI BVC BVS BCC BCS BNE BEQ
set_stat $ff ;all on
> load_flag $ff
0a08 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0a0a : 48 > pha ;use stack to load status
0a0b : 28 > plp
0a0c : 101a bpl nbr1 ;branches should not be taken
0a0e : 501b bvc nbr2
0a10 : 901c bcc nbr3
0a12 : d01d bne nbr4
0a14 : 3003 bmi br1 ;branches should be taken
trap
0a16 : 4c160a > jmp * ;failed anyway
0a19 : 7003 br1 bvs br2
trap
0a1b : 4c1b0a > jmp * ;failed anyway
0a1e : b003 br2 bcs br3
trap
0a20 : 4c200a > jmp * ;failed anyway
0a23 : f00f br3 beq br4
trap
0a25 : 4c250a > jmp * ;failed anyway
0a28 : nbr1
trap ;previous bpl taken
0a28 : 4c280a > jmp * ;failed anyway
0a2b : nbr2
trap ;previous bvc taken
0a2b : 4c2b0a > jmp * ;failed anyway
0a2e : nbr3
trap ;previous bcc taken
0a2e : 4c2e0a > jmp * ;failed anyway
0a31 : nbr4
trap ;previous bne taken
0a31 : 4c310a > jmp * ;failed anyway
0a34 : 08 br4 php
0a35 : ba tsx
0a36 : e0fe cpx #$fe ;sp after php?
trap_ne
0a38 : d0fe > bne * ;failed not equal (non zero)
0a3a : 68 pla
cmp_flag $ff ;returned all flags on?
0a3b : c9ff > cmp #($ff |fao)&m8 ;expected flags + always on bits
trap_ne
0a3d : d0fe > bne * ;failed not equal (non zero)
0a3f : ba tsx
0a40 : e0ff cpx #$ff ;sp after php?
trap_ne
0a42 : d0fe > bne * ;failed not equal (non zero)
set_stat 0 ;all off
> load_flag 0
0a44 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0a46 : 48 > pha ;use stack to load status
0a47 : 28 > plp
0a48 : 301a bmi nbr11 ;branches should not be taken
0a4a : 701b bvs nbr12
0a4c : b01c bcs nbr13
0a4e : f01d beq nbr14
0a50 : 1003 bpl br11 ;branches should be taken
trap
0a52 : 4c520a > jmp * ;failed anyway
0a55 : 5003 br11 bvc br12
trap
0a57 : 4c570a > jmp * ;failed anyway
0a5a : 9003 br12 bcc br13
trap
0a5c : 4c5c0a > jmp * ;failed anyway
0a5f : d00f br13 bne br14
trap
0a61 : 4c610a > jmp * ;failed anyway
0a64 : nbr11
trap ;previous bmi taken
0a64 : 4c640a > jmp * ;failed anyway
0a67 : nbr12
trap ;previous bvs taken
0a67 : 4c670a > jmp * ;failed anyway
0a6a : nbr13
trap ;previous bcs taken
0a6a : 4c6a0a > jmp * ;failed anyway
0a6d : nbr14
trap ;previous beq taken
0a6d : 4c6d0a > jmp * ;failed anyway
0a70 : 08 br14 php
0a71 : 68 pla
cmp_flag 0 ;flags off except break (pushed by sw) + reserved?
0a72 : c930 > cmp #(0 |fao)&m8 ;expected flags + always on bits
trap_ne
0a74 : d0fe > bne * ;failed not equal (non zero)
;crosscheck flags
set_stat zero
> load_flag zero
0a76 : a902 > lda #zero ;allow test to change I-flag (no mask)
>
0a78 : 48 > pha ;use stack to load status
0a79 : 28 > plp
0a7a : d002 bne brzs1
0a7c : f003 beq brzs2
0a7e : brzs1
trap ;branch zero/non zero
0a7e : 4c7e0a > jmp * ;failed anyway
0a81 : b002 brzs2 bcs brzs3
0a83 : 9003 bcc brzs4
0a85 : brzs3
trap ;branch carry/no carry
0a85 : 4c850a > jmp * ;failed anyway
0a88 : 3002 brzs4 bmi brzs5
0a8a : 1003 bpl brzs6
0a8c : brzs5
trap ;branch minus/plus
0a8c : 4c8c0a > jmp * ;failed anyway
0a8f : 7002 brzs6 bvs brzs7
0a91 : 5003 bvc brzs8
0a93 : brzs7
trap ;branch overflow/no overflow
0a93 : 4c930a > jmp * ;failed anyway
0a96 : brzs8
set_stat carry
> load_flag carry
0a96 : a901 > lda #carry ;allow test to change I-flag (no mask)
>
0a98 : 48 > pha ;use stack to load status
0a99 : 28 > plp
0a9a : f002 beq brcs1
0a9c : d003 bne brcs2
0a9e : brcs1
trap ;branch zero/non zero
0a9e : 4c9e0a > jmp * ;failed anyway
0aa1 : 9002 brcs2 bcc brcs3
0aa3 : b003 bcs brcs4
0aa5 : brcs3
trap ;branch carry/no carry
0aa5 : 4ca50a > jmp * ;failed anyway
0aa8 : 3002 brcs4 bmi brcs5
0aaa : 1003 bpl brcs6
0aac : brcs5
trap ;branch minus/plus
0aac : 4cac0a > jmp * ;failed anyway
0aaf : 7002 brcs6 bvs brcs7
0ab1 : 5003 bvc brcs8
0ab3 : brcs7
trap ;branch overflow/no overflow
0ab3 : 4cb30a > jmp * ;failed anyway
0ab6 : brcs8
set_stat minus
> load_flag minus
0ab6 : a980 > lda #minus ;allow test to change I-flag (no mask)
>
0ab8 : 48 > pha ;use stack to load status
0ab9 : 28 > plp
0aba : f002 beq brmi1
0abc : d003 bne brmi2
0abe : brmi1
trap ;branch zero/non zero
0abe : 4cbe0a > jmp * ;failed anyway
0ac1 : b002 brmi2 bcs brmi3
0ac3 : 9003 bcc brmi4
0ac5 : brmi3
trap ;branch carry/no carry
0ac5 : 4cc50a > jmp * ;failed anyway
0ac8 : 1002 brmi4 bpl brmi5
0aca : 3003 bmi brmi6
0acc : brmi5
trap ;branch minus/plus
0acc : 4ccc0a > jmp * ;failed anyway
0acf : 7002 brmi6 bvs brmi7
0ad1 : 5003 bvc brmi8
0ad3 : brmi7
trap ;branch overflow/no overflow
0ad3 : 4cd30a > jmp * ;failed anyway
0ad6 : brmi8
set_stat overfl
> load_flag overfl
0ad6 : a940 > lda #overfl ;allow test to change I-flag (no mask)
>
0ad8 : 48 > pha ;use stack to load status
0ad9 : 28 > plp
0ada : f002 beq brvs1
0adc : d003 bne brvs2
0ade : brvs1
trap ;branch zero/non zero
0ade : 4cde0a > jmp * ;failed anyway
0ae1 : b002 brvs2 bcs brvs3
0ae3 : 9003 bcc brvs4
0ae5 : brvs3
trap ;branch carry/no carry
0ae5 : 4ce50a > jmp * ;failed anyway
0ae8 : 3002 brvs4 bmi brvs5
0aea : 1003 bpl brvs6
0aec : brvs5
trap ;branch minus/plus
0aec : 4cec0a > jmp * ;failed anyway
0aef : 5002 brvs6 bvc brvs7
0af1 : 7003 bvs brvs8
0af3 : brvs7
trap ;branch overflow/no overflow
0af3 : 4cf30a > jmp * ;failed anyway
0af6 : brvs8
set_stat $ff-zero
> load_flag $ff-zero
0af6 : a9fd > lda #$ff-zero ;allow test to change I-flag (no mask)
>
0af8 : 48 > pha ;use stack to load status
0af9 : 28 > plp
0afa : f002 beq brzc1
0afc : d003 bne brzc2
0afe : brzc1
trap ;branch zero/non zero
0afe : 4cfe0a > jmp * ;failed anyway
0b01 : 9002 brzc2 bcc brzc3
0b03 : b003 bcs brzc4
0b05 : brzc3
trap ;branch carry/no carry
0b05 : 4c050b > jmp * ;failed anyway
0b08 : 1002 brzc4 bpl brzc5
0b0a : 3003 bmi brzc6
0b0c : brzc5
trap ;branch minus/plus
0b0c : 4c0c0b > jmp * ;failed anyway
0b0f : 5002 brzc6 bvc brzc7
0b11 : 7003 bvs brzc8
0b13 : brzc7
trap ;branch overflow/no overflow
0b13 : 4c130b > jmp * ;failed anyway
0b16 : brzc8
set_stat $ff-carry
> load_flag $ff-carry
0b16 : a9fe > lda #$ff-carry ;allow test to change I-flag (no mask)
>
0b18 : 48 > pha ;use stack to load status
0b19 : 28 > plp
0b1a : d002 bne brcc1
0b1c : f003 beq brcc2
0b1e : brcc1
trap ;branch zero/non zero
0b1e : 4c1e0b > jmp * ;failed anyway
0b21 : b002 brcc2 bcs brcc3
0b23 : 9003 bcc brcc4
0b25 : brcc3
trap ;branch carry/no carry
0b25 : 4c250b > jmp * ;failed anyway
0b28 : 1002 brcc4 bpl brcc5
0b2a : 3003 bmi brcc6
0b2c : brcc5
trap ;branch minus/plus
0b2c : 4c2c0b > jmp * ;failed anyway
0b2f : 5002 brcc6 bvc brcc7
0b31 : 7003 bvs brcc8
0b33 : brcc7
trap ;branch overflow/no overflow
0b33 : 4c330b > jmp * ;failed anyway
0b36 : brcc8
set_stat $ff-minus
> load_flag $ff-minus
0b36 : a97f > lda #$ff-minus ;allow test to change I-flag (no mask)
>
0b38 : 48 > pha ;use stack to load status
0b39 : 28 > plp
0b3a : d002 bne brpl1
0b3c : f003 beq brpl2
0b3e : brpl1
trap ;branch zero/non zero
0b3e : 4c3e0b > jmp * ;failed anyway
0b41 : 9002 brpl2 bcc brpl3
0b43 : b003 bcs brpl4
0b45 : brpl3
trap ;branch carry/no carry
0b45 : 4c450b > jmp * ;failed anyway
0b48 : 3002 brpl4 bmi brpl5
0b4a : 1003 bpl brpl6
0b4c : brpl5
trap ;branch minus/plus
0b4c : 4c4c0b > jmp * ;failed anyway
0b4f : 5002 brpl6 bvc brpl7
0b51 : 7003 bvs brpl8
0b53 : brpl7
trap ;branch overflow/no overflow
0b53 : 4c530b > jmp * ;failed anyway
0b56 : brpl8
set_stat $ff-overfl
> load_flag $ff-overfl
0b56 : a9bf > lda #$ff-overfl ;allow test to change I-flag (no mask)
>
0b58 : 48 > pha ;use stack to load status
0b59 : 28 > plp
0b5a : d002 bne brvc1
0b5c : f003 beq brvc2
0b5e : brvc1
trap ;branch zero/non zero
0b5e : 4c5e0b > jmp * ;failed anyway
0b61 : 9002 brvc2 bcc brvc3
0b63 : b003 bcs brvc4
0b65 : brvc3
trap ;branch carry/no carry
0b65 : 4c650b > jmp * ;failed anyway
0b68 : 1002 brvc4 bpl brvc5
0b6a : 3003 bmi brvc6
0b6c : brvc5
trap ;branch minus/plus
0b6c : 4c6c0b > jmp * ;failed anyway
0b6f : 7002 brvc6 bvs brvc7
0b71 : 5003 bvc brvc8
0b73 : brvc7
trap ;branch overflow/no overflow
0b73 : 4c730b > jmp * ;failed anyway
0b76 : brvc8
next_test
0b76 : ad0002 > lda test_case ;previous test
0b79 : c904 > cmp #test_num
> trap_ne ;test is out of sequence
0b7b : d0fe > bne * ;failed not equal (non zero)
>
0005 = >test_num = test_num + 1
0b7d : a905 > lda #test_num ;*** next tests' number
0b7f : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; test PHA does not alter flags or accumulator but PLA does
0b82 : a255 ldx #$55 ;x & y protected
0b84 : a0aa ldy #$aa
set_a 1,$ff ;push
> load_flag $ff
0b86 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0b88 : 48 > pha ;use stack to load status
0b89 : a901 > lda #1 ;precharge accu
0b8b : 28 > plp
0b8c : 48 pha
tst_a 1,$ff
0b8d : 08 > php ;save flags
0b8e : c901 > cmp #1 ;test result
> trap_ne
0b90 : d0fe > bne * ;failed not equal (non zero)
>
0b92 : 68 > pla ;load status
0b93 : 48 > pha
> cmp_flag $ff
0b94 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0b96 : d0fe > bne * ;failed not equal (non zero)
>
0b98 : 28 > plp ;restore status
set_a 0,0
> load_flag 0
0b99 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0b9b : 48 > pha ;use stack to load status
0b9c : a900 > lda #0 ;precharge accu
0b9e : 28 > plp
0b9f : 48 pha
tst_a 0,0
0ba0 : 08 > php ;save flags
0ba1 : c900 > cmp #0 ;test result
> trap_ne
0ba3 : d0fe > bne * ;failed not equal (non zero)
>
0ba5 : 68 > pla ;load status
0ba6 : 48 > pha
> cmp_flag 0
0ba7 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0ba9 : d0fe > bne * ;failed not equal (non zero)
>
0bab : 28 > plp ;restore status
set_a $ff,$ff
> load_flag $ff
0bac : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0bae : 48 > pha ;use stack to load status
0baf : a9ff > lda #$ff ;precharge accu
0bb1 : 28 > plp
0bb2 : 48 pha
tst_a $ff,$ff
0bb3 : 08 > php ;save flags
0bb4 : c9ff > cmp #$ff ;test result
> trap_ne
0bb6 : d0fe > bne * ;failed not equal (non zero)
>
0bb8 : 68 > pla ;load status
0bb9 : 48 > pha
> cmp_flag $ff
0bba : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0bbc : d0fe > bne * ;failed not equal (non zero)
>
0bbe : 28 > plp ;restore status
set_a 1,0
> load_flag 0
0bbf : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0bc1 : 48 > pha ;use stack to load status
0bc2 : a901 > lda #1 ;precharge accu
0bc4 : 28 > plp
0bc5 : 48 pha
tst_a 1,0
0bc6 : 08 > php ;save flags
0bc7 : c901 > cmp #1 ;test result
> trap_ne
0bc9 : d0fe > bne * ;failed not equal (non zero)
>
0bcb : 68 > pla ;load status
0bcc : 48 > pha
> cmp_flag 0
0bcd : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0bcf : d0fe > bne * ;failed not equal (non zero)
>
0bd1 : 28 > plp ;restore status
set_a 0,$ff
> load_flag $ff
0bd2 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0bd4 : 48 > pha ;use stack to load status
0bd5 : a900 > lda #0 ;precharge accu
0bd7 : 28 > plp
0bd8 : 48 pha
tst_a 0,$ff
0bd9 : 08 > php ;save flags
0bda : c900 > cmp #0 ;test result
> trap_ne
0bdc : d0fe > bne * ;failed not equal (non zero)
>
0bde : 68 > pla ;load status
0bdf : 48 > pha
> cmp_flag $ff
0be0 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0be2 : d0fe > bne * ;failed not equal (non zero)
>
0be4 : 28 > plp ;restore status
set_a $ff,0
> load_flag 0
0be5 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0be7 : 48 > pha ;use stack to load status
0be8 : a9ff > lda #$ff ;precharge accu
0bea : 28 > plp
0beb : 48 pha
tst_a $ff,0
0bec : 08 > php ;save flags
0bed : c9ff > cmp #$ff ;test result
> trap_ne
0bef : d0fe > bne * ;failed not equal (non zero)
>
0bf1 : 68 > pla ;load status
0bf2 : 48 > pha
> cmp_flag 0
0bf3 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0bf5 : d0fe > bne * ;failed not equal (non zero)
>
0bf7 : 28 > plp ;restore status
set_a 0,$ff ;pull
> load_flag $ff
0bf8 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0bfa : 48 > pha ;use stack to load status
0bfb : a900 > lda #0 ;precharge accu
0bfd : 28 > plp
0bfe : 68 pla
tst_a $ff,$ff-zero
0bff : 08 > php ;save flags
0c00 : c9ff > cmp #$ff ;test result
> trap_ne
0c02 : d0fe > bne * ;failed not equal (non zero)
>
0c04 : 68 > pla ;load status
0c05 : 48 > pha
> cmp_flag $ff-zero
0c06 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0c08 : d0fe > bne * ;failed not equal (non zero)
>
0c0a : 28 > plp ;restore status
set_a $ff,0
> load_flag 0
0c0b : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0c0d : 48 > pha ;use stack to load status
0c0e : a9ff > lda #$ff ;precharge accu
0c10 : 28 > plp
0c11 : 68 pla
tst_a 0,zero
0c12 : 08 > php ;save flags
0c13 : c900 > cmp #0 ;test result
> trap_ne
0c15 : d0fe > bne * ;failed not equal (non zero)
>
0c17 : 68 > pla ;load status
0c18 : 48 > pha
> cmp_flag zero
0c19 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0c1b : d0fe > bne * ;failed not equal (non zero)
>
0c1d : 28 > plp ;restore status
set_a $fe,$ff
> load_flag $ff
0c1e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0c20 : 48 > pha ;use stack to load status
0c21 : a9fe > lda #$fe ;precharge accu
0c23 : 28 > plp
0c24 : 68 pla
tst_a 1,$ff-zero-minus
0c25 : 08 > php ;save flags
0c26 : c901 > cmp #1 ;test result
> trap_ne
0c28 : d0fe > bne * ;failed not equal (non zero)
>
0c2a : 68 > pla ;load status
0c2b : 48 > pha
> cmp_flag $ff-zero-minus
0c2c : c97d > cmp #($ff-zero-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0c2e : d0fe > bne * ;failed not equal (non zero)
>
0c30 : 28 > plp ;restore status
set_a 0,0
> load_flag 0
0c31 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0c33 : 48 > pha ;use stack to load status
0c34 : a900 > lda #0 ;precharge accu
0c36 : 28 > plp
0c37 : 68 pla
tst_a $ff,minus
0c38 : 08 > php ;save flags
0c39 : c9ff > cmp #$ff ;test result
> trap_ne
0c3b : d0fe > bne * ;failed not equal (non zero)
>
0c3d : 68 > pla ;load status
0c3e : 48 > pha
> cmp_flag minus
0c3f : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0c41 : d0fe > bne * ;failed not equal (non zero)
>
0c43 : 28 > plp ;restore status
set_a $ff,$ff
> load_flag $ff
0c44 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0c46 : 48 > pha ;use stack to load status
0c47 : a9ff > lda #$ff ;precharge accu
0c49 : 28 > plp
0c4a : 68 pla
tst_a 0,$ff-minus
0c4b : 08 > php ;save flags
0c4c : c900 > cmp #0 ;test result
> trap_ne
0c4e : d0fe > bne * ;failed not equal (non zero)
>
0c50 : 68 > pla ;load status
0c51 : 48 > pha
> cmp_flag $ff-minus
0c52 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0c54 : d0fe > bne * ;failed not equal (non zero)
>
0c56 : 28 > plp ;restore status
set_a $fe,0
> load_flag 0
0c57 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0c59 : 48 > pha ;use stack to load status
0c5a : a9fe > lda #$fe ;precharge accu
0c5c : 28 > plp
0c5d : 68 pla
tst_a 1,0
0c5e : 08 > php ;save flags
0c5f : c901 > cmp #1 ;test result
> trap_ne
0c61 : d0fe > bne * ;failed not equal (non zero)
>
0c63 : 68 > pla ;load status
0c64 : 48 > pha
> cmp_flag 0
0c65 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0c67 : d0fe > bne * ;failed not equal (non zero)
>
0c69 : 28 > plp ;restore status
0c6a : e055 cpx #$55 ;x & y unchanged?
trap_ne
0c6c : d0fe > bne * ;failed not equal (non zero)
0c6e : c0aa cpy #$aa
trap_ne
0c70 : d0fe > bne * ;failed not equal (non zero)
next_test
0c72 : ad0002 > lda test_case ;previous test
0c75 : c905 > cmp #test_num
> trap_ne ;test is out of sequence
0c77 : d0fe > bne * ;failed not equal (non zero)
>
0006 = >test_num = test_num + 1
0c79 : a906 > lda #test_num ;*** next tests' number
0c7b : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; partial pretest EOR #
set_a $3c,0
> load_flag 0
0c7e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0c80 : 48 > pha ;use stack to load status
0c81 : a93c > lda #$3c ;precharge accu
0c83 : 28 > plp
0c84 : 49c3 eor #$c3
tst_a $ff,fn
0c86 : 08 > php ;save flags
0c87 : c9ff > cmp #$ff ;test result
> trap_ne
0c89 : d0fe > bne * ;failed not equal (non zero)
>
0c8b : 68 > pla ;load status
0c8c : 48 > pha
> cmp_flag fn
0c8d : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0c8f : d0fe > bne * ;failed not equal (non zero)
>
0c91 : 28 > plp ;restore status
set_a $c3,0
> load_flag 0
0c92 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0c94 : 48 > pha ;use stack to load status
0c95 : a9c3 > lda #$c3 ;precharge accu
0c97 : 28 > plp
0c98 : 49c3 eor #$c3
tst_a 0,fz
0c9a : 08 > php ;save flags
0c9b : c900 > cmp #0 ;test result
> trap_ne
0c9d : d0fe > bne * ;failed not equal (non zero)
>
0c9f : 68 > pla ;load status
0ca0 : 48 > pha
> cmp_flag fz
0ca1 : c932 > cmp #(fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0ca3 : d0fe > bne * ;failed not equal (non zero)
>
0ca5 : 28 > plp ;restore status
next_test
0ca6 : ad0002 > lda test_case ;previous test
0ca9 : c906 > cmp #test_num
> trap_ne ;test is out of sequence
0cab : d0fe > bne * ;failed not equal (non zero)
>
0007 = >test_num = test_num + 1
0cad : a907 > lda #test_num ;*** next tests' number
0caf : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; PC modifying instructions except branches (NOP, JMP, JSR, RTS, BRK, RTI)
; testing NOP
0cb2 : a224 ldx #$24
0cb4 : a042 ldy #$42
set_a $18,0
> load_flag 0
0cb6 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0cb8 : 48 > pha ;use stack to load status
0cb9 : a918 > lda #$18 ;precharge accu
0cbb : 28 > plp
0cbc : ea nop
tst_a $18,0
0cbd : 08 > php ;save flags
0cbe : c918 > cmp #$18 ;test result
> trap_ne
0cc0 : d0fe > bne * ;failed not equal (non zero)
>
0cc2 : 68 > pla ;load status
0cc3 : 48 > pha
> cmp_flag 0
0cc4 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0cc6 : d0fe > bne * ;failed not equal (non zero)
>
0cc8 : 28 > plp ;restore status
0cc9 : e024 cpx #$24
trap_ne
0ccb : d0fe > bne * ;failed not equal (non zero)
0ccd : c042 cpy #$42
trap_ne
0ccf : d0fe > bne * ;failed not equal (non zero)
0cd1 : a2db ldx #$db
0cd3 : a0bd ldy #$bd
set_a $e7,$ff
> load_flag $ff
0cd5 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0cd7 : 48 > pha ;use stack to load status
0cd8 : a9e7 > lda #$e7 ;precharge accu
0cda : 28 > plp
0cdb : ea nop
tst_a $e7,$ff
0cdc : 08 > php ;save flags
0cdd : c9e7 > cmp #$e7 ;test result
> trap_ne
0cdf : d0fe > bne * ;failed not equal (non zero)
>
0ce1 : 68 > pla ;load status
0ce2 : 48 > pha
> cmp_flag $ff
0ce3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0ce5 : d0fe > bne * ;failed not equal (non zero)
>
0ce7 : 28 > plp ;restore status
0ce8 : e0db cpx #$db
trap_ne
0cea : d0fe > bne * ;failed not equal (non zero)
0cec : c0bd cpy #$bd
trap_ne
0cee : d0fe > bne * ;failed not equal (non zero)
next_test
0cf0 : ad0002 > lda test_case ;previous test
0cf3 : c907 > cmp #test_num
> trap_ne ;test is out of sequence
0cf5 : d0fe > bne * ;failed not equal (non zero)
>
0008 = >test_num = test_num + 1
0cf7 : a908 > lda #test_num ;*** next tests' number
0cf9 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; jump absolute
set_stat $0
> load_flag $0
0cfc : a900 > lda #$0 ;allow test to change I-flag (no mask)
>
0cfe : 48 > pha ;use stack to load status
0cff : 28 > plp
0d00 : a946 lda #'F'
0d02 : a241 ldx #'A'
0d04 : a052 ldy #'R' ;N=0, V=0, Z=0, C=0
0d06 : 4cef3a jmp test_far
0d09 : ea nop
0d0a : ea nop
trap_ne ;runover protection
0d0b : d0fe > bne * ;failed not equal (non zero)
0d0d : e8 inx
0d0e : e8 inx
0d0f : far_ret
trap_eq ;returned flags OK?
0d0f : f0fe > beq * ;failed equal (zero)
trap_pl
0d11 : 10fe > bpl * ;failed plus (bit 7 clear)
trap_cc
0d13 : 90fe > bcc * ;failed carry clear
trap_vc
0d15 : 50fe > bvc * ;failed overflow clear
0d17 : c9ec cmp #('F'^$aa) ;returned registers OK?
trap_ne
0d19 : d0fe > bne * ;failed not equal (non zero)
0d1b : e042 cpx #('A'+1)
trap_ne
0d1d : d0fe > bne * ;failed not equal (non zero)
0d1f : c04f cpy #('R'-3)
trap_ne
0d21 : d0fe > bne * ;failed not equal (non zero)
0d23 : ca dex
0d24 : c8 iny
0d25 : c8 iny
0d26 : c8 iny
0d27 : 49aa eor #$aa ;N=0, V=1, Z=0, C=1
0d29 : 4c320d jmp test_near
0d2c : ea nop
0d2d : ea nop
trap_ne ;runover protection
0d2e : d0fe > bne * ;failed not equal (non zero)
0d30 : e8 inx
0d31 : e8 inx
0d32 : test_near
trap_eq ;passed flags OK?
0d32 : f0fe > beq * ;failed equal (zero)
trap_mi
0d34 : 30fe > bmi * ;failed minus (bit 7 set)
trap_cc
0d36 : 90fe > bcc * ;failed carry clear
trap_vc
0d38 : 50fe > bvc * ;failed overflow clear
0d3a : c946 cmp #'F' ;passed registers OK?
trap_ne
0d3c : d0fe > bne * ;failed not equal (non zero)
0d3e : e041 cpx #'A'
trap_ne
0d40 : d0fe > bne * ;failed not equal (non zero)
0d42 : c052 cpy #'R'
trap_ne
0d44 : d0fe > bne * ;failed not equal (non zero)
next_test
0d46 : ad0002 > lda test_case ;previous test
0d49 : c908 > cmp #test_num
> trap_ne ;test is out of sequence
0d4b : d0fe > bne * ;failed not equal (non zero)
>
0009 = >test_num = test_num + 1
0d4d : a909 > lda #test_num ;*** next tests' number
0d4f : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; jump indirect
set_stat 0
> load_flag 0
0d52 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0d54 : 48 > pha ;use stack to load status
0d55 : 28 > plp
0d56 : a949 lda #'I'
0d58 : a24e ldx #'N'
0d5a : a044 ldy #'D' ;N=0, V=0, Z=0, C=0
0d5c : 6c1e3b jmp (ptr_tst_ind)
0d5f : ea nop
trap_ne ;runover protection
0d60 : d0fe > bne * ;failed not equal (non zero)
0d62 : 88 dey
0d63 : 88 dey
0d64 : ind_ret
0d64 : 08 php ;either SP or Y count will fail, if we do not hit
0d65 : 88 dey
0d66 : 88 dey
0d67 : 88 dey
0d68 : 28 plp
trap_eq ;returned flags OK?
0d69 : f0fe > beq * ;failed equal (zero)
trap_pl
0d6b : 10fe > bpl * ;failed plus (bit 7 clear)
trap_cc
0d6d : 90fe > bcc * ;failed carry clear
trap_vc
0d6f : 50fe > bvc * ;failed overflow clear
0d71 : c9e3 cmp #('I'^$aa) ;returned registers OK?
trap_ne
0d73 : d0fe > bne * ;failed not equal (non zero)
0d75 : e04f cpx #('N'+1)
trap_ne
0d77 : d0fe > bne * ;failed not equal (non zero)
0d79 : c03e cpy #('D'-6)
trap_ne
0d7b : d0fe > bne * ;failed not equal (non zero)
0d7d : ba tsx ;SP check
0d7e : e0ff cpx #$ff
trap_ne
0d80 : d0fe > bne * ;failed not equal (non zero)
next_test
0d82 : ad0002 > lda test_case ;previous test
0d85 : c909 > cmp #test_num
> trap_ne ;test is out of sequence
0d87 : d0fe > bne * ;failed not equal (non zero)
>
000a = >test_num = test_num + 1
0d89 : a90a > lda #test_num ;*** next tests' number
0d8b : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; jump subroutine & return from subroutine
set_stat 0
> load_flag 0
0d8e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0d90 : 48 > pha ;use stack to load status
0d91 : 28 > plp
0d92 : a94a lda #'J'
0d94 : a253 ldx #'S'
0d96 : a052 ldy #'R' ;N=0, V=0, Z=0, C=0
0d98 : 205d3b jsr test_jsr
0d9a = jsr_ret = *-1 ;last address of jsr = return address
0d9b : 08 php ;either SP or Y count will fail, if we do not hit
0d9c : 88 dey
0d9d : 88 dey
0d9e : 88 dey
0d9f : 28 plp
trap_eq ;returned flags OK?
0da0 : f0fe > beq * ;failed equal (zero)
trap_pl
0da2 : 10fe > bpl * ;failed plus (bit 7 clear)
trap_cc
0da4 : 90fe > bcc * ;failed carry clear
trap_vc
0da6 : 50fe > bvc * ;failed overflow clear
0da8 : c9e0 cmp #('J'^$aa) ;returned registers OK?
trap_ne
0daa : d0fe > bne * ;failed not equal (non zero)
0dac : e054 cpx #('S'+1)
trap_ne
0dae : d0fe > bne * ;failed not equal (non zero)
0db0 : c04c cpy #('R'-6)
trap_ne
0db2 : d0fe > bne * ;failed not equal (non zero)
0db4 : ba tsx ;sp?
0db5 : e0ff cpx #$ff
trap_ne
0db7 : d0fe > bne * ;failed not equal (non zero)
next_test
0db9 : ad0002 > lda test_case ;previous test
0dbc : c90a > cmp #test_num
> trap_ne ;test is out of sequence
0dbe : d0fe > bne * ;failed not equal (non zero)
>
000b = >test_num = test_num + 1
0dc0 : a90b > lda #test_num ;*** next tests' number
0dc2 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; break & return from interrupt
if ROM_vectors = 1
load_flag 0 ;with interrupts enabled if allowed!
0dc5 : a900 > lda #0 ;allow test to change I-flag (no mask)
0dc7 : 48 pha
0dc8 : a942 lda #'B'
0dca : a252 ldx #'R'
0dcc : a04b ldy #'K'
0dce : 28 plp ;N=0, V=0, Z=0, C=0
0dcf : 00 brk
else
lda #hi brk_ret0 ;emulated break
pha
lda #lo brk_ret0
pha
load_flag fao ;set break & unused on stack
pha
load_flag intdis ;during interrupt
pha
lda #'B'
ldx #'R'
ldy #'K'
plp ;N=0, V=0, Z=0, C=0
jmp irq_trap
endif
0dd0 : 88 dey ;should not be executed
0dd1 : brk_ret0 ;address of break return
0dd1 : 08 php ;either SP or Y count will fail, if we do not hit
0dd2 : 88 dey
0dd3 : 88 dey
0dd4 : 88 dey
0dd5 : c9e8 cmp #'B'^$aa ;returned registers OK?
;the IRQ vector was never executed if A & X stay unmodified
trap_ne
0dd7 : d0fe > bne * ;failed not equal (non zero)
0dd9 : e053 cpx #'R'+1
trap_ne
0ddb : d0fe > bne * ;failed not equal (non zero)
0ddd : c045 cpy #'K'-6
trap_ne
0ddf : d0fe > bne * ;failed not equal (non zero)
0de1 : 68 pla ;returned flags OK (unchanged)?
cmp_flag 0
0de2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
trap_ne
0de4 : d0fe > bne * ;failed not equal (non zero)
0de6 : ba tsx ;sp?
0de7 : e0ff cpx #$ff
trap_ne
0de9 : d0fe > bne * ;failed not equal (non zero)
if ROM_vectors = 1
load_flag $ff ;with interrupts disabled if allowed!
0deb : a9ff > lda #$ff ;allow test to change I-flag (no mask)
0ded : 48 pha
0dee : a9bd lda #$ff-'B'
0df0 : a2ad ldx #$ff-'R'
0df2 : a0b4 ldy #$ff-'K'
0df4 : 28 plp ;N=1, V=1, Z=1, C=1
0df5 : 00 brk
else
lda #hi brk_ret1 ;emulated break
pha
lda #lo brk_ret1
pha
load_flag $ff
pha ;set break & unused on stack
pha ;actual flags
lda #$ff-'B'
ldx #$ff-'R'
ldy #$ff-'K'
plp ;N=1, V=1, Z=1, C=1
jmp irq_trap
endif
0df6 : 88 dey ;should not be executed
0df7 : brk_ret1 ;address of break return
0df7 : 08 php ;either SP or Y count will fail, if we do not hit
0df8 : 88 dey
0df9 : 88 dey
0dfa : 88 dey
0dfb : c917 cmp #($ff-'B')^$aa ;returned registers OK?
;the IRQ vector was never executed if A & X stay unmodified
trap_ne
0dfd : d0fe > bne * ;failed not equal (non zero)
0dff : e0ae cpx #$ff-'R'+1
trap_ne
0e01 : d0fe > bne * ;failed not equal (non zero)
0e03 : c0ae cpy #$ff-'K'-6
trap_ne
0e05 : d0fe > bne * ;failed not equal (non zero)
0e07 : 68 pla ;returned flags OK (unchanged)?
cmp_flag $ff
0e08 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
trap_ne
0e0a : d0fe > bne * ;failed not equal (non zero)
0e0c : ba tsx ;sp?
0e0d : e0ff cpx #$ff
trap_ne
0e0f : d0fe > bne * ;failed not equal (non zero)
next_test
0e11 : ad0002 > lda test_case ;previous test
0e14 : c90b > cmp #test_num
> trap_ne ;test is out of sequence
0e16 : d0fe > bne * ;failed not equal (non zero)
>
000c = >test_num = test_num + 1
0e18 : a90c > lda #test_num ;*** next tests' number
0e1a : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; test set and clear flags CLC CLI CLD CLV SEC SEI SED
set_stat $ff
> load_flag $ff
0e1d : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0e1f : 48 > pha ;use stack to load status
0e20 : 28 > plp
0e21 : 18 clc
tst_stat $ff-carry
0e22 : 08 > php ;save status
0e23 : 68 > pla ;use stack to retrieve status
0e24 : 48 > pha
> cmp_flag $ff-carry
0e25 : c9fe > cmp #($ff-carry|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0e27 : d0fe > bne * ;failed not equal (non zero)
>
0e29 : 28 > plp ;restore status
0e2a : 38 sec
tst_stat $ff
0e2b : 08 > php ;save status
0e2c : 68 > pla ;use stack to retrieve status
0e2d : 48 > pha
> cmp_flag $ff
0e2e : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0e30 : d0fe > bne * ;failed not equal (non zero)
>
0e32 : 28 > plp ;restore status
if I_flag = 3
0e33 : 58 cli
tst_stat $ff-intdis
0e34 : 08 > php ;save status
0e35 : 68 > pla ;use stack to retrieve status
0e36 : 48 > pha
> cmp_flag $ff-intdis
0e37 : c9fb > cmp #($ff-intdis|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0e39 : d0fe > bne * ;failed not equal (non zero)
>
0e3b : 28 > plp ;restore status
0e3c : 78 sei
tst_stat $ff
0e3d : 08 > php ;save status
0e3e : 68 > pla ;use stack to retrieve status
0e3f : 48 > pha
> cmp_flag $ff
0e40 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0e42 : d0fe > bne * ;failed not equal (non zero)
>
0e44 : 28 > plp ;restore status
endif
0e45 : d8 cld
tst_stat $ff-decmode
0e46 : 08 > php ;save status
0e47 : 68 > pla ;use stack to retrieve status
0e48 : 48 > pha
> cmp_flag $ff-decmode
0e49 : c9f7 > cmp #($ff-decmode|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0e4b : d0fe > bne * ;failed not equal (non zero)
>
0e4d : 28 > plp ;restore status
0e4e : f8 sed
tst_stat $ff
0e4f : 08 > php ;save status
0e50 : 68 > pla ;use stack to retrieve status
0e51 : 48 > pha
> cmp_flag $ff
0e52 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0e54 : d0fe > bne * ;failed not equal (non zero)
>
0e56 : 28 > plp ;restore status
0e57 : b8 clv
tst_stat $ff-overfl
0e58 : 08 > php ;save status
0e59 : 68 > pla ;use stack to retrieve status
0e5a : 48 > pha
> cmp_flag $ff-overfl
0e5b : c9bf > cmp #($ff-overfl|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0e5d : d0fe > bne * ;failed not equal (non zero)
>
0e5f : 28 > plp ;restore status
set_stat 0
> load_flag 0
0e60 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0e62 : 48 > pha ;use stack to load status
0e63 : 28 > plp
tst_stat 0
0e64 : 08 > php ;save status
0e65 : 68 > pla ;use stack to retrieve status
0e66 : 48 > pha
> cmp_flag 0
0e67 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0e69 : d0fe > bne * ;failed not equal (non zero)
>
0e6b : 28 > plp ;restore status
0e6c : 38 sec
tst_stat carry
0e6d : 08 > php ;save status
0e6e : 68 > pla ;use stack to retrieve status
0e6f : 48 > pha
> cmp_flag carry
0e70 : c931 > cmp #(carry|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0e72 : d0fe > bne * ;failed not equal (non zero)
>
0e74 : 28 > plp ;restore status
0e75 : 18 clc
tst_stat 0
0e76 : 08 > php ;save status
0e77 : 68 > pla ;use stack to retrieve status
0e78 : 48 > pha
> cmp_flag 0
0e79 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0e7b : d0fe > bne * ;failed not equal (non zero)
>
0e7d : 28 > plp ;restore status
if I_flag = 3
0e7e : 78 sei
tst_stat intdis
0e7f : 08 > php ;save status
0e80 : 68 > pla ;use stack to retrieve status
0e81 : 48 > pha
> cmp_flag intdis
0e82 : c934 > cmp #(intdis|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0e84 : d0fe > bne * ;failed not equal (non zero)
>
0e86 : 28 > plp ;restore status
0e87 : 58 cli
tst_stat 0
0e88 : 08 > php ;save status
0e89 : 68 > pla ;use stack to retrieve status
0e8a : 48 > pha
> cmp_flag 0
0e8b : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0e8d : d0fe > bne * ;failed not equal (non zero)
>
0e8f : 28 > plp ;restore status
endif
0e90 : f8 sed
tst_stat decmode
0e91 : 08 > php ;save status
0e92 : 68 > pla ;use stack to retrieve status
0e93 : 48 > pha
> cmp_flag decmode
0e94 : c938 > cmp #(decmode|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0e96 : d0fe > bne * ;failed not equal (non zero)
>
0e98 : 28 > plp ;restore status
0e99 : d8 cld
tst_stat 0
0e9a : 08 > php ;save status
0e9b : 68 > pla ;use stack to retrieve status
0e9c : 48 > pha
> cmp_flag 0
0e9d : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0e9f : d0fe > bne * ;failed not equal (non zero)
>
0ea1 : 28 > plp ;restore status
set_stat overfl
> load_flag overfl
0ea2 : a940 > lda #overfl ;allow test to change I-flag (no mask)
>
0ea4 : 48 > pha ;use stack to load status
0ea5 : 28 > plp
tst_stat overfl
0ea6 : 08 > php ;save status
0ea7 : 68 > pla ;use stack to retrieve status
0ea8 : 48 > pha
> cmp_flag overfl
0ea9 : c970 > cmp #(overfl|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0eab : d0fe > bne * ;failed not equal (non zero)
>
0ead : 28 > plp ;restore status
0eae : b8 clv
tst_stat 0
0eaf : 08 > php ;save status
0eb0 : 68 > pla ;use stack to retrieve status
0eb1 : 48 > pha
> cmp_flag 0
0eb2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0eb4 : d0fe > bne * ;failed not equal (non zero)
>
0eb6 : 28 > plp ;restore status
next_test
0eb7 : ad0002 > lda test_case ;previous test
0eba : c90c > cmp #test_num
> trap_ne ;test is out of sequence
0ebc : d0fe > bne * ;failed not equal (non zero)
>
000d = >test_num = test_num + 1
0ebe : a90d > lda #test_num ;*** next tests' number
0ec0 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; testing index register increment/decrement and transfer
; INX INY DEX DEY TAX TXA TAY TYA
0ec3 : a2fe ldx #$fe
set_stat $ff
> load_flag $ff
0ec5 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0ec7 : 48 > pha ;use stack to load status
0ec8 : 28 > plp
0ec9 : e8 inx ;ff
tst_x $ff,$ff-zero
0eca : 08 > php ;save flags
0ecb : e0ff > cpx #$ff ;test result
> trap_ne
0ecd : d0fe > bne * ;failed not equal (non zero)
>
0ecf : 68 > pla ;load status
0ed0 : 48 > pha
> cmp_flag $ff-zero
0ed1 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0ed3 : d0fe > bne * ;failed not equal (non zero)
>
0ed5 : 28 > plp ;restore status
0ed6 : e8 inx ;00
tst_x 0,$ff-minus
0ed7 : 08 > php ;save flags
0ed8 : e000 > cpx #0 ;test result
> trap_ne
0eda : d0fe > bne * ;failed not equal (non zero)
>
0edc : 68 > pla ;load status
0edd : 48 > pha
> cmp_flag $ff-minus
0ede : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0ee0 : d0fe > bne * ;failed not equal (non zero)
>
0ee2 : 28 > plp ;restore status
0ee3 : e8 inx ;01
tst_x 1,$ff-minus-zero
0ee4 : 08 > php ;save flags
0ee5 : e001 > cpx #1 ;test result
> trap_ne
0ee7 : d0fe > bne * ;failed not equal (non zero)
>
0ee9 : 68 > pla ;load status
0eea : 48 > pha
> cmp_flag $ff-minus-zero
0eeb : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0eed : d0fe > bne * ;failed not equal (non zero)
>
0eef : 28 > plp ;restore status
0ef0 : ca dex ;00
tst_x 0,$ff-minus
0ef1 : 08 > php ;save flags
0ef2 : e000 > cpx #0 ;test result
> trap_ne
0ef4 : d0fe > bne * ;failed not equal (non zero)
>
0ef6 : 68 > pla ;load status
0ef7 : 48 > pha
> cmp_flag $ff-minus
0ef8 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0efa : d0fe > bne * ;failed not equal (non zero)
>
0efc : 28 > plp ;restore status
0efd : ca dex ;ff
tst_x $ff,$ff-zero
0efe : 08 > php ;save flags
0eff : e0ff > cpx #$ff ;test result
> trap_ne
0f01 : d0fe > bne * ;failed not equal (non zero)
>
0f03 : 68 > pla ;load status
0f04 : 48 > pha
> cmp_flag $ff-zero
0f05 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0f07 : d0fe > bne * ;failed not equal (non zero)
>
0f09 : 28 > plp ;restore status
0f0a : ca dex ;fe
set_stat 0
> load_flag 0
0f0b : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0f0d : 48 > pha ;use stack to load status
0f0e : 28 > plp
0f0f : e8 inx ;ff
tst_x $ff,minus
0f10 : 08 > php ;save flags
0f11 : e0ff > cpx #$ff ;test result
> trap_ne
0f13 : d0fe > bne * ;failed not equal (non zero)
>
0f15 : 68 > pla ;load status
0f16 : 48 > pha
> cmp_flag minus
0f17 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0f19 : d0fe > bne * ;failed not equal (non zero)
>
0f1b : 28 > plp ;restore status
0f1c : e8 inx ;00
tst_x 0,zero
0f1d : 08 > php ;save flags
0f1e : e000 > cpx #0 ;test result
> trap_ne
0f20 : d0fe > bne * ;failed not equal (non zero)
>
0f22 : 68 > pla ;load status
0f23 : 48 > pha
> cmp_flag zero
0f24 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0f26 : d0fe > bne * ;failed not equal (non zero)
>
0f28 : 28 > plp ;restore status
0f29 : e8 inx ;01
tst_x 1,0
0f2a : 08 > php ;save flags
0f2b : e001 > cpx #1 ;test result
> trap_ne
0f2d : d0fe > bne * ;failed not equal (non zero)
>
0f2f : 68 > pla ;load status
0f30 : 48 > pha
> cmp_flag 0
0f31 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0f33 : d0fe > bne * ;failed not equal (non zero)
>
0f35 : 28 > plp ;restore status
0f36 : ca dex ;00
tst_x 0,zero
0f37 : 08 > php ;save flags
0f38 : e000 > cpx #0 ;test result
> trap_ne
0f3a : d0fe > bne * ;failed not equal (non zero)
>
0f3c : 68 > pla ;load status
0f3d : 48 > pha
> cmp_flag zero
0f3e : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0f40 : d0fe > bne * ;failed not equal (non zero)
>
0f42 : 28 > plp ;restore status
0f43 : ca dex ;ff
tst_x $ff,minus
0f44 : 08 > php ;save flags
0f45 : e0ff > cpx #$ff ;test result
> trap_ne
0f47 : d0fe > bne * ;failed not equal (non zero)
>
0f49 : 68 > pla ;load status
0f4a : 48 > pha
> cmp_flag minus
0f4b : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0f4d : d0fe > bne * ;failed not equal (non zero)
>
0f4f : 28 > plp ;restore status
0f50 : a0fe ldy #$fe
set_stat $ff
> load_flag $ff
0f52 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0f54 : 48 > pha ;use stack to load status
0f55 : 28 > plp
0f56 : c8 iny ;ff
tst_y $ff,$ff-zero
0f57 : 08 > php ;save flags
0f58 : c0ff > cpy #$ff ;test result
> trap_ne
0f5a : d0fe > bne * ;failed not equal (non zero)
>
0f5c : 68 > pla ;load status
0f5d : 48 > pha
> cmp_flag $ff-zero
0f5e : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0f60 : d0fe > bne * ;failed not equal (non zero)
>
0f62 : 28 > plp ;restore status
0f63 : c8 iny ;00
tst_y 0,$ff-minus
0f64 : 08 > php ;save flags
0f65 : c000 > cpy #0 ;test result
> trap_ne
0f67 : d0fe > bne * ;failed not equal (non zero)
>
0f69 : 68 > pla ;load status
0f6a : 48 > pha
> cmp_flag $ff-minus
0f6b : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0f6d : d0fe > bne * ;failed not equal (non zero)
>
0f6f : 28 > plp ;restore status
0f70 : c8 iny ;01
tst_y 1,$ff-minus-zero
0f71 : 08 > php ;save flags
0f72 : c001 > cpy #1 ;test result
> trap_ne
0f74 : d0fe > bne * ;failed not equal (non zero)
>
0f76 : 68 > pla ;load status
0f77 : 48 > pha
> cmp_flag $ff-minus-zero
0f78 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0f7a : d0fe > bne * ;failed not equal (non zero)
>
0f7c : 28 > plp ;restore status
0f7d : 88 dey ;00
tst_y 0,$ff-minus
0f7e : 08 > php ;save flags
0f7f : c000 > cpy #0 ;test result
> trap_ne
0f81 : d0fe > bne * ;failed not equal (non zero)
>
0f83 : 68 > pla ;load status
0f84 : 48 > pha
> cmp_flag $ff-minus
0f85 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0f87 : d0fe > bne * ;failed not equal (non zero)
>
0f89 : 28 > plp ;restore status
0f8a : 88 dey ;ff
tst_y $ff,$ff-zero
0f8b : 08 > php ;save flags
0f8c : c0ff > cpy #$ff ;test result
> trap_ne
0f8e : d0fe > bne * ;failed not equal (non zero)
>
0f90 : 68 > pla ;load status
0f91 : 48 > pha
> cmp_flag $ff-zero
0f92 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0f94 : d0fe > bne * ;failed not equal (non zero)
>
0f96 : 28 > plp ;restore status
0f97 : 88 dey ;fe
set_stat 0
> load_flag 0
0f98 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0f9a : 48 > pha ;use stack to load status
0f9b : 28 > plp
0f9c : c8 iny ;ff
tst_y $ff,0+minus
0f9d : 08 > php ;save flags
0f9e : c0ff > cpy #$ff ;test result
> trap_ne
0fa0 : d0fe > bne * ;failed not equal (non zero)
>
0fa2 : 68 > pla ;load status
0fa3 : 48 > pha
> cmp_flag 0+minus
0fa4 : c9b0 > cmp #(0+minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0fa6 : d0fe > bne * ;failed not equal (non zero)
>
0fa8 : 28 > plp ;restore status
0fa9 : c8 iny ;00
tst_y 0,zero
0faa : 08 > php ;save flags
0fab : c000 > cpy #0 ;test result
> trap_ne
0fad : d0fe > bne * ;failed not equal (non zero)
>
0faf : 68 > pla ;load status
0fb0 : 48 > pha
> cmp_flag zero
0fb1 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0fb3 : d0fe > bne * ;failed not equal (non zero)
>
0fb5 : 28 > plp ;restore status
0fb6 : c8 iny ;01
tst_y 1,0
0fb7 : 08 > php ;save flags
0fb8 : c001 > cpy #1 ;test result
> trap_ne
0fba : d0fe > bne * ;failed not equal (non zero)
>
0fbc : 68 > pla ;load status
0fbd : 48 > pha
> cmp_flag 0
0fbe : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0fc0 : d0fe > bne * ;failed not equal (non zero)
>
0fc2 : 28 > plp ;restore status
0fc3 : 88 dey ;00
tst_y 0,zero
0fc4 : 08 > php ;save flags
0fc5 : c000 > cpy #0 ;test result
> trap_ne
0fc7 : d0fe > bne * ;failed not equal (non zero)
>
0fc9 : 68 > pla ;load status
0fca : 48 > pha
> cmp_flag zero
0fcb : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0fcd : d0fe > bne * ;failed not equal (non zero)
>
0fcf : 28 > plp ;restore status
0fd0 : 88 dey ;ff
tst_y $ff,minus
0fd1 : 08 > php ;save flags
0fd2 : c0ff > cpy #$ff ;test result
> trap_ne
0fd4 : d0fe > bne * ;failed not equal (non zero)
>
0fd6 : 68 > pla ;load status
0fd7 : 48 > pha
> cmp_flag minus
0fd8 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0fda : d0fe > bne * ;failed not equal (non zero)
>
0fdc : 28 > plp ;restore status
0fdd : a2ff ldx #$ff
set_stat $ff
> load_flag $ff
0fdf : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0fe1 : 48 > pha ;use stack to load status
0fe2 : 28 > plp
0fe3 : 8a txa
tst_a $ff,$ff-zero
0fe4 : 08 > php ;save flags
0fe5 : c9ff > cmp #$ff ;test result
> trap_ne
0fe7 : d0fe > bne * ;failed not equal (non zero)
>
0fe9 : 68 > pla ;load status
0fea : 48 > pha
> cmp_flag $ff-zero
0feb : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0fed : d0fe > bne * ;failed not equal (non zero)
>
0fef : 28 > plp ;restore status
0ff0 : 08 php
0ff1 : e8 inx ;00
0ff2 : 28 plp
0ff3 : 8a txa
tst_a 0,$ff-minus
0ff4 : 08 > php ;save flags
0ff5 : c900 > cmp #0 ;test result
> trap_ne
0ff7 : d0fe > bne * ;failed not equal (non zero)
>
0ff9 : 68 > pla ;load status
0ffa : 48 > pha
> cmp_flag $ff-minus
0ffb : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0ffd : d0fe > bne * ;failed not equal (non zero)
>
0fff : 28 > plp ;restore status
1000 : 08 php
1001 : e8 inx ;01
1002 : 28 plp
1003 : 8a txa
tst_a 1,$ff-minus-zero
1004 : 08 > php ;save flags
1005 : c901 > cmp #1 ;test result
> trap_ne
1007 : d0fe > bne * ;failed not equal (non zero)
>
1009 : 68 > pla ;load status
100a : 48 > pha
> cmp_flag $ff-minus-zero
100b : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
100d : d0fe > bne * ;failed not equal (non zero)
>
100f : 28 > plp ;restore status
set_stat 0
> load_flag 0
1010 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1012 : 48 > pha ;use stack to load status
1013 : 28 > plp
1014 : 8a txa
tst_a 1,0
1015 : 08 > php ;save flags
1016 : c901 > cmp #1 ;test result
> trap_ne
1018 : d0fe > bne * ;failed not equal (non zero)
>
101a : 68 > pla ;load status
101b : 48 > pha
> cmp_flag 0
101c : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
101e : d0fe > bne * ;failed not equal (non zero)
>
1020 : 28 > plp ;restore status
1021 : 08 php
1022 : ca dex ;00
1023 : 28 plp
1024 : 8a txa
tst_a 0,zero
1025 : 08 > php ;save flags
1026 : c900 > cmp #0 ;test result
> trap_ne
1028 : d0fe > bne * ;failed not equal (non zero)
>
102a : 68 > pla ;load status
102b : 48 > pha
> cmp_flag zero
102c : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
102e : d0fe > bne * ;failed not equal (non zero)
>
1030 : 28 > plp ;restore status
1031 : 08 php
1032 : ca dex ;ff
1033 : 28 plp
1034 : 8a txa
tst_a $ff,minus
1035 : 08 > php ;save flags
1036 : c9ff > cmp #$ff ;test result
> trap_ne
1038 : d0fe > bne * ;failed not equal (non zero)
>
103a : 68 > pla ;load status
103b : 48 > pha
> cmp_flag minus
103c : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
103e : d0fe > bne * ;failed not equal (non zero)
>
1040 : 28 > plp ;restore status
1041 : a0ff ldy #$ff
set_stat $ff
> load_flag $ff
1043 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1045 : 48 > pha ;use stack to load status
1046 : 28 > plp
1047 : 98 tya
tst_a $ff,$ff-zero
1048 : 08 > php ;save flags
1049 : c9ff > cmp #$ff ;test result
> trap_ne
104b : d0fe > bne * ;failed not equal (non zero)
>
104d : 68 > pla ;load status
104e : 48 > pha
> cmp_flag $ff-zero
104f : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1051 : d0fe > bne * ;failed not equal (non zero)
>
1053 : 28 > plp ;restore status
1054 : 08 php
1055 : c8 iny ;00
1056 : 28 plp
1057 : 98 tya
tst_a 0,$ff-minus
1058 : 08 > php ;save flags
1059 : c900 > cmp #0 ;test result
> trap_ne
105b : d0fe > bne * ;failed not equal (non zero)
>
105d : 68 > pla ;load status
105e : 48 > pha
> cmp_flag $ff-minus
105f : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1061 : d0fe > bne * ;failed not equal (non zero)
>
1063 : 28 > plp ;restore status
1064 : 08 php
1065 : c8 iny ;01
1066 : 28 plp
1067 : 98 tya
tst_a 1,$ff-minus-zero
1068 : 08 > php ;save flags
1069 : c901 > cmp #1 ;test result
> trap_ne
106b : d0fe > bne * ;failed not equal (non zero)
>
106d : 68 > pla ;load status
106e : 48 > pha
> cmp_flag $ff-minus-zero
106f : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1071 : d0fe > bne * ;failed not equal (non zero)
>
1073 : 28 > plp ;restore status
set_stat 0
> load_flag 0
1074 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1076 : 48 > pha ;use stack to load status
1077 : 28 > plp
1078 : 98 tya
tst_a 1,0
1079 : 08 > php ;save flags
107a : c901 > cmp #1 ;test result
> trap_ne
107c : d0fe > bne * ;failed not equal (non zero)
>
107e : 68 > pla ;load status
107f : 48 > pha
> cmp_flag 0
1080 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1082 : d0fe > bne * ;failed not equal (non zero)
>
1084 : 28 > plp ;restore status
1085 : 08 php
1086 : 88 dey ;00
1087 : 28 plp
1088 : 98 tya
tst_a 0,zero
1089 : 08 > php ;save flags
108a : c900 > cmp #0 ;test result
> trap_ne
108c : d0fe > bne * ;failed not equal (non zero)
>
108e : 68 > pla ;load status
108f : 48 > pha
> cmp_flag zero
1090 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1092 : d0fe > bne * ;failed not equal (non zero)
>
1094 : 28 > plp ;restore status
1095 : 08 php
1096 : 88 dey ;ff
1097 : 28 plp
1098 : 98 tya
tst_a $ff,minus
1099 : 08 > php ;save flags
109a : c9ff > cmp #$ff ;test result
> trap_ne
109c : d0fe > bne * ;failed not equal (non zero)
>
109e : 68 > pla ;load status
109f : 48 > pha
> cmp_flag minus
10a0 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
10a2 : d0fe > bne * ;failed not equal (non zero)
>
10a4 : 28 > plp ;restore status
load_flag $ff
10a5 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
10a7 : 48 pha
10a8 : a2ff ldx #$ff ;ff
10aa : 8a txa
10ab : 28 plp
10ac : a8 tay
tst_y $ff,$ff-zero
10ad : 08 > php ;save flags
10ae : c0ff > cpy #$ff ;test result
> trap_ne
10b0 : d0fe > bne * ;failed not equal (non zero)
>
10b2 : 68 > pla ;load status
10b3 : 48 > pha
> cmp_flag $ff-zero
10b4 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
10b6 : d0fe > bne * ;failed not equal (non zero)
>
10b8 : 28 > plp ;restore status
10b9 : 08 php
10ba : e8 inx ;00
10bb : 8a txa
10bc : 28 plp
10bd : a8 tay
tst_y 0,$ff-minus
10be : 08 > php ;save flags
10bf : c000 > cpy #0 ;test result
> trap_ne
10c1 : d0fe > bne * ;failed not equal (non zero)
>
10c3 : 68 > pla ;load status
10c4 : 48 > pha
> cmp_flag $ff-minus
10c5 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
10c7 : d0fe > bne * ;failed not equal (non zero)
>
10c9 : 28 > plp ;restore status
10ca : 08 php
10cb : e8 inx ;01
10cc : 8a txa
10cd : 28 plp
10ce : a8 tay
tst_y 1,$ff-minus-zero
10cf : 08 > php ;save flags
10d0 : c001 > cpy #1 ;test result
> trap_ne
10d2 : d0fe > bne * ;failed not equal (non zero)
>
10d4 : 68 > pla ;load status
10d5 : 48 > pha
> cmp_flag $ff-minus-zero
10d6 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
10d8 : d0fe > bne * ;failed not equal (non zero)
>
10da : 28 > plp ;restore status
load_flag 0
10db : a900 > lda #0 ;allow test to change I-flag (no mask)
10dd : 48 pha
10de : a900 lda #0
10e0 : 8a txa
10e1 : 28 plp
10e2 : a8 tay
tst_y 1,0
10e3 : 08 > php ;save flags
10e4 : c001 > cpy #1 ;test result
> trap_ne
10e6 : d0fe > bne * ;failed not equal (non zero)
>
10e8 : 68 > pla ;load status
10e9 : 48 > pha
> cmp_flag 0
10ea : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
10ec : d0fe > bne * ;failed not equal (non zero)
>
10ee : 28 > plp ;restore status
10ef : 08 php
10f0 : ca dex ;00
10f1 : 8a txa
10f2 : 28 plp
10f3 : a8 tay
tst_y 0,zero
10f4 : 08 > php ;save flags
10f5 : c000 > cpy #0 ;test result
> trap_ne
10f7 : d0fe > bne * ;failed not equal (non zero)
>
10f9 : 68 > pla ;load status
10fa : 48 > pha
> cmp_flag zero
10fb : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
10fd : d0fe > bne * ;failed not equal (non zero)
>
10ff : 28 > plp ;restore status
1100 : 08 php
1101 : ca dex ;ff
1102 : 8a txa
1103 : 28 plp
1104 : a8 tay
tst_y $ff,minus
1105 : 08 > php ;save flags
1106 : c0ff > cpy #$ff ;test result
> trap_ne
1108 : d0fe > bne * ;failed not equal (non zero)
>
110a : 68 > pla ;load status
110b : 48 > pha
> cmp_flag minus
110c : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
110e : d0fe > bne * ;failed not equal (non zero)
>
1110 : 28 > plp ;restore status
load_flag $ff
1111 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
1113 : 48 pha
1114 : a0ff ldy #$ff ;ff
1116 : 98 tya
1117 : 28 plp
1118 : aa tax
tst_x $ff,$ff-zero
1119 : 08 > php ;save flags
111a : e0ff > cpx #$ff ;test result
> trap_ne
111c : d0fe > bne * ;failed not equal (non zero)
>
111e : 68 > pla ;load status
111f : 48 > pha
> cmp_flag $ff-zero
1120 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1122 : d0fe > bne * ;failed not equal (non zero)
>
1124 : 28 > plp ;restore status
1125 : 08 php
1126 : c8 iny ;00
1127 : 98 tya
1128 : 28 plp
1129 : aa tax
tst_x 0,$ff-minus
112a : 08 > php ;save flags
112b : e000 > cpx #0 ;test result
> trap_ne
112d : d0fe > bne * ;failed not equal (non zero)
>
112f : 68 > pla ;load status
1130 : 48 > pha
> cmp_flag $ff-minus
1131 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1133 : d0fe > bne * ;failed not equal (non zero)
>
1135 : 28 > plp ;restore status
1136 : 08 php
1137 : c8 iny ;01
1138 : 98 tya
1139 : 28 plp
113a : aa tax
tst_x 1,$ff-minus-zero
113b : 08 > php ;save flags
113c : e001 > cpx #1 ;test result
> trap_ne
113e : d0fe > bne * ;failed not equal (non zero)
>
1140 : 68 > pla ;load status
1141 : 48 > pha
> cmp_flag $ff-minus-zero
1142 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1144 : d0fe > bne * ;failed not equal (non zero)
>
1146 : 28 > plp ;restore status
load_flag 0
1147 : a900 > lda #0 ;allow test to change I-flag (no mask)
1149 : 48 pha
114a : a900 lda #0 ;preset status
114c : 98 tya
114d : 28 plp
114e : aa tax
tst_x 1,0
114f : 08 > php ;save flags
1150 : e001 > cpx #1 ;test result
> trap_ne
1152 : d0fe > bne * ;failed not equal (non zero)
>
1154 : 68 > pla ;load status
1155 : 48 > pha
> cmp_flag 0
1156 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1158 : d0fe > bne * ;failed not equal (non zero)
>
115a : 28 > plp ;restore status
115b : 08 php
115c : 88 dey ;00
115d : 98 tya
115e : 28 plp
115f : aa tax
tst_x 0,zero
1160 : 08 > php ;save flags
1161 : e000 > cpx #0 ;test result
> trap_ne
1163 : d0fe > bne * ;failed not equal (non zero)
>
1165 : 68 > pla ;load status
1166 : 48 > pha
> cmp_flag zero
1167 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1169 : d0fe > bne * ;failed not equal (non zero)
>
116b : 28 > plp ;restore status
116c : 08 php
116d : 88 dey ;ff
116e : 98 tya
116f : 28 plp
1170 : aa tax
tst_x $ff,minus
1171 : 08 > php ;save flags
1172 : e0ff > cpx #$ff ;test result
> trap_ne
1174 : d0fe > bne * ;failed not equal (non zero)
>
1176 : 68 > pla ;load status
1177 : 48 > pha
> cmp_flag minus
1178 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
117a : d0fe > bne * ;failed not equal (non zero)
>
117c : 28 > plp ;restore status
next_test
117d : ad0002 > lda test_case ;previous test
1180 : c90d > cmp #test_num
> trap_ne ;test is out of sequence
1182 : d0fe > bne * ;failed not equal (non zero)
>
000e = >test_num = test_num + 1
1184 : a90e > lda #test_num ;*** next tests' number
1186 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
;TSX sets NZ - TXS does not
; This section also tests for proper stack wrap around.
1189 : a201 ldx #1 ;01
set_stat $ff
> load_flag $ff
118b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
118d : 48 > pha ;use stack to load status
118e : 28 > plp
118f : 9a txs
1190 : 08 php
1191 : ad0101 lda $101
cmp_flag $ff
1194 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
trap_ne
1196 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1198 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
119a : 48 > pha ;use stack to load status
119b : 28 > plp
119c : 9a txs
119d : 08 php
119e : ad0101 lda $101
cmp_flag 0
11a1 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
trap_ne
11a3 : d0fe > bne * ;failed not equal (non zero)
11a5 : ca dex ;00
set_stat $ff
> load_flag $ff
11a6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
11a8 : 48 > pha ;use stack to load status
11a9 : 28 > plp
11aa : 9a txs
11ab : 08 php
11ac : ad0001 lda $100
cmp_flag $ff
11af : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
trap_ne
11b1 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
11b3 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
11b5 : 48 > pha ;use stack to load status
11b6 : 28 > plp
11b7 : 9a txs
11b8 : 08 php
11b9 : ad0001 lda $100
cmp_flag 0
11bc : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
trap_ne
11be : d0fe > bne * ;failed not equal (non zero)
11c0 : ca dex ;ff
set_stat $ff
> load_flag $ff
11c1 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
11c3 : 48 > pha ;use stack to load status
11c4 : 28 > plp
11c5 : 9a txs
11c6 : 08 php
11c7 : adff01 lda $1ff
cmp_flag $ff
11ca : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
trap_ne
11cc : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
11ce : a900 > lda #0 ;allow test to change I-flag (no mask)
>
11d0 : 48 > pha ;use stack to load status
11d1 : 28 > plp
11d2 : 9a txs
11d3 : 08 php
11d4 : adff01 lda $1ff
cmp_flag 0
11d7 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
11d9 : a201 ldx #1
11db : 9a txs ;sp=01
set_stat $ff
> load_flag $ff
11dc : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
11de : 48 > pha ;use stack to load status
11df : 28 > plp
11e0 : ba tsx ;clears Z, N
11e1 : 08 php ;sp=00
11e2 : e001 cpx #1
trap_ne
11e4 : d0fe > bne * ;failed not equal (non zero)
11e6 : ad0101 lda $101
cmp_flag $ff-minus-zero
11e9 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits
trap_ne
11eb : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
11ed : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
11ef : 48 > pha ;use stack to load status
11f0 : 28 > plp
11f1 : ba tsx ;clears N, sets Z
11f2 : 08 php ;sp=ff
11f3 : e000 cpx #0
trap_ne
11f5 : d0fe > bne * ;failed not equal (non zero)
11f7 : ad0001 lda $100
cmp_flag $ff-minus
11fa : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
trap_ne
11fc : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
11fe : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1200 : 48 > pha ;use stack to load status
1201 : 28 > plp
1202 : ba tsx ;clears N, sets Z
1203 : 08 php ;sp=fe
1204 : e0ff cpx #$ff
trap_ne
1206 : d0fe > bne * ;failed not equal (non zero)
1208 : adff01 lda $1ff
cmp_flag $ff-zero
120b : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
trap_ne
120d : d0fe > bne * ;failed not equal (non zero)
120f : a201 ldx #1
1211 : 9a txs ;sp=01
set_stat 0
> load_flag 0
1212 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1214 : 48 > pha ;use stack to load status
1215 : 28 > plp
1216 : ba tsx ;clears Z, N
1217 : 08 php ;sp=00
1218 : e001 cpx #1
trap_ne
121a : d0fe > bne * ;failed not equal (non zero)
121c : ad0101 lda $101
cmp_flag 0
121f : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
trap_ne
1221 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1223 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1225 : 48 > pha ;use stack to load status
1226 : 28 > plp
1227 : ba tsx ;clears N, sets Z
1228 : 08 php ;sp=ff
1229 : e000 cpx #0
trap_ne
122b : d0fe > bne * ;failed not equal (non zero)
122d : ad0001 lda $100
cmp_flag zero
1230 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
trap_ne
1232 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1234 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1236 : 48 > pha ;use stack to load status
1237 : 28 > plp
1238 : ba tsx ;clears N, sets Z
1239 : 08 php ;sp=fe
123a : e0ff cpx #$ff
trap_ne
123c : d0fe > bne * ;failed not equal (non zero)
123e : adff01 lda $1ff
cmp_flag minus
1241 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
trap_ne
1243 : d0fe > bne * ;failed not equal (non zero)
1245 : 68 pla ;sp=ff
next_test
1246 : ad0002 > lda test_case ;previous test
1249 : c90e > cmp #test_num
> trap_ne ;test is out of sequence
124b : d0fe > bne * ;failed not equal (non zero)
>
000f = >test_num = test_num + 1
124d : a90f > lda #test_num ;*** next tests' number
124f : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; testing index register load & store LDY LDX STY STX all addressing modes
; LDX / STX - zp,y / abs,y
1252 : a003 ldy #3
1254 : tldx
set_stat 0
> load_flag 0
1254 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1256 : 48 > pha ;use stack to load status
1257 : 28 > plp
1258 : b609 ldx zp1,y
125a : 08 php ;test stores do not alter flags
125b : 8a txa
125c : 49c3 eor #$c3
125e : 28 plp
125f : 990302 sta abst,y
1262 : 08 php ;flags after load/store sequence
1263 : 49c3 eor #$c3
1265 : d91702 cmp abs1,y ;test result
trap_ne
1268 : d0fe > bne * ;failed not equal (non zero)
126a : 68 pla ;load status
eor_flag 0
126b : 4930 > eor #0|fao ;invert expected flags + always on bits
126d : d91c02 cmp fLDx,y ;test flags
trap_ne
1270 : d0fe > bne * ;failed not equal (non zero)
1272 : 88 dey
1273 : 10df bpl tldx
1275 : a003 ldy #3
1277 : tldx1
set_stat $ff
> load_flag $ff
1277 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1279 : 48 > pha ;use stack to load status
127a : 28 > plp
127b : b609 ldx zp1,y
127d : 08 php ;test stores do not alter flags
127e : 8a txa
127f : 49c3 eor #$c3
1281 : 28 plp
1282 : 990302 sta abst,y
1285 : 08 php ;flags after load/store sequence
1286 : 49c3 eor #$c3
1288 : d91702 cmp abs1,y ;test result
trap_ne
128b : d0fe > bne * ;failed not equal (non zero)
128d : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
128e : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1290 : d91c02 cmp fLDx,y ;test flags
trap_ne
1293 : d0fe > bne * ;failed not equal (non zero)
1295 : 88 dey
1296 : 10df bpl tldx1
1298 : a003 ldy #3
129a : tldx2
set_stat 0
> load_flag 0
129a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
129c : 48 > pha ;use stack to load status
129d : 28 > plp
129e : be1702 ldx abs1,y
12a1 : 08 php ;test stores do not alter flags
12a2 : 8a txa
12a3 : 49c3 eor #$c3
12a5 : aa tax
12a6 : 28 plp
12a7 : 9602 stx zpt,y
12a9 : 08 php ;flags after load/store sequence
12aa : 49c3 eor #$c3
12ac : d90900 cmp zp1,y ;test result
trap_ne
12af : d0fe > bne * ;failed not equal (non zero)
12b1 : 68 pla ;load status
eor_flag 0
12b2 : 4930 > eor #0|fao ;invert expected flags + always on bits
12b4 : d91c02 cmp fLDx,y ;test flags
trap_ne
12b7 : d0fe > bne * ;failed not equal (non zero)
12b9 : 88 dey
12ba : 10de bpl tldx2
12bc : a003 ldy #3
12be : tldx3
set_stat $ff
> load_flag $ff
12be : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
12c0 : 48 > pha ;use stack to load status
12c1 : 28 > plp
12c2 : be1702 ldx abs1,y
12c5 : 08 php ;test stores do not alter flags
12c6 : 8a txa
12c7 : 49c3 eor #$c3
12c9 : aa tax
12ca : 28 plp
12cb : 9602 stx zpt,y
12cd : 08 php ;flags after load/store sequence
12ce : 49c3 eor #$c3
12d0 : d90900 cmp zp1,y ;test result
trap_ne
12d3 : d0fe > bne * ;failed not equal (non zero)
12d5 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
12d6 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
12d8 : d91c02 cmp fLDx,y ;test flags
trap_ne
12db : d0fe > bne * ;failed not equal (non zero)
12dd : 88 dey
12de : 10de bpl tldx3
12e0 : a003 ldy #3 ;testing store result
12e2 : a200 ldx #0
12e4 : b90200 tstx lda zpt,y
12e7 : 49c3 eor #$c3
12e9 : d90900 cmp zp1,y
trap_ne ;store to zp data
12ec : d0fe > bne * ;failed not equal (non zero)
12ee : 9602 stx zpt,y ;clear
12f0 : b90302 lda abst,y
12f3 : 49c3 eor #$c3
12f5 : d91702 cmp abs1,y
trap_ne ;store to abs data
12f8 : d0fe > bne * ;failed not equal (non zero)
12fa : 8a txa
12fb : 990302 sta abst,y ;clear
12fe : 88 dey
12ff : 10e3 bpl tstx
next_test
1301 : ad0002 > lda test_case ;previous test
1304 : c90f > cmp #test_num
> trap_ne ;test is out of sequence
1306 : d0fe > bne * ;failed not equal (non zero)
>
0010 = >test_num = test_num + 1
1308 : a910 > lda #test_num ;*** next tests' number
130a : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; indexed wraparound test (only zp should wrap)
130d : a0fd ldy #3+$fa
130f : b60f tldx4 ldx zp1-$fa&$ff,y ;wrap on indexed zp
1311 : 8a txa
1312 : 990901 sta abst-$fa,y ;no STX abs,y!
1315 : 88 dey
1316 : c0fa cpy #$fa
1318 : b0f5 bcs tldx4
131a : a0fd ldy #3+$fa
131c : be1d01 tldx5 ldx abs1-$fa,y ;no wrap on indexed abs
131f : 9608 stx zpt-$fa&$ff,y
1321 : 88 dey
1322 : c0fa cpy #$fa
1324 : b0f6 bcs tldx5
1326 : a003 ldy #3 ;testing wraparound result
1328 : a200 ldx #0
132a : b90200 tstx1 lda zpt,y
132d : d90900 cmp zp1,y
trap_ne ;store to zp data
1330 : d0fe > bne * ;failed not equal (non zero)
1332 : 9602 stx zpt,y ;clear
1334 : b90302 lda abst,y
1337 : d91702 cmp abs1,y
trap_ne ;store to abs data
133a : d0fe > bne * ;failed not equal (non zero)
133c : 8a txa
133d : 990302 sta abst,y ;clear
1340 : 88 dey
1341 : 10e7 bpl tstx1
next_test
1343 : ad0002 > lda test_case ;previous test
1346 : c910 > cmp #test_num
> trap_ne ;test is out of sequence
1348 : d0fe > bne * ;failed not equal (non zero)
>
0011 = >test_num = test_num + 1
134a : a911 > lda #test_num ;*** next tests' number
134c : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; LDY / STY - zp,x / abs,x
134f : a203 ldx #3
1351 : tldy
set_stat 0
> load_flag 0
1351 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1353 : 48 > pha ;use stack to load status
1354 : 28 > plp
1355 : b409 ldy zp1,x
1357 : 08 php ;test stores do not alter flags
1358 : 98 tya
1359 : 49c3 eor #$c3
135b : 28 plp
135c : 9d0302 sta abst,x
135f : 08 php ;flags after load/store sequence
1360 : 49c3 eor #$c3
1362 : dd1702 cmp abs1,x ;test result
trap_ne
1365 : d0fe > bne * ;failed not equal (non zero)
1367 : 68 pla ;load status
eor_flag 0
1368 : 4930 > eor #0|fao ;invert expected flags + always on bits
136a : dd1c02 cmp fLDx,x ;test flags
trap_ne
136d : d0fe > bne * ;failed not equal (non zero)
136f : ca dex
1370 : 10df bpl tldy
1372 : a203 ldx #3
1374 : tldy1
set_stat $ff
> load_flag $ff
1374 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1376 : 48 > pha ;use stack to load status
1377 : 28 > plp
1378 : b409 ldy zp1,x
137a : 08 php ;test stores do not alter flags
137b : 98 tya
137c : 49c3 eor #$c3
137e : 28 plp
137f : 9d0302 sta abst,x
1382 : 08 php ;flags after load/store sequence
1383 : 49c3 eor #$c3
1385 : dd1702 cmp abs1,x ;test result
trap_ne
1388 : d0fe > bne * ;failed not equal (non zero)
138a : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
138b : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
138d : dd1c02 cmp fLDx,x ;test flags
trap_ne
1390 : d0fe > bne * ;failed not equal (non zero)
1392 : ca dex
1393 : 10df bpl tldy1
1395 : a203 ldx #3
1397 : tldy2
set_stat 0
> load_flag 0
1397 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1399 : 48 > pha ;use stack to load status
139a : 28 > plp
139b : bc1702 ldy abs1,x
139e : 08 php ;test stores do not alter flags
139f : 98 tya
13a0 : 49c3 eor #$c3
13a2 : a8 tay
13a3 : 28 plp
13a4 : 9402 sty zpt,x
13a6 : 08 php ;flags after load/store sequence
13a7 : 49c3 eor #$c3
13a9 : d509 cmp zp1,x ;test result
trap_ne
13ab : d0fe > bne * ;failed not equal (non zero)
13ad : 68 pla ;load status
eor_flag 0
13ae : 4930 > eor #0|fao ;invert expected flags + always on bits
13b0 : dd1c02 cmp fLDx,x ;test flags
trap_ne
13b3 : d0fe > bne * ;failed not equal (non zero)
13b5 : ca dex
13b6 : 10df bpl tldy2
13b8 : a203 ldx #3
13ba : tldy3
set_stat $ff
> load_flag $ff
13ba : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
13bc : 48 > pha ;use stack to load status
13bd : 28 > plp
13be : bc1702 ldy abs1,x
13c1 : 08 php ;test stores do not alter flags
13c2 : 98 tya
13c3 : 49c3 eor #$c3
13c5 : a8 tay
13c6 : 28 plp
13c7 : 9402 sty zpt,x
13c9 : 08 php ;flags after load/store sequence
13ca : 49c3 eor #$c3
13cc : d509 cmp zp1,x ;test result
trap_ne
13ce : d0fe > bne * ;failed not equal (non zero)
13d0 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
13d1 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
13d3 : dd1c02 cmp fLDx,x ;test flags
trap_ne
13d6 : d0fe > bne * ;failed not equal (non zero)
13d8 : ca dex
13d9 : 10df bpl tldy3
13db : a203 ldx #3 ;testing store result
13dd : a000 ldy #0
13df : b502 tsty lda zpt,x
13e1 : 49c3 eor #$c3
13e3 : d509 cmp zp1,x
trap_ne ;store to zp,x data
13e5 : d0fe > bne * ;failed not equal (non zero)
13e7 : 9402 sty zpt,x ;clear
13e9 : bd0302 lda abst,x
13ec : 49c3 eor #$c3
13ee : dd1702 cmp abs1,x
trap_ne ;store to abs,x data
13f1 : d0fe > bne * ;failed not equal (non zero)
13f3 : 8a txa
13f4 : 9d0302 sta abst,x ;clear
13f7 : ca dex
13f8 : 10e5 bpl tsty
next_test
13fa : ad0002 > lda test_case ;previous test
13fd : c911 > cmp #test_num
> trap_ne ;test is out of sequence
13ff : d0fe > bne * ;failed not equal (non zero)
>
0012 = >test_num = test_num + 1
1401 : a912 > lda #test_num ;*** next tests' number
1403 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; indexed wraparound test (only zp should wrap)
1406 : a2fd ldx #3+$fa
1408 : b40f tldy4 ldy zp1-$fa&$ff,x ;wrap on indexed zp
140a : 98 tya
140b : 9d0901 sta abst-$fa,x ;no STX abs,x!
140e : ca dex
140f : e0fa cpx #$fa
1411 : b0f5 bcs tldy4
1413 : a2fd ldx #3+$fa
1415 : bc1d01 tldy5 ldy abs1-$fa,x ;no wrap on indexed abs
1418 : 9408 sty zpt-$fa&$ff,x
141a : ca dex
141b : e0fa cpx #$fa
141d : b0f6 bcs tldy5
141f : a203 ldx #3 ;testing wraparound result
1421 : a000 ldy #0
1423 : b502 tsty1 lda zpt,x
1425 : d509 cmp zp1,x
trap_ne ;store to zp,x data
1427 : d0fe > bne * ;failed not equal (non zero)
1429 : 9402 sty zpt,x ;clear
142b : bd0302 lda abst,x
142e : dd1702 cmp abs1,x
trap_ne ;store to abs,x data
1431 : d0fe > bne * ;failed not equal (non zero)
1433 : 8a txa
1434 : 9d0302 sta abst,x ;clear
1437 : ca dex
1438 : 10e9 bpl tsty1
next_test
143a : ad0002 > lda test_case ;previous test
143d : c912 > cmp #test_num
> trap_ne ;test is out of sequence
143f : d0fe > bne * ;failed not equal (non zero)
>
0013 = >test_num = test_num + 1
1441 : a913 > lda #test_num ;*** next tests' number
1443 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; LDX / STX - zp / abs / #
set_stat 0
> load_flag 0
1446 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1448 : 48 > pha ;use stack to load status
1449 : 28 > plp
144a : a609 ldx zp1
144c : 08 php ;test stores do not alter flags
144d : 8a txa
144e : 49c3 eor #$c3
1450 : aa tax
1451 : 28 plp
1452 : 8e0302 stx abst
1455 : 08 php ;flags after load/store sequence
1456 : 49c3 eor #$c3
1458 : aa tax
1459 : e0c3 cpx #$c3 ;test result
trap_ne
145b : d0fe > bne * ;failed not equal (non zero)
145d : 68 pla ;load status
eor_flag 0
145e : 4930 > eor #0|fao ;invert expected flags + always on bits
1460 : cd1c02 cmp fLDx ;test flags
trap_ne
1463 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1465 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1467 : 48 > pha ;use stack to load status
1468 : 28 > plp
1469 : a60a ldx zp1+1
146b : 08 php ;test stores do not alter flags
146c : 8a txa
146d : 49c3 eor #$c3
146f : aa tax
1470 : 28 plp
1471 : 8e0402 stx abst+1
1474 : 08 php ;flags after load/store sequence
1475 : 49c3 eor #$c3
1477 : aa tax
1478 : e082 cpx #$82 ;test result
trap_ne
147a : d0fe > bne * ;failed not equal (non zero)
147c : 68 pla ;load status
eor_flag 0
147d : 4930 > eor #0|fao ;invert expected flags + always on bits
147f : cd1d02 cmp fLDx+1 ;test flags
trap_ne
1482 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1484 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1486 : 48 > pha ;use stack to load status
1487 : 28 > plp
1488 : a60b ldx zp1+2
148a : 08 php ;test stores do not alter flags
148b : 8a txa
148c : 49c3 eor #$c3
148e : aa tax
148f : 28 plp
1490 : 8e0502 stx abst+2
1493 : 08 php ;flags after load/store sequence
1494 : 49c3 eor #$c3
1496 : aa tax
1497 : e041 cpx #$41 ;test result
trap_ne
1499 : d0fe > bne * ;failed not equal (non zero)
149b : 68 pla ;load status
eor_flag 0
149c : 4930 > eor #0|fao ;invert expected flags + always on bits
149e : cd1e02 cmp fLDx+2 ;test flags
trap_ne
14a1 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
14a3 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
14a5 : 48 > pha ;use stack to load status
14a6 : 28 > plp
14a7 : a60c ldx zp1+3
14a9 : 08 php ;test stores do not alter flags
14aa : 8a txa
14ab : 49c3 eor #$c3
14ad : aa tax
14ae : 28 plp
14af : 8e0602 stx abst+3
14b2 : 08 php ;flags after load/store sequence
14b3 : 49c3 eor #$c3
14b5 : aa tax
14b6 : e000 cpx #0 ;test result
trap_ne
14b8 : d0fe > bne * ;failed not equal (non zero)
14ba : 68 pla ;load status
eor_flag 0
14bb : 4930 > eor #0|fao ;invert expected flags + always on bits
14bd : cd1f02 cmp fLDx+3 ;test flags
trap_ne
14c0 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
14c2 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
14c4 : 48 > pha ;use stack to load status
14c5 : 28 > plp
14c6 : a609 ldx zp1
14c8 : 08 php ;test stores do not alter flags
14c9 : 8a txa
14ca : 49c3 eor #$c3
14cc : aa tax
14cd : 28 plp
14ce : 8e0302 stx abst
14d1 : 08 php ;flags after load/store sequence
14d2 : 49c3 eor #$c3
14d4 : aa tax
14d5 : e0c3 cpx #$c3 ;test result
trap_ne ;
14d7 : d0fe > bne * ;failed not equal (non zero)
14d9 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
14da : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
14dc : cd1c02 cmp fLDx ;test flags
trap_ne
14df : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
14e1 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
14e3 : 48 > pha ;use stack to load status
14e4 : 28 > plp
14e5 : a60a ldx zp1+1
14e7 : 08 php ;test stores do not alter flags
14e8 : 8a txa
14e9 : 49c3 eor #$c3
14eb : aa tax
14ec : 28 plp
14ed : 8e0402 stx abst+1
14f0 : 08 php ;flags after load/store sequence
14f1 : 49c3 eor #$c3
14f3 : aa tax
14f4 : e082 cpx #$82 ;test result
trap_ne
14f6 : d0fe > bne * ;failed not equal (non zero)
14f8 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
14f9 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
14fb : cd1d02 cmp fLDx+1 ;test flags
trap_ne
14fe : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1500 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1502 : 48 > pha ;use stack to load status
1503 : 28 > plp
1504 : a60b ldx zp1+2
1506 : 08 php ;test stores do not alter flags
1507 : 8a txa
1508 : 49c3 eor #$c3
150a : aa tax
150b : 28 plp
150c : 8e0502 stx abst+2
150f : 08 php ;flags after load/store sequence
1510 : 49c3 eor #$c3
1512 : aa tax
1513 : e041 cpx #$41 ;test result
trap_ne ;
1515 : d0fe > bne * ;failed not equal (non zero)
1517 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1518 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
151a : cd1e02 cmp fLDx+2 ;test flags
trap_ne
151d : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
151f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1521 : 48 > pha ;use stack to load status
1522 : 28 > plp
1523 : a60c ldx zp1+3
1525 : 08 php ;test stores do not alter flags
1526 : 8a txa
1527 : 49c3 eor #$c3
1529 : aa tax
152a : 28 plp
152b : 8e0602 stx abst+3
152e : 08 php ;flags after load/store sequence
152f : 49c3 eor #$c3
1531 : aa tax
1532 : e000 cpx #0 ;test result
trap_ne
1534 : d0fe > bne * ;failed not equal (non zero)
1536 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1537 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1539 : cd1f02 cmp fLDx+3 ;test flags
trap_ne
153c : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
153e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1540 : 48 > pha ;use stack to load status
1541 : 28 > plp
1542 : ae1702 ldx abs1
1545 : 08 php ;test stores do not alter flags
1546 : 8a txa
1547 : 49c3 eor #$c3
1549 : aa tax
154a : 28 plp
154b : 8602 stx zpt
154d : 08 php ;flags after load/store sequence
154e : 49c3 eor #$c3
1550 : c509 cmp zp1 ;test result
trap_ne
1552 : d0fe > bne * ;failed not equal (non zero)
1554 : 68 pla ;load status
eor_flag 0
1555 : 4930 > eor #0|fao ;invert expected flags + always on bits
1557 : cd1c02 cmp fLDx ;test flags
trap_ne
155a : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
155c : a900 > lda #0 ;allow test to change I-flag (no mask)
>
155e : 48 > pha ;use stack to load status
155f : 28 > plp
1560 : ae1802 ldx abs1+1
1563 : 08 php ;test stores do not alter flags
1564 : 8a txa
1565 : 49c3 eor #$c3
1567 : aa tax
1568 : 28 plp
1569 : 8603 stx zpt+1
156b : 08 php ;flags after load/store sequence
156c : 49c3 eor #$c3
156e : c50a cmp zp1+1 ;test result
trap_ne
1570 : d0fe > bne * ;failed not equal (non zero)
1572 : 68 pla ;load status
eor_flag 0
1573 : 4930 > eor #0|fao ;invert expected flags + always on bits
1575 : cd1d02 cmp fLDx+1 ;test flags
trap_ne
1578 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
157a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
157c : 48 > pha ;use stack to load status
157d : 28 > plp
157e : ae1902 ldx abs1+2
1581 : 08 php ;test stores do not alter flags
1582 : 8a txa
1583 : 49c3 eor #$c3
1585 : aa tax
1586 : 28 plp
1587 : 8604 stx zpt+2
1589 : 08 php ;flags after load/store sequence
158a : 49c3 eor #$c3
158c : c50b cmp zp1+2 ;test result
trap_ne
158e : d0fe > bne * ;failed not equal (non zero)
1590 : 68 pla ;load status
eor_flag 0
1591 : 4930 > eor #0|fao ;invert expected flags + always on bits
1593 : cd1e02 cmp fLDx+2 ;test flags
trap_ne
1596 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1598 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
159a : 48 > pha ;use stack to load status
159b : 28 > plp
159c : ae1a02 ldx abs1+3
159f : 08 php ;test stores do not alter flags
15a0 : 8a txa
15a1 : 49c3 eor #$c3
15a3 : aa tax
15a4 : 28 plp
15a5 : 8605 stx zpt+3
15a7 : 08 php ;flags after load/store sequence
15a8 : 49c3 eor #$c3
15aa : c50c cmp zp1+3 ;test result
trap_ne
15ac : d0fe > bne * ;failed not equal (non zero)
15ae : 68 pla ;load status
eor_flag 0
15af : 4930 > eor #0|fao ;invert expected flags + always on bits
15b1 : cd1f02 cmp fLDx+3 ;test flags
trap_ne
15b4 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
15b6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
15b8 : 48 > pha ;use stack to load status
15b9 : 28 > plp
15ba : ae1702 ldx abs1
15bd : 08 php ;test stores do not alter flags
15be : 8a txa
15bf : 49c3 eor #$c3
15c1 : aa tax
15c2 : 28 plp
15c3 : 8602 stx zpt
15c5 : 08 php ;flags after load/store sequence
15c6 : 49c3 eor #$c3
15c8 : aa tax
15c9 : e409 cpx zp1 ;test result
trap_ne
15cb : d0fe > bne * ;failed not equal (non zero)
15cd : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
15ce : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
15d0 : cd1c02 cmp fLDx ;test flags
trap_ne
15d3 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
15d5 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
15d7 : 48 > pha ;use stack to load status
15d8 : 28 > plp
15d9 : ae1802 ldx abs1+1
15dc : 08 php ;test stores do not alter flags
15dd : 8a txa
15de : 49c3 eor #$c3
15e0 : aa tax
15e1 : 28 plp
15e2 : 8603 stx zpt+1
15e4 : 08 php ;flags after load/store sequence
15e5 : 49c3 eor #$c3
15e7 : aa tax
15e8 : e40a cpx zp1+1 ;test result
trap_ne
15ea : d0fe > bne * ;failed not equal (non zero)
15ec : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
15ed : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
15ef : cd1d02 cmp fLDx+1 ;test flags
trap_ne
15f2 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
15f4 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
15f6 : 48 > pha ;use stack to load status
15f7 : 28 > plp
15f8 : ae1902 ldx abs1+2
15fb : 08 php ;test stores do not alter flags
15fc : 8a txa
15fd : 49c3 eor #$c3
15ff : aa tax
1600 : 28 plp
1601 : 8604 stx zpt+2
1603 : 08 php ;flags after load/store sequence
1604 : 49c3 eor #$c3
1606 : aa tax
1607 : e40b cpx zp1+2 ;test result
trap_ne
1609 : d0fe > bne * ;failed not equal (non zero)
160b : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
160c : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
160e : cd1e02 cmp fLDx+2 ;test flags
trap_ne
1611 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1613 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1615 : 48 > pha ;use stack to load status
1616 : 28 > plp
1617 : ae1a02 ldx abs1+3
161a : 08 php ;test stores do not alter flags
161b : 8a txa
161c : 49c3 eor #$c3
161e : aa tax
161f : 28 plp
1620 : 8605 stx zpt+3
1622 : 08 php ;flags after load/store sequence
1623 : 49c3 eor #$c3
1625 : aa tax
1626 : e40c cpx zp1+3 ;test result
trap_ne
1628 : d0fe > bne * ;failed not equal (non zero)
162a : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
162b : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
162d : cd1f02 cmp fLDx+3 ;test flags
trap_ne
1630 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1632 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1634 : 48 > pha ;use stack to load status
1635 : 28 > plp
1636 : a2c3 ldx #$c3
1638 : 08 php
1639 : ec1702 cpx abs1 ;test result
trap_ne
163c : d0fe > bne * ;failed not equal (non zero)
163e : 68 pla ;load status
eor_flag 0
163f : 4930 > eor #0|fao ;invert expected flags + always on bits
1641 : cd1c02 cmp fLDx ;test flags
trap_ne
1644 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1646 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1648 : 48 > pha ;use stack to load status
1649 : 28 > plp
164a : a282 ldx #$82
164c : 08 php
164d : ec1802 cpx abs1+1 ;test result
trap_ne
1650 : d0fe > bne * ;failed not equal (non zero)
1652 : 68 pla ;load status
eor_flag 0
1653 : 4930 > eor #0|fao ;invert expected flags + always on bits
1655 : cd1d02 cmp fLDx+1 ;test flags
trap_ne
1658 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
165a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
165c : 48 > pha ;use stack to load status
165d : 28 > plp
165e : a241 ldx #$41
1660 : 08 php
1661 : ec1902 cpx abs1+2 ;test result
trap_ne
1664 : d0fe > bne * ;failed not equal (non zero)
1666 : 68 pla ;load status
eor_flag 0
1667 : 4930 > eor #0|fao ;invert expected flags + always on bits
1669 : cd1e02 cmp fLDx+2 ;test flags
trap_ne
166c : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
166e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1670 : 48 > pha ;use stack to load status
1671 : 28 > plp
1672 : a200 ldx #0
1674 : 08 php
1675 : ec1a02 cpx abs1+3 ;test result
trap_ne
1678 : d0fe > bne * ;failed not equal (non zero)
167a : 68 pla ;load status
eor_flag 0
167b : 4930 > eor #0|fao ;invert expected flags + always on bits
167d : cd1f02 cmp fLDx+3 ;test flags
trap_ne
1680 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1682 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1684 : 48 > pha ;use stack to load status
1685 : 28 > plp
1686 : a2c3 ldx #$c3
1688 : 08 php
1689 : ec1702 cpx abs1 ;test result
trap_ne
168c : d0fe > bne * ;failed not equal (non zero)
168e : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
168f : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1691 : cd1c02 cmp fLDx ;test flags
trap_ne
1694 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1696 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1698 : 48 > pha ;use stack to load status
1699 : 28 > plp
169a : a282 ldx #$82
169c : 08 php
169d : ec1802 cpx abs1+1 ;test result
trap_ne
16a0 : d0fe > bne * ;failed not equal (non zero)
16a2 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
16a3 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
16a5 : cd1d02 cmp fLDx+1 ;test flags
trap_ne
16a8 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
16aa : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
16ac : 48 > pha ;use stack to load status
16ad : 28 > plp
16ae : a241 ldx #$41
16b0 : 08 php
16b1 : ec1902 cpx abs1+2 ;test result
trap_ne
16b4 : d0fe > bne * ;failed not equal (non zero)
16b6 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
16b7 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
16b9 : cd1e02 cmp fLDx+2 ;test flags
trap_ne
16bc : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
16be : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
16c0 : 48 > pha ;use stack to load status
16c1 : 28 > plp
16c2 : a200 ldx #0
16c4 : 08 php
16c5 : ec1a02 cpx abs1+3 ;test result
trap_ne
16c8 : d0fe > bne * ;failed not equal (non zero)
16ca : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
16cb : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
16cd : cd1f02 cmp fLDx+3 ;test flags
trap_ne
16d0 : d0fe > bne * ;failed not equal (non zero)
16d2 : a200 ldx #0
16d4 : a502 lda zpt
16d6 : 49c3 eor #$c3
16d8 : c509 cmp zp1
trap_ne ;store to zp data
16da : d0fe > bne * ;failed not equal (non zero)
16dc : 8602 stx zpt ;clear
16de : ad0302 lda abst
16e1 : 49c3 eor #$c3
16e3 : cd1702 cmp abs1
trap_ne ;store to abs data
16e6 : d0fe > bne * ;failed not equal (non zero)
16e8 : 8e0302 stx abst ;clear
16eb : a503 lda zpt+1
16ed : 49c3 eor #$c3
16ef : c50a cmp zp1+1
trap_ne ;store to zp data
16f1 : d0fe > bne * ;failed not equal (non zero)
16f3 : 8603 stx zpt+1 ;clear
16f5 : ad0402 lda abst+1
16f8 : 49c3 eor #$c3
16fa : cd1802 cmp abs1+1
trap_ne ;store to abs data
16fd : d0fe > bne * ;failed not equal (non zero)
16ff : 8e0402 stx abst+1 ;clear
1702 : a504 lda zpt+2
1704 : 49c3 eor #$c3
1706 : c50b cmp zp1+2
trap_ne ;store to zp data
1708 : d0fe > bne * ;failed not equal (non zero)
170a : 8604 stx zpt+2 ;clear
170c : ad0502 lda abst+2
170f : 49c3 eor #$c3
1711 : cd1902 cmp abs1+2
trap_ne ;store to abs data
1714 : d0fe > bne * ;failed not equal (non zero)
1716 : 8e0502 stx abst+2 ;clear
1719 : a505 lda zpt+3
171b : 49c3 eor #$c3
171d : c50c cmp zp1+3
trap_ne ;store to zp data
171f : d0fe > bne * ;failed not equal (non zero)
1721 : 8605 stx zpt+3 ;clear
1723 : ad0602 lda abst+3
1726 : 49c3 eor #$c3
1728 : cd1a02 cmp abs1+3
trap_ne ;store to abs data
172b : d0fe > bne * ;failed not equal (non zero)
172d : 8e0602 stx abst+3 ;clear
next_test
1730 : ad0002 > lda test_case ;previous test
1733 : c913 > cmp #test_num
> trap_ne ;test is out of sequence
1735 : d0fe > bne * ;failed not equal (non zero)
>
0014 = >test_num = test_num + 1
1737 : a914 > lda #test_num ;*** next tests' number
1739 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; LDY / STY - zp / abs / #
set_stat 0
> load_flag 0
173c : a900 > lda #0 ;allow test to change I-flag (no mask)
>
173e : 48 > pha ;use stack to load status
173f : 28 > plp
1740 : a409 ldy zp1
1742 : 08 php ;test stores do not alter flags
1743 : 98 tya
1744 : 49c3 eor #$c3
1746 : a8 tay
1747 : 28 plp
1748 : 8c0302 sty abst
174b : 08 php ;flags after load/store sequence
174c : 49c3 eor #$c3
174e : a8 tay
174f : c0c3 cpy #$c3 ;test result
trap_ne
1751 : d0fe > bne * ;failed not equal (non zero)
1753 : 68 pla ;load status
eor_flag 0
1754 : 4930 > eor #0|fao ;invert expected flags + always on bits
1756 : cd1c02 cmp fLDx ;test flags
trap_ne
1759 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
175b : a900 > lda #0 ;allow test to change I-flag (no mask)
>
175d : 48 > pha ;use stack to load status
175e : 28 > plp
175f : a40a ldy zp1+1
1761 : 08 php ;test stores do not alter flags
1762 : 98 tya
1763 : 49c3 eor #$c3
1765 : a8 tay
1766 : 28 plp
1767 : 8c0402 sty abst+1
176a : 08 php ;flags after load/store sequence
176b : 49c3 eor #$c3
176d : a8 tay
176e : c082 cpy #$82 ;test result
trap_ne
1770 : d0fe > bne * ;failed not equal (non zero)
1772 : 68 pla ;load status
eor_flag 0
1773 : 4930 > eor #0|fao ;invert expected flags + always on bits
1775 : cd1d02 cmp fLDx+1 ;test flags
trap_ne
1778 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
177a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
177c : 48 > pha ;use stack to load status
177d : 28 > plp
177e : a40b ldy zp1+2
1780 : 08 php ;test stores do not alter flags
1781 : 98 tya
1782 : 49c3 eor #$c3
1784 : a8 tay
1785 : 28 plp
1786 : 8c0502 sty abst+2
1789 : 08 php ;flags after load/store sequence
178a : 49c3 eor #$c3
178c : a8 tay
178d : c041 cpy #$41 ;test result
trap_ne
178f : d0fe > bne * ;failed not equal (non zero)
1791 : 68 pla ;load status
eor_flag 0
1792 : 4930 > eor #0|fao ;invert expected flags + always on bits
1794 : cd1e02 cmp fLDx+2 ;test flags
trap_ne
1797 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1799 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
179b : 48 > pha ;use stack to load status
179c : 28 > plp
179d : a40c ldy zp1+3
179f : 08 php ;test stores do not alter flags
17a0 : 98 tya
17a1 : 49c3 eor #$c3
17a3 : a8 tay
17a4 : 28 plp
17a5 : 8c0602 sty abst+3
17a8 : 08 php ;flags after load/store sequence
17a9 : 49c3 eor #$c3
17ab : a8 tay
17ac : c000 cpy #0 ;test result
trap_ne
17ae : d0fe > bne * ;failed not equal (non zero)
17b0 : 68 pla ;load status
eor_flag 0
17b1 : 4930 > eor #0|fao ;invert expected flags + always on bits
17b3 : cd1f02 cmp fLDx+3 ;test flags
trap_ne
17b6 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
17b8 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
17ba : 48 > pha ;use stack to load status
17bb : 28 > plp
17bc : a409 ldy zp1
17be : 08 php ;test stores do not alter flags
17bf : 98 tya
17c0 : 49c3 eor #$c3
17c2 : a8 tay
17c3 : 28 plp
17c4 : 8c0302 sty abst
17c7 : 08 php ;flags after load/store sequence
17c8 : 49c3 eor #$c3
17ca : a8 tay
17cb : c0c3 cpy #$c3 ;test result
trap_ne
17cd : d0fe > bne * ;failed not equal (non zero)
17cf : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
17d0 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
17d2 : cd1c02 cmp fLDx ;test flags
trap_ne
17d5 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
17d7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
17d9 : 48 > pha ;use stack to load status
17da : 28 > plp
17db : a40a ldy zp1+1
17dd : 08 php ;test stores do not alter flags
17de : 98 tya
17df : 49c3 eor #$c3
17e1 : a8 tay
17e2 : 28 plp
17e3 : 8c0402 sty abst+1
17e6 : 08 php ;flags after load/store sequence
17e7 : 49c3 eor #$c3
17e9 : a8 tay
17ea : c082 cpy #$82 ;test result
trap_ne
17ec : d0fe > bne * ;failed not equal (non zero)
17ee : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
17ef : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
17f1 : cd1d02 cmp fLDx+1 ;test flags
trap_ne
17f4 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
17f6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
17f8 : 48 > pha ;use stack to load status
17f9 : 28 > plp
17fa : a40b ldy zp1+2
17fc : 08 php ;test stores do not alter flags
17fd : 98 tya
17fe : 49c3 eor #$c3
1800 : a8 tay
1801 : 28 plp
1802 : 8c0502 sty abst+2
1805 : 08 php ;flags after load/store sequence
1806 : 49c3 eor #$c3
1808 : a8 tay
1809 : c041 cpy #$41 ;test result
trap_ne
180b : d0fe > bne * ;failed not equal (non zero)
180d : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
180e : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1810 : cd1e02 cmp fLDx+2 ;test flags
trap_ne
1813 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1815 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1817 : 48 > pha ;use stack to load status
1818 : 28 > plp
1819 : a40c ldy zp1+3
181b : 08 php ;test stores do not alter flags
181c : 98 tya
181d : 49c3 eor #$c3
181f : a8 tay
1820 : 28 plp
1821 : 8c0602 sty abst+3
1824 : 08 php ;flags after load/store sequence
1825 : 49c3 eor #$c3
1827 : a8 tay
1828 : c000 cpy #0 ;test result
trap_ne
182a : d0fe > bne * ;failed not equal (non zero)
182c : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
182d : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
182f : cd1f02 cmp fLDx+3 ;test flags
trap_ne
1832 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1834 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1836 : 48 > pha ;use stack to load status
1837 : 28 > plp
1838 : ac1702 ldy abs1
183b : 08 php ;test stores do not alter flags
183c : 98 tya
183d : 49c3 eor #$c3
183f : a8 tay
1840 : 28 plp
1841 : 8402 sty zpt
1843 : 08 php ;flags after load/store sequence
1844 : 49c3 eor #$c3
1846 : a8 tay
1847 : c409 cpy zp1 ;test result
trap_ne
1849 : d0fe > bne * ;failed not equal (non zero)
184b : 68 pla ;load status
eor_flag 0
184c : 4930 > eor #0|fao ;invert expected flags + always on bits
184e : cd1c02 cmp fLDx ;test flags
trap_ne
1851 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1853 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1855 : 48 > pha ;use stack to load status
1856 : 28 > plp
1857 : ac1802 ldy abs1+1
185a : 08 php ;test stores do not alter flags
185b : 98 tya
185c : 49c3 eor #$c3
185e : a8 tay
185f : 28 plp
1860 : 8403 sty zpt+1
1862 : 08 php ;flags after load/store sequence
1863 : 49c3 eor #$c3
1865 : a8 tay
1866 : c40a cpy zp1+1 ;test result
trap_ne
1868 : d0fe > bne * ;failed not equal (non zero)
186a : 68 pla ;load status
eor_flag 0
186b : 4930 > eor #0|fao ;invert expected flags + always on bits
186d : cd1d02 cmp fLDx+1 ;test flags
trap_ne
1870 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1872 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1874 : 48 > pha ;use stack to load status
1875 : 28 > plp
1876 : ac1902 ldy abs1+2
1879 : 08 php ;test stores do not alter flags
187a : 98 tya
187b : 49c3 eor #$c3
187d : a8 tay
187e : 28 plp
187f : 8404 sty zpt+2
1881 : 08 php ;flags after load/store sequence
1882 : 49c3 eor #$c3
1884 : a8 tay
1885 : c40b cpy zp1+2 ;test result
trap_ne
1887 : d0fe > bne * ;failed not equal (non zero)
1889 : 68 pla ;load status
eor_flag 0
188a : 4930 > eor #0|fao ;invert expected flags + always on bits
188c : cd1e02 cmp fLDx+2 ;test flags
trap_ne
188f : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1891 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1893 : 48 > pha ;use stack to load status
1894 : 28 > plp
1895 : ac1a02 ldy abs1+3
1898 : 08 php ;test stores do not alter flags
1899 : 98 tya
189a : 49c3 eor #$c3
189c : a8 tay
189d : 28 plp
189e : 8405 sty zpt+3
18a0 : 08 php ;flags after load/store sequence
18a1 : 49c3 eor #$c3
18a3 : a8 tay
18a4 : c40c cpy zp1+3 ;test result
trap_ne
18a6 : d0fe > bne * ;failed not equal (non zero)
18a8 : 68 pla ;load status
eor_flag 0
18a9 : 4930 > eor #0|fao ;invert expected flags + always on bits
18ab : cd1f02 cmp fLDx+3 ;test flags
trap_ne
18ae : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
18b0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
18b2 : 48 > pha ;use stack to load status
18b3 : 28 > plp
18b4 : ac1702 ldy abs1
18b7 : 08 php ;test stores do not alter flags
18b8 : 98 tya
18b9 : 49c3 eor #$c3
18bb : a8 tay
18bc : 28 plp
18bd : 8402 sty zpt
18bf : 08 php ;flags after load/store sequence
18c0 : 49c3 eor #$c3
18c2 : a8 tay
18c3 : c509 cmp zp1 ;test result
trap_ne
18c5 : d0fe > bne * ;failed not equal (non zero)
18c7 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
18c8 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
18ca : cd1c02 cmp fLDx ;test flags
trap_ne
18cd : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
18cf : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
18d1 : 48 > pha ;use stack to load status
18d2 : 28 > plp
18d3 : ac1802 ldy abs1+1
18d6 : 08 php ;test stores do not alter flags
18d7 : 98 tya
18d8 : 49c3 eor #$c3
18da : a8 tay
18db : 28 plp
18dc : 8403 sty zpt+1
18de : 08 php ;flags after load/store sequence
18df : 49c3 eor #$c3
18e1 : a8 tay
18e2 : c50a cmp zp1+1 ;test result
trap_ne
18e4 : d0fe > bne * ;failed not equal (non zero)
18e6 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
18e7 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
18e9 : cd1d02 cmp fLDx+1 ;test flags
trap_ne
18ec : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
18ee : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
18f0 : 48 > pha ;use stack to load status
18f1 : 28 > plp
18f2 : ac1902 ldy abs1+2
18f5 : 08 php ;test stores do not alter flags
18f6 : 98 tya
18f7 : 49c3 eor #$c3
18f9 : a8 tay
18fa : 28 plp
18fb : 8404 sty zpt+2
18fd : 08 php ;flags after load/store sequence
18fe : 49c3 eor #$c3
1900 : a8 tay
1901 : c50b cmp zp1+2 ;test result
trap_ne
1903 : d0fe > bne * ;failed not equal (non zero)
1905 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1906 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1908 : cd1e02 cmp fLDx+2 ;test flags
trap_ne
190b : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
190d : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
190f : 48 > pha ;use stack to load status
1910 : 28 > plp
1911 : ac1a02 ldy abs1+3
1914 : 08 php ;test stores do not alter flags
1915 : 98 tya
1916 : 49c3 eor #$c3
1918 : a8 tay
1919 : 28 plp
191a : 8405 sty zpt+3
191c : 08 php ;flags after load/store sequence
191d : 49c3 eor #$c3
191f : a8 tay
1920 : c50c cmp zp1+3 ;test result
trap_ne
1922 : d0fe > bne * ;failed not equal (non zero)
1924 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1925 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1927 : cd1f02 cmp fLDx+3 ;test flags
trap_ne
192a : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
192c : a900 > lda #0 ;allow test to change I-flag (no mask)
>
192e : 48 > pha ;use stack to load status
192f : 28 > plp
1930 : a0c3 ldy #$c3
1932 : 08 php
1933 : cc1702 cpy abs1 ;test result
trap_ne
1936 : d0fe > bne * ;failed not equal (non zero)
1938 : 68 pla ;load status
eor_flag 0
1939 : 4930 > eor #0|fao ;invert expected flags + always on bits
193b : cd1c02 cmp fLDx ;test flags
trap_ne
193e : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1940 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1942 : 48 > pha ;use stack to load status
1943 : 28 > plp
1944 : a082 ldy #$82
1946 : 08 php
1947 : cc1802 cpy abs1+1 ;test result
trap_ne
194a : d0fe > bne * ;failed not equal (non zero)
194c : 68 pla ;load status
eor_flag 0
194d : 4930 > eor #0|fao ;invert expected flags + always on bits
194f : cd1d02 cmp fLDx+1 ;test flags
trap_ne
1952 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1954 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1956 : 48 > pha ;use stack to load status
1957 : 28 > plp
1958 : a041 ldy #$41
195a : 08 php
195b : cc1902 cpy abs1+2 ;test result
trap_ne
195e : d0fe > bne * ;failed not equal (non zero)
1960 : 68 pla ;load status
eor_flag 0
1961 : 4930 > eor #0|fao ;invert expected flags + always on bits
1963 : cd1e02 cmp fLDx+2 ;test flags
trap_ne
1966 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1968 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
196a : 48 > pha ;use stack to load status
196b : 28 > plp
196c : a000 ldy #0
196e : 08 php
196f : cc1a02 cpy abs1+3 ;test result
trap_ne
1972 : d0fe > bne * ;failed not equal (non zero)
1974 : 68 pla ;load status
eor_flag 0
1975 : 4930 > eor #0|fao ;invert expected flags + always on bits
1977 : cd1f02 cmp fLDx+3 ;test flags
trap_ne
197a : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
197c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
197e : 48 > pha ;use stack to load status
197f : 28 > plp
1980 : a0c3 ldy #$c3
1982 : 08 php
1983 : cc1702 cpy abs1 ;test result
trap_ne
1986 : d0fe > bne * ;failed not equal (non zero)
1988 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1989 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
198b : cd1c02 cmp fLDx ;test flags
trap_ne
198e : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1990 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1992 : 48 > pha ;use stack to load status
1993 : 28 > plp
1994 : a082 ldy #$82
1996 : 08 php
1997 : cc1802 cpy abs1+1 ;test result
trap_ne
199a : d0fe > bne * ;failed not equal (non zero)
199c : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
199d : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
199f : cd1d02 cmp fLDx+1 ;test flags
trap_ne
19a2 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
19a4 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
19a6 : 48 > pha ;use stack to load status
19a7 : 28 > plp
19a8 : a041 ldy #$41
19aa : 08 php
19ab : cc1902 cpy abs1+2 ;test result
trap_ne
19ae : d0fe > bne * ;failed not equal (non zero)
19b0 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
19b1 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
19b3 : cd1e02 cmp fLDx+2 ;test flags
trap_ne
19b6 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
19b8 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
19ba : 48 > pha ;use stack to load status
19bb : 28 > plp
19bc : a000 ldy #0
19be : 08 php
19bf : cc1a02 cpy abs1+3 ;test result
trap_ne
19c2 : d0fe > bne * ;failed not equal (non zero)
19c4 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
19c5 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
19c7 : cd1f02 cmp fLDx+3 ;test flags
trap_ne
19ca : d0fe > bne * ;failed not equal (non zero)
19cc : a000 ldy #0
19ce : a502 lda zpt
19d0 : 49c3 eor #$c3
19d2 : c509 cmp zp1
trap_ne ;store to zp data
19d4 : d0fe > bne * ;failed not equal (non zero)
19d6 : 8402 sty zpt ;clear
19d8 : ad0302 lda abst
19db : 49c3 eor #$c3
19dd : cd1702 cmp abs1
trap_ne ;store to abs data
19e0 : d0fe > bne * ;failed not equal (non zero)
19e2 : 8c0302 sty abst ;clear
19e5 : a503 lda zpt+1
19e7 : 49c3 eor #$c3
19e9 : c50a cmp zp1+1
trap_ne ;store to zp+1 data
19eb : d0fe > bne * ;failed not equal (non zero)
19ed : 8403 sty zpt+1 ;clear
19ef : ad0402 lda abst+1
19f2 : 49c3 eor #$c3
19f4 : cd1802 cmp abs1+1
trap_ne ;store to abs+1 data
19f7 : d0fe > bne * ;failed not equal (non zero)
19f9 : 8c0402 sty abst+1 ;clear
19fc : a504 lda zpt+2
19fe : 49c3 eor #$c3
1a00 : c50b cmp zp1+2
trap_ne ;store to zp+2 data
1a02 : d0fe > bne * ;failed not equal (non zero)
1a04 : 8404 sty zpt+2 ;clear
1a06 : ad0502 lda abst+2
1a09 : 49c3 eor #$c3
1a0b : cd1902 cmp abs1+2
trap_ne ;store to abs+2 data
1a0e : d0fe > bne * ;failed not equal (non zero)
1a10 : 8c0502 sty abst+2 ;clear
1a13 : a505 lda zpt+3
1a15 : 49c3 eor #$c3
1a17 : c50c cmp zp1+3
trap_ne ;store to zp+3 data
1a19 : d0fe > bne * ;failed not equal (non zero)
1a1b : 8405 sty zpt+3 ;clear
1a1d : ad0602 lda abst+3
1a20 : 49c3 eor #$c3
1a22 : cd1a02 cmp abs1+3
trap_ne ;store to abs+3 data
1a25 : d0fe > bne * ;failed not equal (non zero)
1a27 : 8c0602 sty abst+3 ;clear
next_test
1a2a : ad0002 > lda test_case ;previous test
1a2d : c914 > cmp #test_num
> trap_ne ;test is out of sequence
1a2f : d0fe > bne * ;failed not equal (non zero)
>
0015 = >test_num = test_num + 1
1a31 : a915 > lda #test_num ;*** next tests' number
1a33 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; testing load / store accumulator LDA / STA all addressing modes
; LDA / STA - zp,x / abs,x
1a36 : a203 ldx #3
1a38 : tldax
set_stat 0
> load_flag 0
1a38 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1a3a : 48 > pha ;use stack to load status
1a3b : 28 > plp
1a3c : b509 lda zp1,x
1a3e : 08 php ;test stores do not alter flags
1a3f : 49c3 eor #$c3
1a41 : 28 plp
1a42 : 9d0302 sta abst,x
1a45 : 08 php ;flags after load/store sequence
1a46 : 49c3 eor #$c3
1a48 : dd1702 cmp abs1,x ;test result
trap_ne
1a4b : d0fe > bne * ;failed not equal (non zero)
1a4d : 68 pla ;load status
eor_flag 0
1a4e : 4930 > eor #0|fao ;invert expected flags + always on bits
1a50 : dd1c02 cmp fLDx,x ;test flags
trap_ne
1a53 : d0fe > bne * ;failed not equal (non zero)
1a55 : ca dex
1a56 : 10e0 bpl tldax
1a58 : a203 ldx #3
1a5a : tldax1
set_stat $ff
> load_flag $ff
1a5a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1a5c : 48 > pha ;use stack to load status
1a5d : 28 > plp
1a5e : b509 lda zp1,x
1a60 : 08 php ;test stores do not alter flags
1a61 : 49c3 eor #$c3
1a63 : 28 plp
1a64 : 9d0302 sta abst,x
1a67 : 08 php ;flags after load/store sequence
1a68 : 49c3 eor #$c3
1a6a : dd1702 cmp abs1,x ;test result
trap_ne
1a6d : d0fe > bne * ;failed not equal (non zero)
1a6f : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1a70 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1a72 : dd1c02 cmp fLDx,x ;test flags
trap_ne
1a75 : d0fe > bne * ;failed not equal (non zero)
1a77 : ca dex
1a78 : 10e0 bpl tldax1
1a7a : a203 ldx #3
1a7c : tldax2
set_stat 0
> load_flag 0
1a7c : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1a7e : 48 > pha ;use stack to load status
1a7f : 28 > plp
1a80 : bd1702 lda abs1,x
1a83 : 08 php ;test stores do not alter flags
1a84 : 49c3 eor #$c3
1a86 : 28 plp
1a87 : 9502 sta zpt,x
1a89 : 08 php ;flags after load/store sequence
1a8a : 49c3 eor #$c3
1a8c : d509 cmp zp1,x ;test result
trap_ne
1a8e : d0fe > bne * ;failed not equal (non zero)
1a90 : 68 pla ;load status
eor_flag 0
1a91 : 4930 > eor #0|fao ;invert expected flags + always on bits
1a93 : dd1c02 cmp fLDx,x ;test flags
trap_ne
1a96 : d0fe > bne * ;failed not equal (non zero)
1a98 : ca dex
1a99 : 10e1 bpl tldax2
1a9b : a203 ldx #3
1a9d : tldax3
set_stat $ff
> load_flag $ff
1a9d : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1a9f : 48 > pha ;use stack to load status
1aa0 : 28 > plp
1aa1 : bd1702 lda abs1,x
1aa4 : 08 php ;test stores do not alter flags
1aa5 : 49c3 eor #$c3
1aa7 : 28 plp
1aa8 : 9502 sta zpt,x
1aaa : 08 php ;flags after load/store sequence
1aab : 49c3 eor #$c3
1aad : d509 cmp zp1,x ;test result
trap_ne
1aaf : d0fe > bne * ;failed not equal (non zero)
1ab1 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1ab2 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1ab4 : dd1c02 cmp fLDx,x ;test flags
trap_ne
1ab7 : d0fe > bne * ;failed not equal (non zero)
1ab9 : ca dex
1aba : 10e1 bpl tldax3
1abc : a203 ldx #3 ;testing store result
1abe : a000 ldy #0
1ac0 : b502 tstax lda zpt,x
1ac2 : 49c3 eor #$c3
1ac4 : d509 cmp zp1,x
trap_ne ;store to zp,x data
1ac6 : d0fe > bne * ;failed not equal (non zero)
1ac8 : 9402 sty zpt,x ;clear
1aca : bd0302 lda abst,x
1acd : 49c3 eor #$c3
1acf : dd1702 cmp abs1,x
trap_ne ;store to abs,x data
1ad2 : d0fe > bne * ;failed not equal (non zero)
1ad4 : 8a txa
1ad5 : 9d0302 sta abst,x ;clear
1ad8 : ca dex
1ad9 : 10e5 bpl tstax
next_test
1adb : ad0002 > lda test_case ;previous test
1ade : c915 > cmp #test_num
> trap_ne ;test is out of sequence
1ae0 : d0fe > bne * ;failed not equal (non zero)
>
0016 = >test_num = test_num + 1
1ae2 : a916 > lda #test_num ;*** next tests' number
1ae4 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; LDA / STA - (zp),y / abs,y / (zp,x)
1ae7 : a003 ldy #3
1ae9 : tlday
set_stat 0
> load_flag 0
1ae9 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1aeb : 48 > pha ;use stack to load status
1aec : 28 > plp
1aed : b11a lda (ind1),y
1aef : 08 php ;test stores do not alter flags
1af0 : 49c3 eor #$c3
1af2 : 28 plp
1af3 : 990302 sta abst,y
1af6 : 08 php ;flags after load/store sequence
1af7 : 49c3 eor #$c3
1af9 : d91702 cmp abs1,y ;test result
trap_ne
1afc : d0fe > bne * ;failed not equal (non zero)
1afe : 68 pla ;load status
eor_flag 0
1aff : 4930 > eor #0|fao ;invert expected flags + always on bits
1b01 : d91c02 cmp fLDx,y ;test flags
trap_ne
1b04 : d0fe > bne * ;failed not equal (non zero)
1b06 : 88 dey
1b07 : 10e0 bpl tlday
1b09 : a003 ldy #3
1b0b : tlday1
set_stat $ff
> load_flag $ff
1b0b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1b0d : 48 > pha ;use stack to load status
1b0e : 28 > plp
1b0f : b11a lda (ind1),y
1b11 : 08 php ;test stores do not alter flags
1b12 : 49c3 eor #$c3
1b14 : 28 plp
1b15 : 990302 sta abst,y
1b18 : 08 php ;flags after load/store sequence
1b19 : 49c3 eor #$c3
1b1b : d91702 cmp abs1,y ;test result
trap_ne
1b1e : d0fe > bne * ;failed not equal (non zero)
1b20 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1b21 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1b23 : d91c02 cmp fLDx,y ;test flags
trap_ne
1b26 : d0fe > bne * ;failed not equal (non zero)
1b28 : 88 dey
1b29 : 10e0 bpl tlday1
1b2b : a003 ldy #3 ;testing store result
1b2d : a200 ldx #0
1b2f : b90302 tstay lda abst,y
1b32 : 49c3 eor #$c3
1b34 : d91702 cmp abs1,y
trap_ne ;store to abs data
1b37 : d0fe > bne * ;failed not equal (non zero)
1b39 : 8a txa
1b3a : 990302 sta abst,y ;clear
1b3d : 88 dey
1b3e : 10ef bpl tstay
1b40 : a003 ldy #3
1b42 : tlday2
set_stat 0
> load_flag 0
1b42 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1b44 : 48 > pha ;use stack to load status
1b45 : 28 > plp
1b46 : b91702 lda abs1,y
1b49 : 08 php ;test stores do not alter flags
1b4a : 49c3 eor #$c3
1b4c : 28 plp
1b4d : 9126 sta (indt),y
1b4f : 08 php ;flags after load/store sequence
1b50 : 49c3 eor #$c3
1b52 : d11a cmp (ind1),y ;test result
trap_ne
1b54 : d0fe > bne * ;failed not equal (non zero)
1b56 : 68 pla ;load status
eor_flag 0
1b57 : 4930 > eor #0|fao ;invert expected flags + always on bits
1b59 : d91c02 cmp fLDx,y ;test flags
trap_ne
1b5c : d0fe > bne * ;failed not equal (non zero)
1b5e : 88 dey
1b5f : 10e1 bpl tlday2
1b61 : a003 ldy #3
1b63 : tlday3
set_stat $ff
> load_flag $ff
1b63 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1b65 : 48 > pha ;use stack to load status
1b66 : 28 > plp
1b67 : b91702 lda abs1,y
1b6a : 08 php ;test stores do not alter flags
1b6b : 49c3 eor #$c3
1b6d : 28 plp
1b6e : 9126 sta (indt),y
1b70 : 08 php ;flags after load/store sequence
1b71 : 49c3 eor #$c3
1b73 : d11a cmp (ind1),y ;test result
trap_ne
1b75 : d0fe > bne * ;failed not equal (non zero)
1b77 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1b78 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1b7a : d91c02 cmp fLDx,y ;test flags
trap_ne
1b7d : d0fe > bne * ;failed not equal (non zero)
1b7f : 88 dey
1b80 : 10e1 bpl tlday3
1b82 : a003 ldy #3 ;testing store result
1b84 : a200 ldx #0
1b86 : b90302 tstay1 lda abst,y
1b89 : 49c3 eor #$c3
1b8b : d91702 cmp abs1,y
trap_ne ;store to abs data
1b8e : d0fe > bne * ;failed not equal (non zero)
1b90 : 8a txa
1b91 : 990302 sta abst,y ;clear
1b94 : 88 dey
1b95 : 10ef bpl tstay1
1b97 : a206 ldx #6
1b99 : a003 ldy #3
1b9b : tldax4
set_stat 0
> load_flag 0
1b9b : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1b9d : 48 > pha ;use stack to load status
1b9e : 28 > plp
1b9f : a11a lda (ind1,x)
1ba1 : 08 php ;test stores do not alter flags
1ba2 : 49c3 eor #$c3
1ba4 : 28 plp
1ba5 : 8126 sta (indt,x)
1ba7 : 08 php ;flags after load/store sequence
1ba8 : 49c3 eor #$c3
1baa : d91702 cmp abs1,y ;test result
trap_ne
1bad : d0fe > bne * ;failed not equal (non zero)
1baf : 68 pla ;load status
eor_flag 0
1bb0 : 4930 > eor #0|fao ;invert expected flags + always on bits
1bb2 : d91c02 cmp fLDx,y ;test flags
trap_ne
1bb5 : d0fe > bne * ;failed not equal (non zero)
1bb7 : ca dex
1bb8 : ca dex
1bb9 : 88 dey
1bba : 10df bpl tldax4
1bbc : a206 ldx #6
1bbe : a003 ldy #3
1bc0 : tldax5
set_stat $ff
> load_flag $ff
1bc0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1bc2 : 48 > pha ;use stack to load status
1bc3 : 28 > plp
1bc4 : a11a lda (ind1,x)
1bc6 : 08 php ;test stores do not alter flags
1bc7 : 49c3 eor #$c3
1bc9 : 28 plp
1bca : 8126 sta (indt,x)
1bcc : 08 php ;flags after load/store sequence
1bcd : 49c3 eor #$c3
1bcf : d91702 cmp abs1,y ;test result
trap_ne
1bd2 : d0fe > bne * ;failed not equal (non zero)
1bd4 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1bd5 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1bd7 : d91c02 cmp fLDx,y ;test flags
trap_ne
1bda : d0fe > bne * ;failed not equal (non zero)
1bdc : ca dex
1bdd : ca dex
1bde : 88 dey
1bdf : 10df bpl tldax5
1be1 : a003 ldy #3 ;testing store result
1be3 : a200 ldx #0
1be5 : b90302 tstay2 lda abst,y
1be8 : 49c3 eor #$c3
1bea : d91702 cmp abs1,y
trap_ne ;store to abs data
1bed : d0fe > bne * ;failed not equal (non zero)
1bef : 8a txa
1bf0 : 990302 sta abst,y ;clear
1bf3 : 88 dey
1bf4 : 10ef bpl tstay2
next_test
1bf6 : ad0002 > lda test_case ;previous test
1bf9 : c916 > cmp #test_num
> trap_ne ;test is out of sequence
1bfb : d0fe > bne * ;failed not equal (non zero)
>
0017 = >test_num = test_num + 1
1bfd : a917 > lda #test_num ;*** next tests' number
1bff : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; indexed wraparound test (only zp should wrap)
1c02 : a2fd ldx #3+$fa
1c04 : b50f tldax6 lda zp1-$fa&$ff,x ;wrap on indexed zp
1c06 : 9d0901 sta abst-$fa,x ;no STX abs,x!
1c09 : ca dex
1c0a : e0fa cpx #$fa
1c0c : b0f6 bcs tldax6
1c0e : a2fd ldx #3+$fa
1c10 : bd1d01 tldax7 lda abs1-$fa,x ;no wrap on indexed abs
1c13 : 9508 sta zpt-$fa&$ff,x
1c15 : ca dex
1c16 : e0fa cpx #$fa
1c18 : b0f6 bcs tldax7
1c1a : a203 ldx #3 ;testing wraparound result
1c1c : a000 ldy #0
1c1e : b502 tstax1 lda zpt,x
1c20 : d509 cmp zp1,x
trap_ne ;store to zp,x data
1c22 : d0fe > bne * ;failed not equal (non zero)
1c24 : 9402 sty zpt,x ;clear
1c26 : bd0302 lda abst,x
1c29 : dd1702 cmp abs1,x
trap_ne ;store to abs,x data
1c2c : d0fe > bne * ;failed not equal (non zero)
1c2e : 8a txa
1c2f : 9d0302 sta abst,x ;clear
1c32 : ca dex
1c33 : 10e9 bpl tstax1
1c35 : a0fb ldy #3+$f8
1c37 : a2fe ldx #6+$f8
1c39 : a122 tlday4 lda (ind1-$f8&$ff,x) ;wrap on indexed zp indirect
1c3b : 990b01 sta abst-$f8,y
1c3e : ca dex
1c3f : ca dex
1c40 : 88 dey
1c41 : c0f8 cpy #$f8
1c43 : b0f4 bcs tlday4
1c45 : a003 ldy #3 ;testing wraparound result
1c47 : a200 ldx #0
1c49 : b90302 tstay4 lda abst,y
1c4c : d91702 cmp abs1,y
trap_ne ;store to abs data
1c4f : d0fe > bne * ;failed not equal (non zero)
1c51 : 8a txa
1c52 : 990302 sta abst,y ;clear
1c55 : 88 dey
1c56 : 10f1 bpl tstay4
1c58 : a0fb ldy #3+$f8
1c5a : b91f01 tlday5 lda abs1-$f8,y ;no wrap on indexed abs
1c5d : 912e sta (inwt),y
1c5f : 88 dey
1c60 : c0f8 cpy #$f8
1c62 : b0f6 bcs tlday5
1c64 : a003 ldy #3 ;testing wraparound result
1c66 : a200 ldx #0
1c68 : b90302 tstay5 lda abst,y
1c6b : d91702 cmp abs1,y
trap_ne ;store to abs data
1c6e : d0fe > bne * ;failed not equal (non zero)
1c70 : 8a txa
1c71 : 990302 sta abst,y ;clear
1c74 : 88 dey
1c75 : 10f1 bpl tstay5
1c77 : a0fb ldy #3+$f8
1c79 : a2fe ldx #6+$f8
1c7b : b124 tlday6 lda (inw1),y ;no wrap on zp indirect indexed
1c7d : 812e sta (indt-$f8&$ff,x)
1c7f : ca dex
1c80 : ca dex
1c81 : 88 dey
1c82 : c0f8 cpy #$f8
1c84 : b0f5 bcs tlday6
1c86 : a003 ldy #3 ;testing wraparound result
1c88 : a200 ldx #0
1c8a : b90302 tstay6 lda abst,y
1c8d : d91702 cmp abs1,y
trap_ne ;store to abs data
1c90 : d0fe > bne * ;failed not equal (non zero)
1c92 : 8a txa
1c93 : 990302 sta abst,y ;clear
1c96 : 88 dey
1c97 : 10f1 bpl tstay6
next_test
1c99 : ad0002 > lda test_case ;previous test
1c9c : c917 > cmp #test_num
> trap_ne ;test is out of sequence
1c9e : d0fe > bne * ;failed not equal (non zero)
>
0018 = >test_num = test_num + 1
1ca0 : a918 > lda #test_num ;*** next tests' number
1ca2 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; LDA / STA - zp / abs / #
set_stat 0
> load_flag 0
1ca5 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1ca7 : 48 > pha ;use stack to load status
1ca8 : 28 > plp
1ca9 : a509 lda zp1
1cab : 08 php ;test stores do not alter flags
1cac : 49c3 eor #$c3
1cae : 28 plp
1caf : 8d0302 sta abst
1cb2 : 08 php ;flags after load/store sequence
1cb3 : 49c3 eor #$c3
1cb5 : c9c3 cmp #$c3 ;test result
trap_ne
1cb7 : d0fe > bne * ;failed not equal (non zero)
1cb9 : 68 pla ;load status
eor_flag 0
1cba : 4930 > eor #0|fao ;invert expected flags + always on bits
1cbc : cd1c02 cmp fLDx ;test flags
trap_ne
1cbf : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1cc1 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1cc3 : 48 > pha ;use stack to load status
1cc4 : 28 > plp
1cc5 : a50a lda zp1+1
1cc7 : 08 php ;test stores do not alter flags
1cc8 : 49c3 eor #$c3
1cca : 28 plp
1ccb : 8d0402 sta abst+1
1cce : 08 php ;flags after load/store sequence
1ccf : 49c3 eor #$c3
1cd1 : c982 cmp #$82 ;test result
trap_ne
1cd3 : d0fe > bne * ;failed not equal (non zero)
1cd5 : 68 pla ;load status
eor_flag 0
1cd6 : 4930 > eor #0|fao ;invert expected flags + always on bits
1cd8 : cd1d02 cmp fLDx+1 ;test flags
trap_ne
1cdb : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1cdd : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1cdf : 48 > pha ;use stack to load status
1ce0 : 28 > plp
1ce1 : a50b lda zp1+2
1ce3 : 08 php ;test stores do not alter flags
1ce4 : 49c3 eor #$c3
1ce6 : 28 plp
1ce7 : 8d0502 sta abst+2
1cea : 08 php ;flags after load/store sequence
1ceb : 49c3 eor #$c3
1ced : c941 cmp #$41 ;test result
trap_ne
1cef : d0fe > bne * ;failed not equal (non zero)
1cf1 : 68 pla ;load status
eor_flag 0
1cf2 : 4930 > eor #0|fao ;invert expected flags + always on bits
1cf4 : cd1e02 cmp fLDx+2 ;test flags
trap_ne
1cf7 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1cf9 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1cfb : 48 > pha ;use stack to load status
1cfc : 28 > plp
1cfd : a50c lda zp1+3
1cff : 08 php ;test stores do not alter flags
1d00 : 49c3 eor #$c3
1d02 : 28 plp
1d03 : 8d0602 sta abst+3
1d06 : 08 php ;flags after load/store sequence
1d07 : 49c3 eor #$c3
1d09 : c900 cmp #0 ;test result
trap_ne
1d0b : d0fe > bne * ;failed not equal (non zero)
1d0d : 68 pla ;load status
eor_flag 0
1d0e : 4930 > eor #0|fao ;invert expected flags + always on bits
1d10 : cd1f02 cmp fLDx+3 ;test flags
trap_ne
1d13 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1d15 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1d17 : 48 > pha ;use stack to load status
1d18 : 28 > plp
1d19 : a509 lda zp1
1d1b : 08 php ;test stores do not alter flags
1d1c : 49c3 eor #$c3
1d1e : 28 plp
1d1f : 8d0302 sta abst
1d22 : 08 php ;flags after load/store sequence
1d23 : 49c3 eor #$c3
1d25 : c9c3 cmp #$c3 ;test result
trap_ne
1d27 : d0fe > bne * ;failed not equal (non zero)
1d29 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1d2a : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1d2c : cd1c02 cmp fLDx ;test flags
trap_ne
1d2f : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1d31 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1d33 : 48 > pha ;use stack to load status
1d34 : 28 > plp
1d35 : a50a lda zp1+1
1d37 : 08 php ;test stores do not alter flags
1d38 : 49c3 eor #$c3
1d3a : 28 plp
1d3b : 8d0402 sta abst+1
1d3e : 08 php ;flags after load/store sequence
1d3f : 49c3 eor #$c3
1d41 : c982 cmp #$82 ;test result
trap_ne
1d43 : d0fe > bne * ;failed not equal (non zero)
1d45 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1d46 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1d48 : cd1d02 cmp fLDx+1 ;test flags
trap_ne
1d4b : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1d4d : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1d4f : 48 > pha ;use stack to load status
1d50 : 28 > plp
1d51 : a50b lda zp1+2
1d53 : 08 php ;test stores do not alter flags
1d54 : 49c3 eor #$c3
1d56 : 28 plp
1d57 : 8d0502 sta abst+2
1d5a : 08 php ;flags after load/store sequence
1d5b : 49c3 eor #$c3
1d5d : c941 cmp #$41 ;test result
trap_ne
1d5f : d0fe > bne * ;failed not equal (non zero)
1d61 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1d62 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1d64 : cd1e02 cmp fLDx+2 ;test flags
trap_ne
1d67 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1d69 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1d6b : 48 > pha ;use stack to load status
1d6c : 28 > plp
1d6d : a50c lda zp1+3
1d6f : 08 php ;test stores do not alter flags
1d70 : 49c3 eor #$c3
1d72 : 28 plp
1d73 : 8d0602 sta abst+3
1d76 : 08 php ;flags after load/store sequence
1d77 : 49c3 eor #$c3
1d79 : c900 cmp #0 ;test result
trap_ne
1d7b : d0fe > bne * ;failed not equal (non zero)
1d7d : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1d7e : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1d80 : cd1f02 cmp fLDx+3 ;test flags
trap_ne
1d83 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1d85 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1d87 : 48 > pha ;use stack to load status
1d88 : 28 > plp
1d89 : ad1702 lda abs1
1d8c : 08 php ;test stores do not alter flags
1d8d : 49c3 eor #$c3
1d8f : 28 plp
1d90 : 8502 sta zpt
1d92 : 08 php ;flags after load/store sequence
1d93 : 49c3 eor #$c3
1d95 : c509 cmp zp1 ;test result
trap_ne
1d97 : d0fe > bne * ;failed not equal (non zero)
1d99 : 68 pla ;load status
eor_flag 0
1d9a : 4930 > eor #0|fao ;invert expected flags + always on bits
1d9c : cd1c02 cmp fLDx ;test flags
trap_ne
1d9f : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1da1 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1da3 : 48 > pha ;use stack to load status
1da4 : 28 > plp
1da5 : ad1802 lda abs1+1
1da8 : 08 php ;test stores do not alter flags
1da9 : 49c3 eor #$c3
1dab : 28 plp
1dac : 8503 sta zpt+1
1dae : 08 php ;flags after load/store sequence
1daf : 49c3 eor #$c3
1db1 : c50a cmp zp1+1 ;test result
trap_ne
1db3 : d0fe > bne * ;failed not equal (non zero)
1db5 : 68 pla ;load status
eor_flag 0
1db6 : 4930 > eor #0|fao ;invert expected flags + always on bits
1db8 : cd1d02 cmp fLDx+1 ;test flags
trap_ne
1dbb : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1dbd : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1dbf : 48 > pha ;use stack to load status
1dc0 : 28 > plp
1dc1 : ad1902 lda abs1+2
1dc4 : 08 php ;test stores do not alter flags
1dc5 : 49c3 eor #$c3
1dc7 : 28 plp
1dc8 : 8504 sta zpt+2
1dca : 08 php ;flags after load/store sequence
1dcb : 49c3 eor #$c3
1dcd : c50b cmp zp1+2 ;test result
trap_ne
1dcf : d0fe > bne * ;failed not equal (non zero)
1dd1 : 68 pla ;load status
eor_flag 0
1dd2 : 4930 > eor #0|fao ;invert expected flags + always on bits
1dd4 : cd1e02 cmp fLDx+2 ;test flags
trap_ne
1dd7 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1dd9 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1ddb : 48 > pha ;use stack to load status
1ddc : 28 > plp
1ddd : ad1a02 lda abs1+3
1de0 : 08 php ;test stores do not alter flags
1de1 : 49c3 eor #$c3
1de3 : 28 plp
1de4 : 8505 sta zpt+3
1de6 : 08 php ;flags after load/store sequence
1de7 : 49c3 eor #$c3
1de9 : c50c cmp zp1+3 ;test result
trap_ne
1deb : d0fe > bne * ;failed not equal (non zero)
1ded : 68 pla ;load status
eor_flag 0
1dee : 4930 > eor #0|fao ;invert expected flags + always on bits
1df0 : cd1f02 cmp fLDx+3 ;test flags
trap_ne
1df3 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1df5 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1df7 : 48 > pha ;use stack to load status
1df8 : 28 > plp
1df9 : ad1702 lda abs1
1dfc : 08 php ;test stores do not alter flags
1dfd : 49c3 eor #$c3
1dff : 28 plp
1e00 : 8502 sta zpt
1e02 : 08 php ;flags after load/store sequence
1e03 : 49c3 eor #$c3
1e05 : c509 cmp zp1 ;test result
trap_ne
1e07 : d0fe > bne * ;failed not equal (non zero)
1e09 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1e0a : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1e0c : cd1c02 cmp fLDx ;test flags
trap_ne
1e0f : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1e11 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1e13 : 48 > pha ;use stack to load status
1e14 : 28 > plp
1e15 : ad1802 lda abs1+1
1e18 : 08 php ;test stores do not alter flags
1e19 : 49c3 eor #$c3
1e1b : 28 plp
1e1c : 8503 sta zpt+1
1e1e : 08 php ;flags after load/store sequence
1e1f : 49c3 eor #$c3
1e21 : c50a cmp zp1+1 ;test result
trap_ne
1e23 : d0fe > bne * ;failed not equal (non zero)
1e25 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1e26 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1e28 : cd1d02 cmp fLDx+1 ;test flags
trap_ne
1e2b : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1e2d : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1e2f : 48 > pha ;use stack to load status
1e30 : 28 > plp
1e31 : ad1902 lda abs1+2
1e34 : 08 php ;test stores do not alter flags
1e35 : 49c3 eor #$c3
1e37 : 28 plp
1e38 : 8504 sta zpt+2
1e3a : 08 php ;flags after load/store sequence
1e3b : 49c3 eor #$c3
1e3d : c50b cmp zp1+2 ;test result
trap_ne
1e3f : d0fe > bne * ;failed not equal (non zero)
1e41 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1e42 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1e44 : cd1e02 cmp fLDx+2 ;test flags
trap_ne
1e47 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1e49 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1e4b : 48 > pha ;use stack to load status
1e4c : 28 > plp
1e4d : ad1a02 lda abs1+3
1e50 : 08 php ;test stores do not alter flags
1e51 : 49c3 eor #$c3
1e53 : 28 plp
1e54 : 8505 sta zpt+3
1e56 : 08 php ;flags after load/store sequence
1e57 : 49c3 eor #$c3
1e59 : c50c cmp zp1+3 ;test result
trap_ne
1e5b : d0fe > bne * ;failed not equal (non zero)
1e5d : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1e5e : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1e60 : cd1f02 cmp fLDx+3 ;test flags
trap_ne
1e63 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1e65 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1e67 : 48 > pha ;use stack to load status
1e68 : 28 > plp
1e69 : a9c3 lda #$c3
1e6b : 08 php
1e6c : cd1702 cmp abs1 ;test result
trap_ne
1e6f : d0fe > bne * ;failed not equal (non zero)
1e71 : 68 pla ;load status
eor_flag 0
1e72 : 4930 > eor #0|fao ;invert expected flags + always on bits
1e74 : cd1c02 cmp fLDx ;test flags
trap_ne
1e77 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1e79 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1e7b : 48 > pha ;use stack to load status
1e7c : 28 > plp
1e7d : a982 lda #$82
1e7f : 08 php
1e80 : cd1802 cmp abs1+1 ;test result
trap_ne
1e83 : d0fe > bne * ;failed not equal (non zero)
1e85 : 68 pla ;load status
eor_flag 0
1e86 : 4930 > eor #0|fao ;invert expected flags + always on bits
1e88 : cd1d02 cmp fLDx+1 ;test flags
trap_ne
1e8b : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1e8d : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1e8f : 48 > pha ;use stack to load status
1e90 : 28 > plp
1e91 : a941 lda #$41
1e93 : 08 php
1e94 : cd1902 cmp abs1+2 ;test result
trap_ne
1e97 : d0fe > bne * ;failed not equal (non zero)
1e99 : 68 pla ;load status
eor_flag 0
1e9a : 4930 > eor #0|fao ;invert expected flags + always on bits
1e9c : cd1e02 cmp fLDx+2 ;test flags
trap_ne
1e9f : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1ea1 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1ea3 : 48 > pha ;use stack to load status
1ea4 : 28 > plp
1ea5 : a900 lda #0
1ea7 : 08 php
1ea8 : cd1a02 cmp abs1+3 ;test result
trap_ne
1eab : d0fe > bne * ;failed not equal (non zero)
1ead : 68 pla ;load status
eor_flag 0
1eae : 4930 > eor #0|fao ;invert expected flags + always on bits
1eb0 : cd1f02 cmp fLDx+3 ;test flags
trap_ne
1eb3 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1eb5 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1eb7 : 48 > pha ;use stack to load status
1eb8 : 28 > plp
1eb9 : a9c3 lda #$c3
1ebb : 08 php
1ebc : cd1702 cmp abs1 ;test result
trap_ne
1ebf : d0fe > bne * ;failed not equal (non zero)
1ec1 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1ec2 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1ec4 : cd1c02 cmp fLDx ;test flags
trap_ne
1ec7 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1ec9 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1ecb : 48 > pha ;use stack to load status
1ecc : 28 > plp
1ecd : a982 lda #$82
1ecf : 08 php
1ed0 : cd1802 cmp abs1+1 ;test result
trap_ne
1ed3 : d0fe > bne * ;failed not equal (non zero)
1ed5 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1ed6 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1ed8 : cd1d02 cmp fLDx+1 ;test flags
trap_ne
1edb : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1edd : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1edf : 48 > pha ;use stack to load status
1ee0 : 28 > plp
1ee1 : a941 lda #$41
1ee3 : 08 php
1ee4 : cd1902 cmp abs1+2 ;test result
trap_ne
1ee7 : d0fe > bne * ;failed not equal (non zero)
1ee9 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1eea : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1eec : cd1e02 cmp fLDx+2 ;test flags
trap_ne
1eef : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1ef1 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1ef3 : 48 > pha ;use stack to load status
1ef4 : 28 > plp
1ef5 : a900 lda #0
1ef7 : 08 php
1ef8 : cd1a02 cmp abs1+3 ;test result
trap_ne
1efb : d0fe > bne * ;failed not equal (non zero)
1efd : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1efe : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1f00 : cd1f02 cmp fLDx+3 ;test flags
trap_ne
1f03 : d0fe > bne * ;failed not equal (non zero)
1f05 : a200 ldx #0
1f07 : a502 lda zpt
1f09 : 49c3 eor #$c3
1f0b : c509 cmp zp1
trap_ne ;store to zp data
1f0d : d0fe > bne * ;failed not equal (non zero)
1f0f : 8602 stx zpt ;clear
1f11 : ad0302 lda abst
1f14 : 49c3 eor #$c3
1f16 : cd1702 cmp abs1
trap_ne ;store to abs data
1f19 : d0fe > bne * ;failed not equal (non zero)
1f1b : 8e0302 stx abst ;clear
1f1e : a503 lda zpt+1
1f20 : 49c3 eor #$c3
1f22 : c50a cmp zp1+1
trap_ne ;store to zp data
1f24 : d0fe > bne * ;failed not equal (non zero)
1f26 : 8603 stx zpt+1 ;clear
1f28 : ad0402 lda abst+1
1f2b : 49c3 eor #$c3
1f2d : cd1802 cmp abs1+1
trap_ne ;store to abs data
1f30 : d0fe > bne * ;failed not equal (non zero)
1f32 : 8e0402 stx abst+1 ;clear
1f35 : a504 lda zpt+2
1f37 : 49c3 eor #$c3
1f39 : c50b cmp zp1+2
trap_ne ;store to zp data
1f3b : d0fe > bne * ;failed not equal (non zero)
1f3d : 8604 stx zpt+2 ;clear
1f3f : ad0502 lda abst+2
1f42 : 49c3 eor #$c3
1f44 : cd1902 cmp abs1+2
trap_ne ;store to abs data
1f47 : d0fe > bne * ;failed not equal (non zero)
1f49 : 8e0502 stx abst+2 ;clear
1f4c : a505 lda zpt+3
1f4e : 49c3 eor #$c3
1f50 : c50c cmp zp1+3
trap_ne ;store to zp data
1f52 : d0fe > bne * ;failed not equal (non zero)
1f54 : 8605 stx zpt+3 ;clear
1f56 : ad0602 lda abst+3
1f59 : 49c3 eor #$c3
1f5b : cd1a02 cmp abs1+3
trap_ne ;store to abs data
1f5e : d0fe > bne * ;failed not equal (non zero)
1f60 : 8e0602 stx abst+3 ;clear
next_test
1f63 : ad0002 > lda test_case ;previous test
1f66 : c918 > cmp #test_num
> trap_ne ;test is out of sequence
1f68 : d0fe > bne * ;failed not equal (non zero)
>
0019 = >test_num = test_num + 1
1f6a : a919 > lda #test_num ;*** next tests' number
1f6c : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; testing bit test & compares BIT CPX CPY CMP all addressing modes
; BIT - zp / abs
set_a $ff,0
> load_flag 0
1f6f : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1f71 : 48 > pha ;use stack to load status
1f72 : a9ff > lda #$ff ;precharge accu
1f74 : 28 > plp
1f75 : 240c bit zp1+3 ;00 - should set Z / clear NV
tst_a $ff,fz
1f77 : 08 > php ;save flags
1f78 : c9ff > cmp #$ff ;test result
> trap_ne
1f7a : d0fe > bne * ;failed not equal (non zero)
>
1f7c : 68 > pla ;load status
1f7d : 48 > pha
> cmp_flag fz
1f7e : c932 > cmp #(fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1f80 : d0fe > bne * ;failed not equal (non zero)
>
1f82 : 28 > plp ;restore status
set_a 1,0
> load_flag 0
1f83 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1f85 : 48 > pha ;use stack to load status
1f86 : a901 > lda #1 ;precharge accu
1f88 : 28 > plp
1f89 : 240b bit zp1+2 ;41 - should set V (M6) / clear NZ
tst_a 1,fv
1f8b : 08 > php ;save flags
1f8c : c901 > cmp #1 ;test result
> trap_ne
1f8e : d0fe > bne * ;failed not equal (non zero)
>
1f90 : 68 > pla ;load status
1f91 : 48 > pha
> cmp_flag fv
1f92 : c970 > cmp #(fv|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1f94 : d0fe > bne * ;failed not equal (non zero)
>
1f96 : 28 > plp ;restore status
set_a 1,0
> load_flag 0
1f97 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1f99 : 48 > pha ;use stack to load status
1f9a : a901 > lda #1 ;precharge accu
1f9c : 28 > plp
1f9d : 240a bit zp1+1 ;82 - should set N (M7) & Z / clear V
tst_a 1,fnz
1f9f : 08 > php ;save flags
1fa0 : c901 > cmp #1 ;test result
> trap_ne
1fa2 : d0fe > bne * ;failed not equal (non zero)
>
1fa4 : 68 > pla ;load status
1fa5 : 48 > pha
> cmp_flag fnz
1fa6 : c9b2 > cmp #(fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1fa8 : d0fe > bne * ;failed not equal (non zero)
>
1faa : 28 > plp ;restore status
set_a 1,0
> load_flag 0
1fab : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1fad : 48 > pha ;use stack to load status
1fae : a901 > lda #1 ;precharge accu
1fb0 : 28 > plp
1fb1 : 2409 bit zp1 ;c3 - should set N (M7) & V (M6) / clear Z
tst_a 1,fnv
1fb3 : 08 > php ;save flags
1fb4 : c901 > cmp #1 ;test result
> trap_ne
1fb6 : d0fe > bne * ;failed not equal (non zero)
>
1fb8 : 68 > pla ;load status
1fb9 : 48 > pha
> cmp_flag fnv
1fba : c9f0 > cmp #(fnv|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1fbc : d0fe > bne * ;failed not equal (non zero)
>
1fbe : 28 > plp ;restore status
set_a $ff,$ff
> load_flag $ff
1fbf : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1fc1 : 48 > pha ;use stack to load status
1fc2 : a9ff > lda #$ff ;precharge accu
1fc4 : 28 > plp
1fc5 : 240c bit zp1+3 ;00 - should set Z / clear NV
tst_a $ff,~fnv
1fc7 : 08 > php ;save flags
1fc8 : c9ff > cmp #$ff ;test result
> trap_ne
1fca : d0fe > bne * ;failed not equal (non zero)
>
1fcc : 68 > pla ;load status
1fcd : 48 > pha
> cmp_flag ~fnv
1fce : c93f > cmp #(~fnv|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1fd0 : d0fe > bne * ;failed not equal (non zero)
>
1fd2 : 28 > plp ;restore status
set_a 1,$ff
> load_flag $ff
1fd3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1fd5 : 48 > pha ;use stack to load status
1fd6 : a901 > lda #1 ;precharge accu
1fd8 : 28 > plp
1fd9 : 240b bit zp1+2 ;41 - should set V (M6) / clear NZ
tst_a 1,~fnz
1fdb : 08 > php ;save flags
1fdc : c901 > cmp #1 ;test result
> trap_ne
1fde : d0fe > bne * ;failed not equal (non zero)
>
1fe0 : 68 > pla ;load status
1fe1 : 48 > pha
> cmp_flag ~fnz
1fe2 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1fe4 : d0fe > bne * ;failed not equal (non zero)
>
1fe6 : 28 > plp ;restore status
set_a 1,$ff
> load_flag $ff
1fe7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1fe9 : 48 > pha ;use stack to load status
1fea : a901 > lda #1 ;precharge accu
1fec : 28 > plp
1fed : 240a bit zp1+1 ;82 - should set N (M7) & Z / clear V
tst_a 1,~fv
1fef : 08 > php ;save flags
1ff0 : c901 > cmp #1 ;test result
> trap_ne
1ff2 : d0fe > bne * ;failed not equal (non zero)
>
1ff4 : 68 > pla ;load status
1ff5 : 48 > pha
> cmp_flag ~fv
1ff6 : c9bf > cmp #(~fv|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1ff8 : d0fe > bne * ;failed not equal (non zero)
>
1ffa : 28 > plp ;restore status
set_a 1,$ff
> load_flag $ff
1ffb : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1ffd : 48 > pha ;use stack to load status
1ffe : a901 > lda #1 ;precharge accu
2000 : 28 > plp
2001 : 2409 bit zp1 ;c3 - should set N (M7) & V (M6) / clear Z
tst_a 1,~fz
2003 : 08 > php ;save flags
2004 : c901 > cmp #1 ;test result
> trap_ne
2006 : d0fe > bne * ;failed not equal (non zero)
>
2008 : 68 > pla ;load status
2009 : 48 > pha
> cmp_flag ~fz
200a : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
200c : d0fe > bne * ;failed not equal (non zero)
>
200e : 28 > plp ;restore status
set_a $ff,0
> load_flag 0
200f : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2011 : 48 > pha ;use stack to load status
2012 : a9ff > lda #$ff ;precharge accu
2014 : 28 > plp
2015 : 2c1a02 bit abs1+3 ;00 - should set Z / clear NV
tst_a $ff,fz
2018 : 08 > php ;save flags
2019 : c9ff > cmp #$ff ;test result
> trap_ne
201b : d0fe > bne * ;failed not equal (non zero)
>
201d : 68 > pla ;load status
201e : 48 > pha
> cmp_flag fz
201f : c932 > cmp #(fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2021 : d0fe > bne * ;failed not equal (non zero)
>
2023 : 28 > plp ;restore status
set_a 1,0
> load_flag 0
2024 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2026 : 48 > pha ;use stack to load status
2027 : a901 > lda #1 ;precharge accu
2029 : 28 > plp
202a : 2c1902 bit abs1+2 ;41 - should set V (M6) / clear NZ
tst_a 1,fv
202d : 08 > php ;save flags
202e : c901 > cmp #1 ;test result
> trap_ne
2030 : d0fe > bne * ;failed not equal (non zero)
>
2032 : 68 > pla ;load status
2033 : 48 > pha
> cmp_flag fv
2034 : c970 > cmp #(fv|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2036 : d0fe > bne * ;failed not equal (non zero)
>
2038 : 28 > plp ;restore status
set_a 1,0
> load_flag 0
2039 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
203b : 48 > pha ;use stack to load status
203c : a901 > lda #1 ;precharge accu
203e : 28 > plp
203f : 2c1802 bit abs1+1 ;82 - should set N (M7) & Z / clear V
tst_a 1,fnz
2042 : 08 > php ;save flags
2043 : c901 > cmp #1 ;test result
> trap_ne
2045 : d0fe > bne * ;failed not equal (non zero)
>
2047 : 68 > pla ;load status
2048 : 48 > pha
> cmp_flag fnz
2049 : c9b2 > cmp #(fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
204b : d0fe > bne * ;failed not equal (non zero)
>
204d : 28 > plp ;restore status
set_a 1,0
> load_flag 0
204e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2050 : 48 > pha ;use stack to load status
2051 : a901 > lda #1 ;precharge accu
2053 : 28 > plp
2054 : 2c1702 bit abs1 ;c3 - should set N (M7) & V (M6) / clear Z
tst_a 1,fnv
2057 : 08 > php ;save flags
2058 : c901 > cmp #1 ;test result
> trap_ne
205a : d0fe > bne * ;failed not equal (non zero)
>
205c : 68 > pla ;load status
205d : 48 > pha
> cmp_flag fnv
205e : c9f0 > cmp #(fnv|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2060 : d0fe > bne * ;failed not equal (non zero)
>
2062 : 28 > plp ;restore status
set_a $ff,$ff
> load_flag $ff
2063 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2065 : 48 > pha ;use stack to load status
2066 : a9ff > lda #$ff ;precharge accu
2068 : 28 > plp
2069 : 2c1a02 bit abs1+3 ;00 - should set Z / clear NV
tst_a $ff,~fnv
206c : 08 > php ;save flags
206d : c9ff > cmp #$ff ;test result
> trap_ne
206f : d0fe > bne * ;failed not equal (non zero)
>
2071 : 68 > pla ;load status
2072 : 48 > pha
> cmp_flag ~fnv
2073 : c93f > cmp #(~fnv|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2075 : d0fe > bne * ;failed not equal (non zero)
>
2077 : 28 > plp ;restore status
set_a 1,$ff
> load_flag $ff
2078 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
207a : 48 > pha ;use stack to load status
207b : a901 > lda #1 ;precharge accu
207d : 28 > plp
207e : 2c1902 bit abs1+2 ;41 - should set V (M6) / clear NZ
tst_a 1,~fnz
2081 : 08 > php ;save flags
2082 : c901 > cmp #1 ;test result
> trap_ne
2084 : d0fe > bne * ;failed not equal (non zero)
>
2086 : 68 > pla ;load status
2087 : 48 > pha
> cmp_flag ~fnz
2088 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
208a : d0fe > bne * ;failed not equal (non zero)
>
208c : 28 > plp ;restore status
set_a 1,$ff
> load_flag $ff
208d : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
208f : 48 > pha ;use stack to load status
2090 : a901 > lda #1 ;precharge accu
2092 : 28 > plp
2093 : 2c1802 bit abs1+1 ;82 - should set N (M7) & Z / clear V
tst_a 1,~fv
2096 : 08 > php ;save flags
2097 : c901 > cmp #1 ;test result
> trap_ne
2099 : d0fe > bne * ;failed not equal (non zero)
>
209b : 68 > pla ;load status
209c : 48 > pha
> cmp_flag ~fv
209d : c9bf > cmp #(~fv|fao)&m8 ;expected flags + always on bits
>
> trap_ne
209f : d0fe > bne * ;failed not equal (non zero)
>
20a1 : 28 > plp ;restore status
set_a 1,$ff
> load_flag $ff
20a2 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
20a4 : 48 > pha ;use stack to load status
20a5 : a901 > lda #1 ;precharge accu
20a7 : 28 > plp
20a8 : 2c1702 bit abs1 ;c3 - should set N (M7) & V (M6) / clear Z
tst_a 1,~fz
20ab : 08 > php ;save flags
20ac : c901 > cmp #1 ;test result
> trap_ne
20ae : d0fe > bne * ;failed not equal (non zero)
>
20b0 : 68 > pla ;load status
20b1 : 48 > pha
> cmp_flag ~fz
20b2 : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
20b4 : d0fe > bne * ;failed not equal (non zero)
>
20b6 : 28 > plp ;restore status
next_test
20b7 : ad0002 > lda test_case ;previous test
20ba : c919 > cmp #test_num
> trap_ne ;test is out of sequence
20bc : d0fe > bne * ;failed not equal (non zero)
>
001a = >test_num = test_num + 1
20be : a91a > lda #test_num ;*** next tests' number
20c0 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; CPX - zp / abs / #
set_x $80,0
> load_flag 0
20c3 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
20c5 : 48 > pha ;use stack to load status
20c6 : a280 > ldx #$80 ;precharge index x
20c8 : 28 > plp
20c9 : e40d cpx zp7f
tst_stat fc
20cb : 08 > php ;save status
20cc : 68 > pla ;use stack to retrieve status
20cd : 48 > pha
> cmp_flag fc
20ce : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
20d0 : d0fe > bne * ;failed not equal (non zero)
>
20d2 : 28 > plp ;restore status
20d3 : ca dex
20d4 : e40d cpx zp7f
tst_stat fzc
20d6 : 08 > php ;save status
20d7 : 68 > pla ;use stack to retrieve status
20d8 : 48 > pha
> cmp_flag fzc
20d9 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
20db : d0fe > bne * ;failed not equal (non zero)
>
20dd : 28 > plp ;restore status
20de : ca dex
20df : e40d cpx zp7f
tst_x $7e,fn
20e1 : 08 > php ;save flags
20e2 : e07e > cpx #$7e ;test result
> trap_ne
20e4 : d0fe > bne * ;failed not equal (non zero)
>
20e6 : 68 > pla ;load status
20e7 : 48 > pha
> cmp_flag fn
20e8 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
20ea : d0fe > bne * ;failed not equal (non zero)
>
20ec : 28 > plp ;restore status
set_x $80,$ff
> load_flag $ff
20ed : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
20ef : 48 > pha ;use stack to load status
20f0 : a280 > ldx #$80 ;precharge index x
20f2 : 28 > plp
20f3 : e40d cpx zp7f
tst_stat ~fnz
20f5 : 08 > php ;save status
20f6 : 68 > pla ;use stack to retrieve status
20f7 : 48 > pha
> cmp_flag ~fnz
20f8 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
20fa : d0fe > bne * ;failed not equal (non zero)
>
20fc : 28 > plp ;restore status
20fd : ca dex
20fe : e40d cpx zp7f
tst_stat ~fn
2100 : 08 > php ;save status
2101 : 68 > pla ;use stack to retrieve status
2102 : 48 > pha
> cmp_flag ~fn
2103 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2105 : d0fe > bne * ;failed not equal (non zero)
>
2107 : 28 > plp ;restore status
2108 : ca dex
2109 : e40d cpx zp7f
tst_x $7e,~fzc
210b : 08 > php ;save flags
210c : e07e > cpx #$7e ;test result
> trap_ne
210e : d0fe > bne * ;failed not equal (non zero)
>
2110 : 68 > pla ;load status
2111 : 48 > pha
> cmp_flag ~fzc
2112 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2114 : d0fe > bne * ;failed not equal (non zero)
>
2116 : 28 > plp ;restore status
set_x $80,0
> load_flag 0
2117 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2119 : 48 > pha ;use stack to load status
211a : a280 > ldx #$80 ;precharge index x
211c : 28 > plp
211d : ec1b02 cpx abs7f
tst_stat fc
2120 : 08 > php ;save status
2121 : 68 > pla ;use stack to retrieve status
2122 : 48 > pha
> cmp_flag fc
2123 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2125 : d0fe > bne * ;failed not equal (non zero)
>
2127 : 28 > plp ;restore status
2128 : ca dex
2129 : ec1b02 cpx abs7f
tst_stat fzc
212c : 08 > php ;save status
212d : 68 > pla ;use stack to retrieve status
212e : 48 > pha
> cmp_flag fzc
212f : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2131 : d0fe > bne * ;failed not equal (non zero)
>
2133 : 28 > plp ;restore status
2134 : ca dex
2135 : ec1b02 cpx abs7f
tst_x $7e,fn
2138 : 08 > php ;save flags
2139 : e07e > cpx #$7e ;test result
> trap_ne
213b : d0fe > bne * ;failed not equal (non zero)
>
213d : 68 > pla ;load status
213e : 48 > pha
> cmp_flag fn
213f : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2141 : d0fe > bne * ;failed not equal (non zero)
>
2143 : 28 > plp ;restore status
set_x $80,$ff
> load_flag $ff
2144 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2146 : 48 > pha ;use stack to load status
2147 : a280 > ldx #$80 ;precharge index x
2149 : 28 > plp
214a : ec1b02 cpx abs7f
tst_stat ~fnz
214d : 08 > php ;save status
214e : 68 > pla ;use stack to retrieve status
214f : 48 > pha
> cmp_flag ~fnz
2150 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2152 : d0fe > bne * ;failed not equal (non zero)
>
2154 : 28 > plp ;restore status
2155 : ca dex
2156 : ec1b02 cpx abs7f
tst_stat ~fn
2159 : 08 > php ;save status
215a : 68 > pla ;use stack to retrieve status
215b : 48 > pha
> cmp_flag ~fn
215c : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
215e : d0fe > bne * ;failed not equal (non zero)
>
2160 : 28 > plp ;restore status
2161 : ca dex
2162 : ec1b02 cpx abs7f
tst_x $7e,~fzc
2165 : 08 > php ;save flags
2166 : e07e > cpx #$7e ;test result
> trap_ne
2168 : d0fe > bne * ;failed not equal (non zero)
>
216a : 68 > pla ;load status
216b : 48 > pha
> cmp_flag ~fzc
216c : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
216e : d0fe > bne * ;failed not equal (non zero)
>
2170 : 28 > plp ;restore status
set_x $80,0
> load_flag 0
2171 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2173 : 48 > pha ;use stack to load status
2174 : a280 > ldx #$80 ;precharge index x
2176 : 28 > plp
2177 : e07f cpx #$7f
tst_stat fc
2179 : 08 > php ;save status
217a : 68 > pla ;use stack to retrieve status
217b : 48 > pha
> cmp_flag fc
217c : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
217e : d0fe > bne * ;failed not equal (non zero)
>
2180 : 28 > plp ;restore status
2181 : ca dex
2182 : e07f cpx #$7f
tst_stat fzc
2184 : 08 > php ;save status
2185 : 68 > pla ;use stack to retrieve status
2186 : 48 > pha
> cmp_flag fzc
2187 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2189 : d0fe > bne * ;failed not equal (non zero)
>
218b : 28 > plp ;restore status
218c : ca dex
218d : e07f cpx #$7f
tst_x $7e,fn
218f : 08 > php ;save flags
2190 : e07e > cpx #$7e ;test result
> trap_ne
2192 : d0fe > bne * ;failed not equal (non zero)
>
2194 : 68 > pla ;load status
2195 : 48 > pha
> cmp_flag fn
2196 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2198 : d0fe > bne * ;failed not equal (non zero)
>
219a : 28 > plp ;restore status
set_x $80,$ff
> load_flag $ff
219b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
219d : 48 > pha ;use stack to load status
219e : a280 > ldx #$80 ;precharge index x
21a0 : 28 > plp
21a1 : e07f cpx #$7f
tst_stat ~fnz
21a3 : 08 > php ;save status
21a4 : 68 > pla ;use stack to retrieve status
21a5 : 48 > pha
> cmp_flag ~fnz
21a6 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
21a8 : d0fe > bne * ;failed not equal (non zero)
>
21aa : 28 > plp ;restore status
21ab : ca dex
21ac : e07f cpx #$7f
tst_stat ~fn
21ae : 08 > php ;save status
21af : 68 > pla ;use stack to retrieve status
21b0 : 48 > pha
> cmp_flag ~fn
21b1 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
21b3 : d0fe > bne * ;failed not equal (non zero)
>
21b5 : 28 > plp ;restore status
21b6 : ca dex
21b7 : e07f cpx #$7f
tst_x $7e,~fzc
21b9 : 08 > php ;save flags
21ba : e07e > cpx #$7e ;test result
> trap_ne
21bc : d0fe > bne * ;failed not equal (non zero)
>
21be : 68 > pla ;load status
21bf : 48 > pha
> cmp_flag ~fzc
21c0 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
21c2 : d0fe > bne * ;failed not equal (non zero)
>
21c4 : 28 > plp ;restore status
next_test
21c5 : ad0002 > lda test_case ;previous test
21c8 : c91a > cmp #test_num
> trap_ne ;test is out of sequence
21ca : d0fe > bne * ;failed not equal (non zero)
>
001b = >test_num = test_num + 1
21cc : a91b > lda #test_num ;*** next tests' number
21ce : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; CPY - zp / abs / #
set_y $80,0
> load_flag 0
21d1 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
21d3 : 48 > pha ;use stack to load status
21d4 : a080 > ldy #$80 ;precharge index y
21d6 : 28 > plp
21d7 : c40d cpy zp7f
tst_stat fc
21d9 : 08 > php ;save status
21da : 68 > pla ;use stack to retrieve status
21db : 48 > pha
> cmp_flag fc
21dc : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
21de : d0fe > bne * ;failed not equal (non zero)
>
21e0 : 28 > plp ;restore status
21e1 : 88 dey
21e2 : c40d cpy zp7f
tst_stat fzc
21e4 : 08 > php ;save status
21e5 : 68 > pla ;use stack to retrieve status
21e6 : 48 > pha
> cmp_flag fzc
21e7 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
21e9 : d0fe > bne * ;failed not equal (non zero)
>
21eb : 28 > plp ;restore status
21ec : 88 dey
21ed : c40d cpy zp7f
tst_y $7e,fn
21ef : 08 > php ;save flags
21f0 : c07e > cpy #$7e ;test result
> trap_ne
21f2 : d0fe > bne * ;failed not equal (non zero)
>
21f4 : 68 > pla ;load status
21f5 : 48 > pha
> cmp_flag fn
21f6 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
21f8 : d0fe > bne * ;failed not equal (non zero)
>
21fa : 28 > plp ;restore status
set_y $80,$ff
> load_flag $ff
21fb : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
21fd : 48 > pha ;use stack to load status
21fe : a080 > ldy #$80 ;precharge index y
2200 : 28 > plp
2201 : c40d cpy zp7f
tst_stat ~fnz
2203 : 08 > php ;save status
2204 : 68 > pla ;use stack to retrieve status
2205 : 48 > pha
> cmp_flag ~fnz
2206 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2208 : d0fe > bne * ;failed not equal (non zero)
>
220a : 28 > plp ;restore status
220b : 88 dey
220c : c40d cpy zp7f
tst_stat ~fn
220e : 08 > php ;save status
220f : 68 > pla ;use stack to retrieve status
2210 : 48 > pha
> cmp_flag ~fn
2211 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2213 : d0fe > bne * ;failed not equal (non zero)
>
2215 : 28 > plp ;restore status
2216 : 88 dey
2217 : c40d cpy zp7f
tst_y $7e,~fzc
2219 : 08 > php ;save flags
221a : c07e > cpy #$7e ;test result
> trap_ne
221c : d0fe > bne * ;failed not equal (non zero)
>
221e : 68 > pla ;load status
221f : 48 > pha
> cmp_flag ~fzc
2220 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2222 : d0fe > bne * ;failed not equal (non zero)
>
2224 : 28 > plp ;restore status
set_y $80,0
> load_flag 0
2225 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2227 : 48 > pha ;use stack to load status
2228 : a080 > ldy #$80 ;precharge index y
222a : 28 > plp
222b : cc1b02 cpy abs7f
tst_stat fc
222e : 08 > php ;save status
222f : 68 > pla ;use stack to retrieve status
2230 : 48 > pha
> cmp_flag fc
2231 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2233 : d0fe > bne * ;failed not equal (non zero)
>
2235 : 28 > plp ;restore status
2236 : 88 dey
2237 : cc1b02 cpy abs7f
tst_stat fzc
223a : 08 > php ;save status
223b : 68 > pla ;use stack to retrieve status
223c : 48 > pha
> cmp_flag fzc
223d : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
223f : d0fe > bne * ;failed not equal (non zero)
>
2241 : 28 > plp ;restore status
2242 : 88 dey
2243 : cc1b02 cpy abs7f
tst_y $7e,fn
2246 : 08 > php ;save flags
2247 : c07e > cpy #$7e ;test result
> trap_ne
2249 : d0fe > bne * ;failed not equal (non zero)
>
224b : 68 > pla ;load status
224c : 48 > pha
> cmp_flag fn
224d : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
224f : d0fe > bne * ;failed not equal (non zero)
>
2251 : 28 > plp ;restore status
set_y $80,$ff
> load_flag $ff
2252 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2254 : 48 > pha ;use stack to load status
2255 : a080 > ldy #$80 ;precharge index y
2257 : 28 > plp
2258 : cc1b02 cpy abs7f
tst_stat ~fnz
225b : 08 > php ;save status
225c : 68 > pla ;use stack to retrieve status
225d : 48 > pha
> cmp_flag ~fnz
225e : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2260 : d0fe > bne * ;failed not equal (non zero)
>
2262 : 28 > plp ;restore status
2263 : 88 dey
2264 : cc1b02 cpy abs7f
tst_stat ~fn
2267 : 08 > php ;save status
2268 : 68 > pla ;use stack to retrieve status
2269 : 48 > pha
> cmp_flag ~fn
226a : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
226c : d0fe > bne * ;failed not equal (non zero)
>
226e : 28 > plp ;restore status
226f : 88 dey
2270 : cc1b02 cpy abs7f
tst_y $7e,~fzc
2273 : 08 > php ;save flags
2274 : c07e > cpy #$7e ;test result
> trap_ne
2276 : d0fe > bne * ;failed not equal (non zero)
>
2278 : 68 > pla ;load status
2279 : 48 > pha
> cmp_flag ~fzc
227a : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
227c : d0fe > bne * ;failed not equal (non zero)
>
227e : 28 > plp ;restore status
set_y $80,0
> load_flag 0
227f : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2281 : 48 > pha ;use stack to load status
2282 : a080 > ldy #$80 ;precharge index y
2284 : 28 > plp
2285 : c07f cpy #$7f
tst_stat fc
2287 : 08 > php ;save status
2288 : 68 > pla ;use stack to retrieve status
2289 : 48 > pha
> cmp_flag fc
228a : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
228c : d0fe > bne * ;failed not equal (non zero)
>
228e : 28 > plp ;restore status
228f : 88 dey
2290 : c07f cpy #$7f
tst_stat fzc
2292 : 08 > php ;save status
2293 : 68 > pla ;use stack to retrieve status
2294 : 48 > pha
> cmp_flag fzc
2295 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2297 : d0fe > bne * ;failed not equal (non zero)
>
2299 : 28 > plp ;restore status
229a : 88 dey
229b : c07f cpy #$7f
tst_y $7e,fn
229d : 08 > php ;save flags
229e : c07e > cpy #$7e ;test result
> trap_ne
22a0 : d0fe > bne * ;failed not equal (non zero)
>
22a2 : 68 > pla ;load status
22a3 : 48 > pha
> cmp_flag fn
22a4 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
22a6 : d0fe > bne * ;failed not equal (non zero)
>
22a8 : 28 > plp ;restore status
set_y $80,$ff
> load_flag $ff
22a9 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
22ab : 48 > pha ;use stack to load status
22ac : a080 > ldy #$80 ;precharge index y
22ae : 28 > plp
22af : c07f cpy #$7f
tst_stat ~fnz
22b1 : 08 > php ;save status
22b2 : 68 > pla ;use stack to retrieve status
22b3 : 48 > pha
> cmp_flag ~fnz
22b4 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
22b6 : d0fe > bne * ;failed not equal (non zero)
>
22b8 : 28 > plp ;restore status
22b9 : 88 dey
22ba : c07f cpy #$7f
tst_stat ~fn
22bc : 08 > php ;save status
22bd : 68 > pla ;use stack to retrieve status
22be : 48 > pha
> cmp_flag ~fn
22bf : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
22c1 : d0fe > bne * ;failed not equal (non zero)
>
22c3 : 28 > plp ;restore status
22c4 : 88 dey
22c5 : c07f cpy #$7f
tst_y $7e,~fzc
22c7 : 08 > php ;save flags
22c8 : c07e > cpy #$7e ;test result
> trap_ne
22ca : d0fe > bne * ;failed not equal (non zero)
>
22cc : 68 > pla ;load status
22cd : 48 > pha
> cmp_flag ~fzc
22ce : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
22d0 : d0fe > bne * ;failed not equal (non zero)
>
22d2 : 28 > plp ;restore status
next_test
22d3 : ad0002 > lda test_case ;previous test
22d6 : c91b > cmp #test_num
> trap_ne ;test is out of sequence
22d8 : d0fe > bne * ;failed not equal (non zero)
>
001c = >test_num = test_num + 1
22da : a91c > lda #test_num ;*** next tests' number
22dc : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; CMP - zp / abs / #
set_a $80,0
> load_flag 0
22df : a900 > lda #0 ;allow test to change I-flag (no mask)
>
22e1 : 48 > pha ;use stack to load status
22e2 : a980 > lda #$80 ;precharge accu
22e4 : 28 > plp
22e5 : c50d cmp zp7f
tst_a $80,fc
22e7 : 08 > php ;save flags
22e8 : c980 > cmp #$80 ;test result
> trap_ne
22ea : d0fe > bne * ;failed not equal (non zero)
>
22ec : 68 > pla ;load status
22ed : 48 > pha
> cmp_flag fc
22ee : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
22f0 : d0fe > bne * ;failed not equal (non zero)
>
22f2 : 28 > plp ;restore status
set_a $7f,0
> load_flag 0
22f3 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
22f5 : 48 > pha ;use stack to load status
22f6 : a97f > lda #$7f ;precharge accu
22f8 : 28 > plp
22f9 : c50d cmp zp7f
tst_a $7f,fzc
22fb : 08 > php ;save flags
22fc : c97f > cmp #$7f ;test result
> trap_ne
22fe : d0fe > bne * ;failed not equal (non zero)
>
2300 : 68 > pla ;load status
2301 : 48 > pha
> cmp_flag fzc
2302 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2304 : d0fe > bne * ;failed not equal (non zero)
>
2306 : 28 > plp ;restore status
set_a $7e,0
> load_flag 0
2307 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2309 : 48 > pha ;use stack to load status
230a : a97e > lda #$7e ;precharge accu
230c : 28 > plp
230d : c50d cmp zp7f
tst_a $7e,fn
230f : 08 > php ;save flags
2310 : c97e > cmp #$7e ;test result
> trap_ne
2312 : d0fe > bne * ;failed not equal (non zero)
>
2314 : 68 > pla ;load status
2315 : 48 > pha
> cmp_flag fn
2316 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2318 : d0fe > bne * ;failed not equal (non zero)
>
231a : 28 > plp ;restore status
set_a $80,$ff
> load_flag $ff
231b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
231d : 48 > pha ;use stack to load status
231e : a980 > lda #$80 ;precharge accu
2320 : 28 > plp
2321 : c50d cmp zp7f
tst_a $80,~fnz
2323 : 08 > php ;save flags
2324 : c980 > cmp #$80 ;test result
> trap_ne
2326 : d0fe > bne * ;failed not equal (non zero)
>
2328 : 68 > pla ;load status
2329 : 48 > pha
> cmp_flag ~fnz
232a : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
232c : d0fe > bne * ;failed not equal (non zero)
>
232e : 28 > plp ;restore status
set_a $7f,$ff
> load_flag $ff
232f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2331 : 48 > pha ;use stack to load status
2332 : a97f > lda #$7f ;precharge accu
2334 : 28 > plp
2335 : c50d cmp zp7f
tst_a $7f,~fn
2337 : 08 > php ;save flags
2338 : c97f > cmp #$7f ;test result
> trap_ne
233a : d0fe > bne * ;failed not equal (non zero)
>
233c : 68 > pla ;load status
233d : 48 > pha
> cmp_flag ~fn
233e : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2340 : d0fe > bne * ;failed not equal (non zero)
>
2342 : 28 > plp ;restore status
set_a $7e,$ff
> load_flag $ff
2343 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2345 : 48 > pha ;use stack to load status
2346 : a97e > lda #$7e ;precharge accu
2348 : 28 > plp
2349 : c50d cmp zp7f
tst_a $7e,~fzc
234b : 08 > php ;save flags
234c : c97e > cmp #$7e ;test result
> trap_ne
234e : d0fe > bne * ;failed not equal (non zero)
>
2350 : 68 > pla ;load status
2351 : 48 > pha
> cmp_flag ~fzc
2352 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2354 : d0fe > bne * ;failed not equal (non zero)
>
2356 : 28 > plp ;restore status
set_a $80,0
> load_flag 0
2357 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2359 : 48 > pha ;use stack to load status
235a : a980 > lda #$80 ;precharge accu
235c : 28 > plp
235d : cd1b02 cmp abs7f
tst_a $80,fc
2360 : 08 > php ;save flags
2361 : c980 > cmp #$80 ;test result
> trap_ne
2363 : d0fe > bne * ;failed not equal (non zero)
>
2365 : 68 > pla ;load status
2366 : 48 > pha
> cmp_flag fc
2367 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2369 : d0fe > bne * ;failed not equal (non zero)
>
236b : 28 > plp ;restore status
set_a $7f,0
> load_flag 0
236c : a900 > lda #0 ;allow test to change I-flag (no mask)
>
236e : 48 > pha ;use stack to load status
236f : a97f > lda #$7f ;precharge accu
2371 : 28 > plp
2372 : cd1b02 cmp abs7f
tst_a $7f,fzc
2375 : 08 > php ;save flags
2376 : c97f > cmp #$7f ;test result
> trap_ne
2378 : d0fe > bne * ;failed not equal (non zero)
>
237a : 68 > pla ;load status
237b : 48 > pha
> cmp_flag fzc
237c : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
237e : d0fe > bne * ;failed not equal (non zero)
>
2380 : 28 > plp ;restore status
set_a $7e,0
> load_flag 0
2381 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2383 : 48 > pha ;use stack to load status
2384 : a97e > lda #$7e ;precharge accu
2386 : 28 > plp
2387 : cd1b02 cmp abs7f
tst_a $7e,fn
238a : 08 > php ;save flags
238b : c97e > cmp #$7e ;test result
> trap_ne
238d : d0fe > bne * ;failed not equal (non zero)
>
238f : 68 > pla ;load status
2390 : 48 > pha
> cmp_flag fn
2391 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2393 : d0fe > bne * ;failed not equal (non zero)
>
2395 : 28 > plp ;restore status
set_a $80,$ff
> load_flag $ff
2396 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2398 : 48 > pha ;use stack to load status
2399 : a980 > lda #$80 ;precharge accu
239b : 28 > plp
239c : cd1b02 cmp abs7f
tst_a $80,~fnz
239f : 08 > php ;save flags
23a0 : c980 > cmp #$80 ;test result
> trap_ne
23a2 : d0fe > bne * ;failed not equal (non zero)
>
23a4 : 68 > pla ;load status
23a5 : 48 > pha
> cmp_flag ~fnz
23a6 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
23a8 : d0fe > bne * ;failed not equal (non zero)
>
23aa : 28 > plp ;restore status
set_a $7f,$ff
> load_flag $ff
23ab : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
23ad : 48 > pha ;use stack to load status
23ae : a97f > lda #$7f ;precharge accu
23b0 : 28 > plp
23b1 : cd1b02 cmp abs7f
tst_a $7f,~fn
23b4 : 08 > php ;save flags
23b5 : c97f > cmp #$7f ;test result
> trap_ne
23b7 : d0fe > bne * ;failed not equal (non zero)
>
23b9 : 68 > pla ;load status
23ba : 48 > pha
> cmp_flag ~fn
23bb : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
23bd : d0fe > bne * ;failed not equal (non zero)
>
23bf : 28 > plp ;restore status
set_a $7e,$ff
> load_flag $ff
23c0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
23c2 : 48 > pha ;use stack to load status
23c3 : a97e > lda #$7e ;precharge accu
23c5 : 28 > plp
23c6 : cd1b02 cmp abs7f
tst_a $7e,~fzc
23c9 : 08 > php ;save flags
23ca : c97e > cmp #$7e ;test result
> trap_ne
23cc : d0fe > bne * ;failed not equal (non zero)
>
23ce : 68 > pla ;load status
23cf : 48 > pha
> cmp_flag ~fzc
23d0 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
23d2 : d0fe > bne * ;failed not equal (non zero)
>
23d4 : 28 > plp ;restore status
set_a $80,0
> load_flag 0
23d5 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
23d7 : 48 > pha ;use stack to load status
23d8 : a980 > lda #$80 ;precharge accu
23da : 28 > plp
23db : c97f cmp #$7f
tst_a $80,fc
23dd : 08 > php ;save flags
23de : c980 > cmp #$80 ;test result
> trap_ne
23e0 : d0fe > bne * ;failed not equal (non zero)
>
23e2 : 68 > pla ;load status
23e3 : 48 > pha
> cmp_flag fc
23e4 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
23e6 : d0fe > bne * ;failed not equal (non zero)
>
23e8 : 28 > plp ;restore status
set_a $7f,0
> load_flag 0
23e9 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
23eb : 48 > pha ;use stack to load status
23ec : a97f > lda #$7f ;precharge accu
23ee : 28 > plp
23ef : c97f cmp #$7f
tst_a $7f,fzc
23f1 : 08 > php ;save flags
23f2 : c97f > cmp #$7f ;test result
> trap_ne
23f4 : d0fe > bne * ;failed not equal (non zero)
>
23f6 : 68 > pla ;load status
23f7 : 48 > pha
> cmp_flag fzc
23f8 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
23fa : d0fe > bne * ;failed not equal (non zero)
>
23fc : 28 > plp ;restore status
set_a $7e,0
> load_flag 0
23fd : a900 > lda #0 ;allow test to change I-flag (no mask)
>
23ff : 48 > pha ;use stack to load status
2400 : a97e > lda #$7e ;precharge accu
2402 : 28 > plp
2403 : c97f cmp #$7f
tst_a $7e,fn
2405 : 08 > php ;save flags
2406 : c97e > cmp #$7e ;test result
> trap_ne
2408 : d0fe > bne * ;failed not equal (non zero)
>
240a : 68 > pla ;load status
240b : 48 > pha
> cmp_flag fn
240c : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
240e : d0fe > bne * ;failed not equal (non zero)
>
2410 : 28 > plp ;restore status
set_a $80,$ff
> load_flag $ff
2411 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2413 : 48 > pha ;use stack to load status
2414 : a980 > lda #$80 ;precharge accu
2416 : 28 > plp
2417 : c97f cmp #$7f
tst_a $80,~fnz
2419 : 08 > php ;save flags
241a : c980 > cmp #$80 ;test result
> trap_ne
241c : d0fe > bne * ;failed not equal (non zero)
>
241e : 68 > pla ;load status
241f : 48 > pha
> cmp_flag ~fnz
2420 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2422 : d0fe > bne * ;failed not equal (non zero)
>
2424 : 28 > plp ;restore status
set_a $7f,$ff
> load_flag $ff
2425 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2427 : 48 > pha ;use stack to load status
2428 : a97f > lda #$7f ;precharge accu
242a : 28 > plp
242b : c97f cmp #$7f
tst_a $7f,~fn
242d : 08 > php ;save flags
242e : c97f > cmp #$7f ;test result
> trap_ne
2430 : d0fe > bne * ;failed not equal (non zero)
>
2432 : 68 > pla ;load status
2433 : 48 > pha
> cmp_flag ~fn
2434 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2436 : d0fe > bne * ;failed not equal (non zero)
>
2438 : 28 > plp ;restore status
set_a $7e,$ff
> load_flag $ff
2439 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
243b : 48 > pha ;use stack to load status
243c : a97e > lda #$7e ;precharge accu
243e : 28 > plp
243f : c97f cmp #$7f
tst_a $7e,~fzc
2441 : 08 > php ;save flags
2442 : c97e > cmp #$7e ;test result
> trap_ne
2444 : d0fe > bne * ;failed not equal (non zero)
>
2446 : 68 > pla ;load status
2447 : 48 > pha
> cmp_flag ~fzc
2448 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
244a : d0fe > bne * ;failed not equal (non zero)
>
244c : 28 > plp ;restore status
244d : a204 ldx #4 ;with indexing by X
set_a $80,0
> load_flag 0
244f : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2451 : 48 > pha ;use stack to load status
2452 : a980 > lda #$80 ;precharge accu
2454 : 28 > plp
2455 : d509 cmp zp1,x
tst_a $80,fc
2457 : 08 > php ;save flags
2458 : c980 > cmp #$80 ;test result
> trap_ne
245a : d0fe > bne * ;failed not equal (non zero)
>
245c : 68 > pla ;load status
245d : 48 > pha
> cmp_flag fc
245e : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2460 : d0fe > bne * ;failed not equal (non zero)
>
2462 : 28 > plp ;restore status
set_a $7f,0
> load_flag 0
2463 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2465 : 48 > pha ;use stack to load status
2466 : a97f > lda #$7f ;precharge accu
2468 : 28 > plp
2469 : d509 cmp zp1,x
tst_a $7f,fzc
246b : 08 > php ;save flags
246c : c97f > cmp #$7f ;test result
> trap_ne
246e : d0fe > bne * ;failed not equal (non zero)
>
2470 : 68 > pla ;load status
2471 : 48 > pha
> cmp_flag fzc
2472 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2474 : d0fe > bne * ;failed not equal (non zero)
>
2476 : 28 > plp ;restore status
set_a $7e,0
> load_flag 0
2477 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2479 : 48 > pha ;use stack to load status
247a : a97e > lda #$7e ;precharge accu
247c : 28 > plp
247d : d509 cmp zp1,x
tst_a $7e,fn
247f : 08 > php ;save flags
2480 : c97e > cmp #$7e ;test result
> trap_ne
2482 : d0fe > bne * ;failed not equal (non zero)
>
2484 : 68 > pla ;load status
2485 : 48 > pha
> cmp_flag fn
2486 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2488 : d0fe > bne * ;failed not equal (non zero)
>
248a : 28 > plp ;restore status
set_a $80,$ff
> load_flag $ff
248b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
248d : 48 > pha ;use stack to load status
248e : a980 > lda #$80 ;precharge accu
2490 : 28 > plp
2491 : d509 cmp zp1,x
tst_a $80,~fnz
2493 : 08 > php ;save flags
2494 : c980 > cmp #$80 ;test result
> trap_ne
2496 : d0fe > bne * ;failed not equal (non zero)
>
2498 : 68 > pla ;load status
2499 : 48 > pha
> cmp_flag ~fnz
249a : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
249c : d0fe > bne * ;failed not equal (non zero)
>
249e : 28 > plp ;restore status
set_a $7f,$ff
> load_flag $ff
249f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
24a1 : 48 > pha ;use stack to load status
24a2 : a97f > lda #$7f ;precharge accu
24a4 : 28 > plp
24a5 : d509 cmp zp1,x
tst_a $7f,~fn
24a7 : 08 > php ;save flags
24a8 : c97f > cmp #$7f ;test result
> trap_ne
24aa : d0fe > bne * ;failed not equal (non zero)
>
24ac : 68 > pla ;load status
24ad : 48 > pha
> cmp_flag ~fn
24ae : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
24b0 : d0fe > bne * ;failed not equal (non zero)
>
24b2 : 28 > plp ;restore status
set_a $7e,$ff
> load_flag $ff
24b3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
24b5 : 48 > pha ;use stack to load status
24b6 : a97e > lda #$7e ;precharge accu
24b8 : 28 > plp
24b9 : d509 cmp zp1,x
tst_a $7e,~fzc
24bb : 08 > php ;save flags
24bc : c97e > cmp #$7e ;test result
> trap_ne
24be : d0fe > bne * ;failed not equal (non zero)
>
24c0 : 68 > pla ;load status
24c1 : 48 > pha
> cmp_flag ~fzc
24c2 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
24c4 : d0fe > bne * ;failed not equal (non zero)
>
24c6 : 28 > plp ;restore status
set_a $80,0
> load_flag 0
24c7 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
24c9 : 48 > pha ;use stack to load status
24ca : a980 > lda #$80 ;precharge accu
24cc : 28 > plp
24cd : dd1702 cmp abs1,x
tst_a $80,fc
24d0 : 08 > php ;save flags
24d1 : c980 > cmp #$80 ;test result
> trap_ne
24d3 : d0fe > bne * ;failed not equal (non zero)
>
24d5 : 68 > pla ;load status
24d6 : 48 > pha
> cmp_flag fc
24d7 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
24d9 : d0fe > bne * ;failed not equal (non zero)
>
24db : 28 > plp ;restore status
set_a $7f,0
> load_flag 0
24dc : a900 > lda #0 ;allow test to change I-flag (no mask)
>
24de : 48 > pha ;use stack to load status
24df : a97f > lda #$7f ;precharge accu
24e1 : 28 > plp
24e2 : dd1702 cmp abs1,x
tst_a $7f,fzc
24e5 : 08 > php ;save flags
24e6 : c97f > cmp #$7f ;test result
> trap_ne
24e8 : d0fe > bne * ;failed not equal (non zero)
>
24ea : 68 > pla ;load status
24eb : 48 > pha
> cmp_flag fzc
24ec : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
24ee : d0fe > bne * ;failed not equal (non zero)
>
24f0 : 28 > plp ;restore status
set_a $7e,0
> load_flag 0
24f1 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
24f3 : 48 > pha ;use stack to load status
24f4 : a97e > lda #$7e ;precharge accu
24f6 : 28 > plp
24f7 : dd1702 cmp abs1,x
tst_a $7e,fn
24fa : 08 > php ;save flags
24fb : c97e > cmp #$7e ;test result
> trap_ne
24fd : d0fe > bne * ;failed not equal (non zero)
>
24ff : 68 > pla ;load status
2500 : 48 > pha
> cmp_flag fn
2501 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2503 : d0fe > bne * ;failed not equal (non zero)
>
2505 : 28 > plp ;restore status
set_a $80,$ff
> load_flag $ff
2506 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2508 : 48 > pha ;use stack to load status
2509 : a980 > lda #$80 ;precharge accu
250b : 28 > plp
250c : dd1702 cmp abs1,x
tst_a $80,~fnz
250f : 08 > php ;save flags
2510 : c980 > cmp #$80 ;test result
> trap_ne
2512 : d0fe > bne * ;failed not equal (non zero)
>
2514 : 68 > pla ;load status
2515 : 48 > pha
> cmp_flag ~fnz
2516 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2518 : d0fe > bne * ;failed not equal (non zero)
>
251a : 28 > plp ;restore status
set_a $7f,$ff
> load_flag $ff
251b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
251d : 48 > pha ;use stack to load status
251e : a97f > lda #$7f ;precharge accu
2520 : 28 > plp
2521 : dd1702 cmp abs1,x
tst_a $7f,~fn
2524 : 08 > php ;save flags
2525 : c97f > cmp #$7f ;test result
> trap_ne
2527 : d0fe > bne * ;failed not equal (non zero)
>
2529 : 68 > pla ;load status
252a : 48 > pha
> cmp_flag ~fn
252b : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
252d : d0fe > bne * ;failed not equal (non zero)
>
252f : 28 > plp ;restore status
set_a $7e,$ff
> load_flag $ff
2530 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2532 : 48 > pha ;use stack to load status
2533 : a97e > lda #$7e ;precharge accu
2535 : 28 > plp
2536 : dd1702 cmp abs1,x
tst_a $7e,~fzc
2539 : 08 > php ;save flags
253a : c97e > cmp #$7e ;test result
> trap_ne
253c : d0fe > bne * ;failed not equal (non zero)
>
253e : 68 > pla ;load status
253f : 48 > pha
> cmp_flag ~fzc
2540 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2542 : d0fe > bne * ;failed not equal (non zero)
>
2544 : 28 > plp ;restore status
2545 : a004 ldy #4 ;with indexing by Y
2547 : a208 ldx #8 ;with indexed indirect
set_a $80,0
> load_flag 0
2549 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
254b : 48 > pha ;use stack to load status
254c : a980 > lda #$80 ;precharge accu
254e : 28 > plp
254f : d91702 cmp abs1,y
tst_a $80,fc
2552 : 08 > php ;save flags
2553 : c980 > cmp #$80 ;test result
> trap_ne
2555 : d0fe > bne * ;failed not equal (non zero)
>
2557 : 68 > pla ;load status
2558 : 48 > pha
> cmp_flag fc
2559 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
255b : d0fe > bne * ;failed not equal (non zero)
>
255d : 28 > plp ;restore status
set_a $7f,0
> load_flag 0
255e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2560 : 48 > pha ;use stack to load status
2561 : a97f > lda #$7f ;precharge accu
2563 : 28 > plp
2564 : d91702 cmp abs1,y
tst_a $7f,fzc
2567 : 08 > php ;save flags
2568 : c97f > cmp #$7f ;test result
> trap_ne
256a : d0fe > bne * ;failed not equal (non zero)
>
256c : 68 > pla ;load status
256d : 48 > pha
> cmp_flag fzc
256e : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2570 : d0fe > bne * ;failed not equal (non zero)
>
2572 : 28 > plp ;restore status
set_a $7e,0
> load_flag 0
2573 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2575 : 48 > pha ;use stack to load status
2576 : a97e > lda #$7e ;precharge accu
2578 : 28 > plp
2579 : d91702 cmp abs1,y
tst_a $7e,fn
257c : 08 > php ;save flags
257d : c97e > cmp #$7e ;test result
> trap_ne
257f : d0fe > bne * ;failed not equal (non zero)
>
2581 : 68 > pla ;load status
2582 : 48 > pha
> cmp_flag fn
2583 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2585 : d0fe > bne * ;failed not equal (non zero)
>
2587 : 28 > plp ;restore status
set_a $80,$ff
> load_flag $ff
2588 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
258a : 48 > pha ;use stack to load status
258b : a980 > lda #$80 ;precharge accu
258d : 28 > plp
258e : d91702 cmp abs1,y
tst_a $80,~fnz
2591 : 08 > php ;save flags
2592 : c980 > cmp #$80 ;test result
> trap_ne
2594 : d0fe > bne * ;failed not equal (non zero)
>
2596 : 68 > pla ;load status
2597 : 48 > pha
> cmp_flag ~fnz
2598 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
259a : d0fe > bne * ;failed not equal (non zero)
>
259c : 28 > plp ;restore status
set_a $7f,$ff
> load_flag $ff
259d : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
259f : 48 > pha ;use stack to load status
25a0 : a97f > lda #$7f ;precharge accu
25a2 : 28 > plp
25a3 : d91702 cmp abs1,y
tst_a $7f,~fn
25a6 : 08 > php ;save flags
25a7 : c97f > cmp #$7f ;test result
> trap_ne
25a9 : d0fe > bne * ;failed not equal (non zero)
>
25ab : 68 > pla ;load status
25ac : 48 > pha
> cmp_flag ~fn
25ad : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
25af : d0fe > bne * ;failed not equal (non zero)
>
25b1 : 28 > plp ;restore status
set_a $7e,$ff
> load_flag $ff
25b2 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
25b4 : 48 > pha ;use stack to load status
25b5 : a97e > lda #$7e ;precharge accu
25b7 : 28 > plp
25b8 : d91702 cmp abs1,y
tst_a $7e,~fzc
25bb : 08 > php ;save flags
25bc : c97e > cmp #$7e ;test result
> trap_ne
25be : d0fe > bne * ;failed not equal (non zero)
>
25c0 : 68 > pla ;load status
25c1 : 48 > pha
> cmp_flag ~fzc
25c2 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
25c4 : d0fe > bne * ;failed not equal (non zero)
>
25c6 : 28 > plp ;restore status
set_a $80,0
> load_flag 0
25c7 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
25c9 : 48 > pha ;use stack to load status
25ca : a980 > lda #$80 ;precharge accu
25cc : 28 > plp
25cd : c11a cmp (ind1,x)
tst_a $80,fc
25cf : 08 > php ;save flags
25d0 : c980 > cmp #$80 ;test result
> trap_ne
25d2 : d0fe > bne * ;failed not equal (non zero)
>
25d4 : 68 > pla ;load status
25d5 : 48 > pha
> cmp_flag fc
25d6 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
25d8 : d0fe > bne * ;failed not equal (non zero)
>
25da : 28 > plp ;restore status
set_a $7f,0
> load_flag 0
25db : a900 > lda #0 ;allow test to change I-flag (no mask)
>
25dd : 48 > pha ;use stack to load status
25de : a97f > lda #$7f ;precharge accu
25e0 : 28 > plp
25e1 : c11a cmp (ind1,x)
tst_a $7f,fzc
25e3 : 08 > php ;save flags
25e4 : c97f > cmp #$7f ;test result
> trap_ne
25e6 : d0fe > bne * ;failed not equal (non zero)
>
25e8 : 68 > pla ;load status
25e9 : 48 > pha
> cmp_flag fzc
25ea : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
25ec : d0fe > bne * ;failed not equal (non zero)
>
25ee : 28 > plp ;restore status
set_a $7e,0
> load_flag 0
25ef : a900 > lda #0 ;allow test to change I-flag (no mask)
>
25f1 : 48 > pha ;use stack to load status
25f2 : a97e > lda #$7e ;precharge accu
25f4 : 28 > plp
25f5 : c11a cmp (ind1,x)
tst_a $7e,fn
25f7 : 08 > php ;save flags
25f8 : c97e > cmp #$7e ;test result
> trap_ne
25fa : d0fe > bne * ;failed not equal (non zero)
>
25fc : 68 > pla ;load status
25fd : 48 > pha
> cmp_flag fn
25fe : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2600 : d0fe > bne * ;failed not equal (non zero)
>
2602 : 28 > plp ;restore status
set_a $80,$ff
> load_flag $ff
2603 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2605 : 48 > pha ;use stack to load status
2606 : a980 > lda #$80 ;precharge accu
2608 : 28 > plp
2609 : c11a cmp (ind1,x)
tst_a $80,~fnz
260b : 08 > php ;save flags
260c : c980 > cmp #$80 ;test result
> trap_ne
260e : d0fe > bne * ;failed not equal (non zero)
>
2610 : 68 > pla ;load status
2611 : 48 > pha
> cmp_flag ~fnz
2612 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2614 : d0fe > bne * ;failed not equal (non zero)
>
2616 : 28 > plp ;restore status
set_a $7f,$ff
> load_flag $ff
2617 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2619 : 48 > pha ;use stack to load status
261a : a97f > lda #$7f ;precharge accu
261c : 28 > plp
261d : c11a cmp (ind1,x)
tst_a $7f,~fn
261f : 08 > php ;save flags
2620 : c97f > cmp #$7f ;test result
> trap_ne
2622 : d0fe > bne * ;failed not equal (non zero)
>
2624 : 68 > pla ;load status
2625 : 48 > pha
> cmp_flag ~fn
2626 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2628 : d0fe > bne * ;failed not equal (non zero)
>
262a : 28 > plp ;restore status
set_a $7e,$ff
> load_flag $ff
262b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
262d : 48 > pha ;use stack to load status
262e : a97e > lda #$7e ;precharge accu
2630 : 28 > plp
2631 : c11a cmp (ind1,x)
tst_a $7e,~fzc
2633 : 08 > php ;save flags
2634 : c97e > cmp #$7e ;test result
> trap_ne
2636 : d0fe > bne * ;failed not equal (non zero)
>
2638 : 68 > pla ;load status
2639 : 48 > pha
> cmp_flag ~fzc
263a : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
263c : d0fe > bne * ;failed not equal (non zero)
>
263e : 28 > plp ;restore status
set_a $80,0
> load_flag 0
263f : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2641 : 48 > pha ;use stack to load status
2642 : a980 > lda #$80 ;precharge accu
2644 : 28 > plp
2645 : d11a cmp (ind1),y
tst_a $80,fc
2647 : 08 > php ;save flags
2648 : c980 > cmp #$80 ;test result
> trap_ne
264a : d0fe > bne * ;failed not equal (non zero)
>
264c : 68 > pla ;load status
264d : 48 > pha
> cmp_flag fc
264e : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2650 : d0fe > bne * ;failed not equal (non zero)
>
2652 : 28 > plp ;restore status
set_a $7f,0
> load_flag 0
2653 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2655 : 48 > pha ;use stack to load status
2656 : a97f > lda #$7f ;precharge accu
2658 : 28 > plp
2659 : d11a cmp (ind1),y
tst_a $7f,fzc
265b : 08 > php ;save flags
265c : c97f > cmp #$7f ;test result
> trap_ne
265e : d0fe > bne * ;failed not equal (non zero)
>
2660 : 68 > pla ;load status
2661 : 48 > pha
> cmp_flag fzc
2662 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2664 : d0fe > bne * ;failed not equal (non zero)
>
2666 : 28 > plp ;restore status
set_a $7e,0
> load_flag 0
2667 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2669 : 48 > pha ;use stack to load status
266a : a97e > lda #$7e ;precharge accu
266c : 28 > plp
266d : d11a cmp (ind1),y
tst_a $7e,fn
266f : 08 > php ;save flags
2670 : c97e > cmp #$7e ;test result
> trap_ne
2672 : d0fe > bne * ;failed not equal (non zero)
>
2674 : 68 > pla ;load status
2675 : 48 > pha
> cmp_flag fn
2676 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2678 : d0fe > bne * ;failed not equal (non zero)
>
267a : 28 > plp ;restore status
set_a $80,$ff
> load_flag $ff
267b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
267d : 48 > pha ;use stack to load status
267e : a980 > lda #$80 ;precharge accu
2680 : 28 > plp
2681 : d11a cmp (ind1),y
tst_a $80,~fnz
2683 : 08 > php ;save flags
2684 : c980 > cmp #$80 ;test result
> trap_ne
2686 : d0fe > bne * ;failed not equal (non zero)
>
2688 : 68 > pla ;load status
2689 : 48 > pha
> cmp_flag ~fnz
268a : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
268c : d0fe > bne * ;failed not equal (non zero)
>
268e : 28 > plp ;restore status
set_a $7f,$ff
> load_flag $ff
268f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2691 : 48 > pha ;use stack to load status
2692 : a97f > lda #$7f ;precharge accu
2694 : 28 > plp
2695 : d11a cmp (ind1),y
tst_a $7f,~fn
2697 : 08 > php ;save flags
2698 : c97f > cmp #$7f ;test result
> trap_ne
269a : d0fe > bne * ;failed not equal (non zero)
>
269c : 68 > pla ;load status
269d : 48 > pha
> cmp_flag ~fn
269e : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
26a0 : d0fe > bne * ;failed not equal (non zero)
>
26a2 : 28 > plp ;restore status
set_a $7e,$ff
> load_flag $ff
26a3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
26a5 : 48 > pha ;use stack to load status
26a6 : a97e > lda #$7e ;precharge accu
26a8 : 28 > plp
26a9 : d11a cmp (ind1),y
tst_a $7e,~fzc
26ab : 08 > php ;save flags
26ac : c97e > cmp #$7e ;test result
> trap_ne
26ae : d0fe > bne * ;failed not equal (non zero)
>
26b0 : 68 > pla ;load status
26b1 : 48 > pha
> cmp_flag ~fzc
26b2 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
26b4 : d0fe > bne * ;failed not equal (non zero)
>
26b6 : 28 > plp ;restore status
next_test
26b7 : ad0002 > lda test_case ;previous test
26ba : c91c > cmp #test_num
> trap_ne ;test is out of sequence
26bc : d0fe > bne * ;failed not equal (non zero)
>
001d = >test_num = test_num + 1
26be : a91d > lda #test_num ;*** next tests' number
26c0 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; testing shifts - ASL LSR ROL ROR all addressing modes
; shifts - accumulator
26c3 : a203 ldx #3
26c5 : tasl
set_ax zp1,0
> load_flag 0
26c5 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
26c7 : 48 > pha ;use stack to load status
26c8 : b509 > lda zp1,x ;precharge accu
26ca : 28 > plp
26cb : 0a asl a
tst_ax rASL,fASL,0
26cc : 08 > php ;save flags
26cd : dd2002 > cmp rASL,x ;test result
> trap_ne
26d0 : d0fe > bne * ;failed not equal (non zero)
>
26d2 : 68 > pla ;load status
> eor_flag 0
26d3 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
26d5 : dd3002 > cmp fASL,x ;test flags
> trap_ne ;
26d8 : d0fe > bne * ;failed not equal (non zero)
>
26da : ca dex
26db : 10e8 bpl tasl
26dd : a203 ldx #3
26df : tasl1
set_ax zp1,$ff
> load_flag $ff
26df : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
26e1 : 48 > pha ;use stack to load status
26e2 : b509 > lda zp1,x ;precharge accu
26e4 : 28 > plp
26e5 : 0a asl a
tst_ax rASL,fASL,$ff-fnzc
26e6 : 08 > php ;save flags
26e7 : dd2002 > cmp rASL,x ;test result
> trap_ne
26ea : d0fe > bne * ;failed not equal (non zero)
>
26ec : 68 > pla ;load status
> eor_flag $ff-fnzc
26ed : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
26ef : dd3002 > cmp fASL,x ;test flags
> trap_ne ;
26f2 : d0fe > bne * ;failed not equal (non zero)
>
26f4 : ca dex
26f5 : 10e8 bpl tasl1
26f7 : a203 ldx #3
26f9 : tlsr
set_ax zp1,0
> load_flag 0
26f9 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
26fb : 48 > pha ;use stack to load status
26fc : b509 > lda zp1,x ;precharge accu
26fe : 28 > plp
26ff : 4a lsr a
tst_ax rLSR,fLSR,0
2700 : 08 > php ;save flags
2701 : dd2802 > cmp rLSR,x ;test result
> trap_ne
2704 : d0fe > bne * ;failed not equal (non zero)
>
2706 : 68 > pla ;load status
> eor_flag 0
2707 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2709 : dd3802 > cmp fLSR,x ;test flags
> trap_ne ;
270c : d0fe > bne * ;failed not equal (non zero)
>
270e : ca dex
270f : 10e8 bpl tlsr
2711 : a203 ldx #3
2713 : tlsr1
set_ax zp1,$ff
> load_flag $ff
2713 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2715 : 48 > pha ;use stack to load status
2716 : b509 > lda zp1,x ;precharge accu
2718 : 28 > plp
2719 : 4a lsr a
tst_ax rLSR,fLSR,$ff-fnzc
271a : 08 > php ;save flags
271b : dd2802 > cmp rLSR,x ;test result
> trap_ne
271e : d0fe > bne * ;failed not equal (non zero)
>
2720 : 68 > pla ;load status
> eor_flag $ff-fnzc
2721 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2723 : dd3802 > cmp fLSR,x ;test flags
> trap_ne ;
2726 : d0fe > bne * ;failed not equal (non zero)
>
2728 : ca dex
2729 : 10e8 bpl tlsr1
272b : a203 ldx #3
272d : trol
set_ax zp1,0
> load_flag 0
272d : a900 > lda #0 ;allow test to change I-flag (no mask)
>
272f : 48 > pha ;use stack to load status
2730 : b509 > lda zp1,x ;precharge accu
2732 : 28 > plp
2733 : 2a rol a
tst_ax rROL,fROL,0
2734 : 08 > php ;save flags
2735 : dd2002 > cmp rROL,x ;test result
> trap_ne
2738 : d0fe > bne * ;failed not equal (non zero)
>
273a : 68 > pla ;load status
> eor_flag 0
273b : 4930 > eor #0|fao ;invert expected flags + always on bits
>
273d : dd3002 > cmp fROL,x ;test flags
> trap_ne ;
2740 : d0fe > bne * ;failed not equal (non zero)
>
2742 : ca dex
2743 : 10e8 bpl trol
2745 : a203 ldx #3
2747 : trol1
set_ax zp1,$ff-fc
> load_flag $ff-fc
2747 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
>
2749 : 48 > pha ;use stack to load status
274a : b509 > lda zp1,x ;precharge accu
274c : 28 > plp
274d : 2a rol a
tst_ax rROL,fROL,$ff-fnzc
274e : 08 > php ;save flags
274f : dd2002 > cmp rROL,x ;test result
> trap_ne
2752 : d0fe > bne * ;failed not equal (non zero)
>
2754 : 68 > pla ;load status
> eor_flag $ff-fnzc
2755 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2757 : dd3002 > cmp fROL,x ;test flags
> trap_ne ;
275a : d0fe > bne * ;failed not equal (non zero)
>
275c : ca dex
275d : 10e8 bpl trol1
275f : a203 ldx #3
2761 : trolc
set_ax zp1,fc
> load_flag fc
2761 : a901 > lda #fc ;allow test to change I-flag (no mask)
>
2763 : 48 > pha ;use stack to load status
2764 : b509 > lda zp1,x ;precharge accu
2766 : 28 > plp
2767 : 2a rol a
tst_ax rROLc,fROLc,0
2768 : 08 > php ;save flags
2769 : dd2402 > cmp rROLc,x ;test result
> trap_ne
276c : d0fe > bne * ;failed not equal (non zero)
>
276e : 68 > pla ;load status
> eor_flag 0
276f : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2771 : dd3402 > cmp fROLc,x ;test flags
> trap_ne ;
2774 : d0fe > bne * ;failed not equal (non zero)
>
2776 : ca dex
2777 : 10e8 bpl trolc
2779 : a203 ldx #3
277b : trolc1
set_ax zp1,$ff
> load_flag $ff
277b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
277d : 48 > pha ;use stack to load status
277e : b509 > lda zp1,x ;precharge accu
2780 : 28 > plp
2781 : 2a rol a
tst_ax rROLc,fROLc,$ff-fnzc
2782 : 08 > php ;save flags
2783 : dd2402 > cmp rROLc,x ;test result
> trap_ne
2786 : d0fe > bne * ;failed not equal (non zero)
>
2788 : 68 > pla ;load status
> eor_flag $ff-fnzc
2789 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
278b : dd3402 > cmp fROLc,x ;test flags
> trap_ne ;
278e : d0fe > bne * ;failed not equal (non zero)
>
2790 : ca dex
2791 : 10e8 bpl trolc1
2793 : a203 ldx #3
2795 : tror
set_ax zp1,0
> load_flag 0
2795 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2797 : 48 > pha ;use stack to load status
2798 : b509 > lda zp1,x ;precharge accu
279a : 28 > plp
279b : 6a ror a
tst_ax rROR,fROR,0
279c : 08 > php ;save flags
279d : dd2802 > cmp rROR,x ;test result
> trap_ne
27a0 : d0fe > bne * ;failed not equal (non zero)
>
27a2 : 68 > pla ;load status
> eor_flag 0
27a3 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
27a5 : dd3802 > cmp fROR,x ;test flags
> trap_ne ;
27a8 : d0fe > bne * ;failed not equal (non zero)
>
27aa : ca dex
27ab : 10e8 bpl tror
27ad : a203 ldx #3
27af : tror1
set_ax zp1,$ff-fc
> load_flag $ff-fc
27af : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
>
27b1 : 48 > pha ;use stack to load status
27b2 : b509 > lda zp1,x ;precharge accu
27b4 : 28 > plp
27b5 : 6a ror a
tst_ax rROR,fROR,$ff-fnzc
27b6 : 08 > php ;save flags
27b7 : dd2802 > cmp rROR,x ;test result
> trap_ne
27ba : d0fe > bne * ;failed not equal (non zero)
>
27bc : 68 > pla ;load status
> eor_flag $ff-fnzc
27bd : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
27bf : dd3802 > cmp fROR,x ;test flags
> trap_ne ;
27c2 : d0fe > bne * ;failed not equal (non zero)
>
27c4 : ca dex
27c5 : 10e8 bpl tror1
27c7 : a203 ldx #3
27c9 : trorc
set_ax zp1,fc
> load_flag fc
27c9 : a901 > lda #fc ;allow test to change I-flag (no mask)
>
27cb : 48 > pha ;use stack to load status
27cc : b509 > lda zp1,x ;precharge accu
27ce : 28 > plp
27cf : 6a ror a
tst_ax rRORc,fRORc,0
27d0 : 08 > php ;save flags
27d1 : dd2c02 > cmp rRORc,x ;test result
> trap_ne
27d4 : d0fe > bne * ;failed not equal (non zero)
>
27d6 : 68 > pla ;load status
> eor_flag 0
27d7 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
27d9 : dd3c02 > cmp fRORc,x ;test flags
> trap_ne ;
27dc : d0fe > bne * ;failed not equal (non zero)
>
27de : ca dex
27df : 10e8 bpl trorc
27e1 : a203 ldx #3
27e3 : trorc1
set_ax zp1,$ff
> load_flag $ff
27e3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
27e5 : 48 > pha ;use stack to load status
27e6 : b509 > lda zp1,x ;precharge accu
27e8 : 28 > plp
27e9 : 6a ror a
tst_ax rRORc,fRORc,$ff-fnzc
27ea : 08 > php ;save flags
27eb : dd2c02 > cmp rRORc,x ;test result
> trap_ne
27ee : d0fe > bne * ;failed not equal (non zero)
>
27f0 : 68 > pla ;load status
> eor_flag $ff-fnzc
27f1 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
27f3 : dd3c02 > cmp fRORc,x ;test flags
> trap_ne ;
27f6 : d0fe > bne * ;failed not equal (non zero)
>
27f8 : ca dex
27f9 : 10e8 bpl trorc1
next_test
27fb : ad0002 > lda test_case ;previous test
27fe : c91d > cmp #test_num
> trap_ne ;test is out of sequence
2800 : d0fe > bne * ;failed not equal (non zero)
>
001e = >test_num = test_num + 1
2802 : a91e > lda #test_num ;*** next tests' number
2804 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; shifts - zeropage
2807 : a203 ldx #3
2809 : tasl2
set_z zp1,0
> load_flag 0
2809 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
280b : 48 > pha ;use stack to load status
280c : b509 > lda zp1,x ;load to zeropage
280e : 8502 > sta zpt
2810 : 28 > plp
2811 : 0602 asl zpt
tst_z rASL,fASL,0
2813 : 08 > php ;save flags
2814 : a502 > lda zpt
2816 : dd2002 > cmp rASL,x ;test result
> trap_ne
2819 : d0fe > bne * ;failed not equal (non zero)
>
281b : 68 > pla ;load status
> eor_flag 0
281c : 4930 > eor #0|fao ;invert expected flags + always on bits
>
281e : dd3002 > cmp fASL,x ;test flags
> trap_ne
2821 : d0fe > bne * ;failed not equal (non zero)
>
2823 : ca dex
2824 : 10e3 bpl tasl2
2826 : a203 ldx #3
2828 : tasl3
set_z zp1,$ff
> load_flag $ff
2828 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
282a : 48 > pha ;use stack to load status
282b : b509 > lda zp1,x ;load to zeropage
282d : 8502 > sta zpt
282f : 28 > plp
2830 : 0602 asl zpt
tst_z rASL,fASL,$ff-fnzc
2832 : 08 > php ;save flags
2833 : a502 > lda zpt
2835 : dd2002 > cmp rASL,x ;test result
> trap_ne
2838 : d0fe > bne * ;failed not equal (non zero)
>
283a : 68 > pla ;load status
> eor_flag $ff-fnzc
283b : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
283d : dd3002 > cmp fASL,x ;test flags
> trap_ne
2840 : d0fe > bne * ;failed not equal (non zero)
>
2842 : ca dex
2843 : 10e3 bpl tasl3
2845 : a203 ldx #3
2847 : tlsr2
set_z zp1,0
> load_flag 0
2847 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2849 : 48 > pha ;use stack to load status
284a : b509 > lda zp1,x ;load to zeropage
284c : 8502 > sta zpt
284e : 28 > plp
284f : 4602 lsr zpt
tst_z rLSR,fLSR,0
2851 : 08 > php ;save flags
2852 : a502 > lda zpt
2854 : dd2802 > cmp rLSR,x ;test result
> trap_ne
2857 : d0fe > bne * ;failed not equal (non zero)
>
2859 : 68 > pla ;load status
> eor_flag 0
285a : 4930 > eor #0|fao ;invert expected flags + always on bits
>
285c : dd3802 > cmp fLSR,x ;test flags
> trap_ne
285f : d0fe > bne * ;failed not equal (non zero)
>
2861 : ca dex
2862 : 10e3 bpl tlsr2
2864 : a203 ldx #3
2866 : tlsr3
set_z zp1,$ff
> load_flag $ff
2866 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2868 : 48 > pha ;use stack to load status
2869 : b509 > lda zp1,x ;load to zeropage
286b : 8502 > sta zpt
286d : 28 > plp
286e : 4602 lsr zpt
tst_z rLSR,fLSR,$ff-fnzc
2870 : 08 > php ;save flags
2871 : a502 > lda zpt
2873 : dd2802 > cmp rLSR,x ;test result
> trap_ne
2876 : d0fe > bne * ;failed not equal (non zero)
>
2878 : 68 > pla ;load status
> eor_flag $ff-fnzc
2879 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
287b : dd3802 > cmp fLSR,x ;test flags
> trap_ne
287e : d0fe > bne * ;failed not equal (non zero)
>
2880 : ca dex
2881 : 10e3 bpl tlsr3
2883 : a203 ldx #3
2885 : trol2
set_z zp1,0
> load_flag 0
2885 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2887 : 48 > pha ;use stack to load status
2888 : b509 > lda zp1,x ;load to zeropage
288a : 8502 > sta zpt
288c : 28 > plp
288d : 2602 rol zpt
tst_z rROL,fROL,0
288f : 08 > php ;save flags
2890 : a502 > lda zpt
2892 : dd2002 > cmp rROL,x ;test result
> trap_ne
2895 : d0fe > bne * ;failed not equal (non zero)
>
2897 : 68 > pla ;load status
> eor_flag 0
2898 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
289a : dd3002 > cmp fROL,x ;test flags
> trap_ne
289d : d0fe > bne * ;failed not equal (non zero)
>
289f : ca dex
28a0 : 10e3 bpl trol2
28a2 : a203 ldx #3
28a4 : trol3
set_z zp1,$ff-fc
> load_flag $ff-fc
28a4 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
>
28a6 : 48 > pha ;use stack to load status
28a7 : b509 > lda zp1,x ;load to zeropage
28a9 : 8502 > sta zpt
28ab : 28 > plp
28ac : 2602 rol zpt
tst_z rROL,fROL,$ff-fnzc
28ae : 08 > php ;save flags
28af : a502 > lda zpt
28b1 : dd2002 > cmp rROL,x ;test result
> trap_ne
28b4 : d0fe > bne * ;failed not equal (non zero)
>
28b6 : 68 > pla ;load status
> eor_flag $ff-fnzc
28b7 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
28b9 : dd3002 > cmp fROL,x ;test flags
> trap_ne
28bc : d0fe > bne * ;failed not equal (non zero)
>
28be : ca dex
28bf : 10e3 bpl trol3
28c1 : a203 ldx #3
28c3 : trolc2
set_z zp1,fc
> load_flag fc
28c3 : a901 > lda #fc ;allow test to change I-flag (no mask)
>
28c5 : 48 > pha ;use stack to load status
28c6 : b509 > lda zp1,x ;load to zeropage
28c8 : 8502 > sta zpt
28ca : 28 > plp
28cb : 2602 rol zpt
tst_z rROLc,fROLc,0
28cd : 08 > php ;save flags
28ce : a502 > lda zpt
28d0 : dd2402 > cmp rROLc,x ;test result
> trap_ne
28d3 : d0fe > bne * ;failed not equal (non zero)
>
28d5 : 68 > pla ;load status
> eor_flag 0
28d6 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
28d8 : dd3402 > cmp fROLc,x ;test flags
> trap_ne
28db : d0fe > bne * ;failed not equal (non zero)
>
28dd : ca dex
28de : 10e3 bpl trolc2
28e0 : a203 ldx #3
28e2 : trolc3
set_z zp1,$ff
> load_flag $ff
28e2 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
28e4 : 48 > pha ;use stack to load status
28e5 : b509 > lda zp1,x ;load to zeropage
28e7 : 8502 > sta zpt
28e9 : 28 > plp
28ea : 2602 rol zpt
tst_z rROLc,fROLc,$ff-fnzc
28ec : 08 > php ;save flags
28ed : a502 > lda zpt
28ef : dd2402 > cmp rROLc,x ;test result
> trap_ne
28f2 : d0fe > bne * ;failed not equal (non zero)
>
28f4 : 68 > pla ;load status
> eor_flag $ff-fnzc
28f5 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
28f7 : dd3402 > cmp fROLc,x ;test flags
> trap_ne
28fa : d0fe > bne * ;failed not equal (non zero)
>
28fc : ca dex
28fd : 10e3 bpl trolc3
28ff : a203 ldx #3
2901 : tror2
set_z zp1,0
> load_flag 0
2901 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2903 : 48 > pha ;use stack to load status
2904 : b509 > lda zp1,x ;load to zeropage
2906 : 8502 > sta zpt
2908 : 28 > plp
2909 : 6602 ror zpt
tst_z rROR,fROR,0
290b : 08 > php ;save flags
290c : a502 > lda zpt
290e : dd2802 > cmp rROR,x ;test result
> trap_ne
2911 : d0fe > bne * ;failed not equal (non zero)
>
2913 : 68 > pla ;load status
> eor_flag 0
2914 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2916 : dd3802 > cmp fROR,x ;test flags
> trap_ne
2919 : d0fe > bne * ;failed not equal (non zero)
>
291b : ca dex
291c : 10e3 bpl tror2
291e : a203 ldx #3
2920 : tror3
set_z zp1,$ff-fc
> load_flag $ff-fc
2920 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
>
2922 : 48 > pha ;use stack to load status
2923 : b509 > lda zp1,x ;load to zeropage
2925 : 8502 > sta zpt
2927 : 28 > plp
2928 : 6602 ror zpt
tst_z rROR,fROR,$ff-fnzc
292a : 08 > php ;save flags
292b : a502 > lda zpt
292d : dd2802 > cmp rROR,x ;test result
> trap_ne
2930 : d0fe > bne * ;failed not equal (non zero)
>
2932 : 68 > pla ;load status
> eor_flag $ff-fnzc
2933 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2935 : dd3802 > cmp fROR,x ;test flags
> trap_ne
2938 : d0fe > bne * ;failed not equal (non zero)
>
293a : ca dex
293b : 10e3 bpl tror3
293d : a203 ldx #3
293f : trorc2
set_z zp1,fc
> load_flag fc
293f : a901 > lda #fc ;allow test to change I-flag (no mask)
>
2941 : 48 > pha ;use stack to load status
2942 : b509 > lda zp1,x ;load to zeropage
2944 : 8502 > sta zpt
2946 : 28 > plp
2947 : 6602 ror zpt
tst_z rRORc,fRORc,0
2949 : 08 > php ;save flags
294a : a502 > lda zpt
294c : dd2c02 > cmp rRORc,x ;test result
> trap_ne
294f : d0fe > bne * ;failed not equal (non zero)
>
2951 : 68 > pla ;load status
> eor_flag 0
2952 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2954 : dd3c02 > cmp fRORc,x ;test flags
> trap_ne
2957 : d0fe > bne * ;failed not equal (non zero)
>
2959 : ca dex
295a : 10e3 bpl trorc2
295c : a203 ldx #3
295e : trorc3
set_z zp1,$ff
> load_flag $ff
295e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2960 : 48 > pha ;use stack to load status
2961 : b509 > lda zp1,x ;load to zeropage
2963 : 8502 > sta zpt
2965 : 28 > plp
2966 : 6602 ror zpt
tst_z rRORc,fRORc,$ff-fnzc
2968 : 08 > php ;save flags
2969 : a502 > lda zpt
296b : dd2c02 > cmp rRORc,x ;test result
> trap_ne
296e : d0fe > bne * ;failed not equal (non zero)
>
2970 : 68 > pla ;load status
> eor_flag $ff-fnzc
2971 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2973 : dd3c02 > cmp fRORc,x ;test flags
> trap_ne
2976 : d0fe > bne * ;failed not equal (non zero)
>
2978 : ca dex
2979 : 10e3 bpl trorc3
next_test
297b : ad0002 > lda test_case ;previous test
297e : c91e > cmp #test_num
> trap_ne ;test is out of sequence
2980 : d0fe > bne * ;failed not equal (non zero)
>
001f = >test_num = test_num + 1
2982 : a91f > lda #test_num ;*** next tests' number
2984 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; shifts - absolute
2987 : a203 ldx #3
2989 : tasl4
set_abs zp1,0
> load_flag 0
2989 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
298b : 48 > pha ;use stack to load status
298c : b509 > lda zp1,x ;load to memory
298e : 8d0302 > sta abst
2991 : 28 > plp
2992 : 0e0302 asl abst
tst_abs rASL,fASL,0
2995 : 08 > php ;save flags
2996 : ad0302 > lda abst
2999 : dd2002 > cmp rASL,x ;test result
> trap_ne
299c : d0fe > bne * ;failed not equal (non zero)
>
299e : 68 > pla ;load status
> eor_flag 0
299f : 4930 > eor #0|fao ;invert expected flags + always on bits
>
29a1 : dd3002 > cmp fASL,x ;test flags
> trap_ne
29a4 : d0fe > bne * ;failed not equal (non zero)
>
29a6 : ca dex
29a7 : 10e0 bpl tasl4
29a9 : a203 ldx #3
29ab : tasl5
set_abs zp1,$ff
> load_flag $ff
29ab : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
29ad : 48 > pha ;use stack to load status
29ae : b509 > lda zp1,x ;load to memory
29b0 : 8d0302 > sta abst
29b3 : 28 > plp
29b4 : 0e0302 asl abst
tst_abs rASL,fASL,$ff-fnzc
29b7 : 08 > php ;save flags
29b8 : ad0302 > lda abst
29bb : dd2002 > cmp rASL,x ;test result
> trap_ne
29be : d0fe > bne * ;failed not equal (non zero)
>
29c0 : 68 > pla ;load status
> eor_flag $ff-fnzc
29c1 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
29c3 : dd3002 > cmp fASL,x ;test flags
> trap_ne
29c6 : d0fe > bne * ;failed not equal (non zero)
>
29c8 : ca dex
29c9 : 10e0 bpl tasl5
29cb : a203 ldx #3
29cd : tlsr4
set_abs zp1,0
> load_flag 0
29cd : a900 > lda #0 ;allow test to change I-flag (no mask)
>
29cf : 48 > pha ;use stack to load status
29d0 : b509 > lda zp1,x ;load to memory
29d2 : 8d0302 > sta abst
29d5 : 28 > plp
29d6 : 4e0302 lsr abst
tst_abs rLSR,fLSR,0
29d9 : 08 > php ;save flags
29da : ad0302 > lda abst
29dd : dd2802 > cmp rLSR,x ;test result
> trap_ne
29e0 : d0fe > bne * ;failed not equal (non zero)
>
29e2 : 68 > pla ;load status
> eor_flag 0
29e3 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
29e5 : dd3802 > cmp fLSR,x ;test flags
> trap_ne
29e8 : d0fe > bne * ;failed not equal (non zero)
>
29ea : ca dex
29eb : 10e0 bpl tlsr4
29ed : a203 ldx #3
29ef : tlsr5
set_abs zp1,$ff
> load_flag $ff
29ef : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
29f1 : 48 > pha ;use stack to load status
29f2 : b509 > lda zp1,x ;load to memory
29f4 : 8d0302 > sta abst
29f7 : 28 > plp
29f8 : 4e0302 lsr abst
tst_abs rLSR,fLSR,$ff-fnzc
29fb : 08 > php ;save flags
29fc : ad0302 > lda abst
29ff : dd2802 > cmp rLSR,x ;test result
> trap_ne
2a02 : d0fe > bne * ;failed not equal (non zero)
>
2a04 : 68 > pla ;load status
> eor_flag $ff-fnzc
2a05 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2a07 : dd3802 > cmp fLSR,x ;test flags
> trap_ne
2a0a : d0fe > bne * ;failed not equal (non zero)
>
2a0c : ca dex
2a0d : 10e0 bpl tlsr5
2a0f : a203 ldx #3
2a11 : trol4
set_abs zp1,0
> load_flag 0
2a11 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2a13 : 48 > pha ;use stack to load status
2a14 : b509 > lda zp1,x ;load to memory
2a16 : 8d0302 > sta abst
2a19 : 28 > plp
2a1a : 2e0302 rol abst
tst_abs rROL,fROL,0
2a1d : 08 > php ;save flags
2a1e : ad0302 > lda abst
2a21 : dd2002 > cmp rROL,x ;test result
> trap_ne
2a24 : d0fe > bne * ;failed not equal (non zero)
>
2a26 : 68 > pla ;load status
> eor_flag 0
2a27 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2a29 : dd3002 > cmp fROL,x ;test flags
> trap_ne
2a2c : d0fe > bne * ;failed not equal (non zero)
>
2a2e : ca dex
2a2f : 10e0 bpl trol4
2a31 : a203 ldx #3
2a33 : trol5
set_abs zp1,$ff-fc
> load_flag $ff-fc
2a33 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
>
2a35 : 48 > pha ;use stack to load status
2a36 : b509 > lda zp1,x ;load to memory
2a38 : 8d0302 > sta abst
2a3b : 28 > plp
2a3c : 2e0302 rol abst
tst_abs rROL,fROL,$ff-fnzc
2a3f : 08 > php ;save flags
2a40 : ad0302 > lda abst
2a43 : dd2002 > cmp rROL,x ;test result
> trap_ne
2a46 : d0fe > bne * ;failed not equal (non zero)
>
2a48 : 68 > pla ;load status
> eor_flag $ff-fnzc
2a49 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2a4b : dd3002 > cmp fROL,x ;test flags
> trap_ne
2a4e : d0fe > bne * ;failed not equal (non zero)
>
2a50 : ca dex
2a51 : 10e0 bpl trol5
2a53 : a203 ldx #3
2a55 : trolc4
set_abs zp1,fc
> load_flag fc
2a55 : a901 > lda #fc ;allow test to change I-flag (no mask)
>
2a57 : 48 > pha ;use stack to load status
2a58 : b509 > lda zp1,x ;load to memory
2a5a : 8d0302 > sta abst
2a5d : 28 > plp
2a5e : 2e0302 rol abst
tst_abs rROLc,fROLc,0
2a61 : 08 > php ;save flags
2a62 : ad0302 > lda abst
2a65 : dd2402 > cmp rROLc,x ;test result
> trap_ne
2a68 : d0fe > bne * ;failed not equal (non zero)
>
2a6a : 68 > pla ;load status
> eor_flag 0
2a6b : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2a6d : dd3402 > cmp fROLc,x ;test flags
> trap_ne
2a70 : d0fe > bne * ;failed not equal (non zero)
>
2a72 : ca dex
2a73 : 10e0 bpl trolc4
2a75 : a203 ldx #3
2a77 : trolc5
set_abs zp1,$ff
> load_flag $ff
2a77 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2a79 : 48 > pha ;use stack to load status
2a7a : b509 > lda zp1,x ;load to memory
2a7c : 8d0302 > sta abst
2a7f : 28 > plp
2a80 : 2e0302 rol abst
tst_abs rROLc,fROLc,$ff-fnzc
2a83 : 08 > php ;save flags
2a84 : ad0302 > lda abst
2a87 : dd2402 > cmp rROLc,x ;test result
> trap_ne
2a8a : d0fe > bne * ;failed not equal (non zero)
>
2a8c : 68 > pla ;load status
> eor_flag $ff-fnzc
2a8d : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2a8f : dd3402 > cmp fROLc,x ;test flags
> trap_ne
2a92 : d0fe > bne * ;failed not equal (non zero)
>
2a94 : ca dex
2a95 : 10e0 bpl trolc5
2a97 : a203 ldx #3
2a99 : tror4
set_abs zp1,0
> load_flag 0
2a99 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2a9b : 48 > pha ;use stack to load status
2a9c : b509 > lda zp1,x ;load to memory
2a9e : 8d0302 > sta abst
2aa1 : 28 > plp
2aa2 : 6e0302 ror abst
tst_abs rROR,fROR,0
2aa5 : 08 > php ;save flags
2aa6 : ad0302 > lda abst
2aa9 : dd2802 > cmp rROR,x ;test result
> trap_ne
2aac : d0fe > bne * ;failed not equal (non zero)
>
2aae : 68 > pla ;load status
> eor_flag 0
2aaf : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2ab1 : dd3802 > cmp fROR,x ;test flags
> trap_ne
2ab4 : d0fe > bne * ;failed not equal (non zero)
>
2ab6 : ca dex
2ab7 : 10e0 bpl tror4
2ab9 : a203 ldx #3
2abb : tror5
set_abs zp1,$ff-fc
> load_flag $ff-fc
2abb : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
>
2abd : 48 > pha ;use stack to load status
2abe : b509 > lda zp1,x ;load to memory
2ac0 : 8d0302 > sta abst
2ac3 : 28 > plp
2ac4 : 6e0302 ror abst
tst_abs rROR,fROR,$ff-fnzc
2ac7 : 08 > php ;save flags
2ac8 : ad0302 > lda abst
2acb : dd2802 > cmp rROR,x ;test result
> trap_ne
2ace : d0fe > bne * ;failed not equal (non zero)
>
2ad0 : 68 > pla ;load status
> eor_flag $ff-fnzc
2ad1 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2ad3 : dd3802 > cmp fROR,x ;test flags
> trap_ne
2ad6 : d0fe > bne * ;failed not equal (non zero)
>
2ad8 : ca dex
2ad9 : 10e0 bpl tror5
2adb : a203 ldx #3
2add : trorc4
set_abs zp1,fc
> load_flag fc
2add : a901 > lda #fc ;allow test to change I-flag (no mask)
>
2adf : 48 > pha ;use stack to load status
2ae0 : b509 > lda zp1,x ;load to memory
2ae2 : 8d0302 > sta abst
2ae5 : 28 > plp
2ae6 : 6e0302 ror abst
tst_abs rRORc,fRORc,0
2ae9 : 08 > php ;save flags
2aea : ad0302 > lda abst
2aed : dd2c02 > cmp rRORc,x ;test result
> trap_ne
2af0 : d0fe > bne * ;failed not equal (non zero)
>
2af2 : 68 > pla ;load status
> eor_flag 0
2af3 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2af5 : dd3c02 > cmp fRORc,x ;test flags
> trap_ne
2af8 : d0fe > bne * ;failed not equal (non zero)
>
2afa : ca dex
2afb : 10e0 bpl trorc4
2afd : a203 ldx #3
2aff : trorc5
set_abs zp1,$ff
> load_flag $ff
2aff : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2b01 : 48 > pha ;use stack to load status
2b02 : b509 > lda zp1,x ;load to memory
2b04 : 8d0302 > sta abst
2b07 : 28 > plp
2b08 : 6e0302 ror abst
tst_abs rRORc,fRORc,$ff-fnzc
2b0b : 08 > php ;save flags
2b0c : ad0302 > lda abst
2b0f : dd2c02 > cmp rRORc,x ;test result
> trap_ne
2b12 : d0fe > bne * ;failed not equal (non zero)
>
2b14 : 68 > pla ;load status
> eor_flag $ff-fnzc
2b15 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2b17 : dd3c02 > cmp fRORc,x ;test flags
> trap_ne
2b1a : d0fe > bne * ;failed not equal (non zero)
>
2b1c : ca dex
2b1d : 10e0 bpl trorc5
next_test
2b1f : ad0002 > lda test_case ;previous test
2b22 : c91f > cmp #test_num
> trap_ne ;test is out of sequence
2b24 : d0fe > bne * ;failed not equal (non zero)
>
0020 = >test_num = test_num + 1
2b26 : a920 > lda #test_num ;*** next tests' number
2b28 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; shifts - zp indexed
2b2b : a203 ldx #3
2b2d : tasl6
set_zx zp1,0
> load_flag 0
2b2d : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2b2f : 48 > pha ;use stack to load status
2b30 : b509 > lda zp1,x ;load to indexed zeropage
2b32 : 9502 > sta zpt,x
2b34 : 28 > plp
2b35 : 1602 asl zpt,x
tst_zx rASL,fASL,0
2b37 : 08 > php ;save flags
2b38 : b502 > lda zpt,x
2b3a : dd2002 > cmp rASL,x ;test result
> trap_ne
2b3d : d0fe > bne * ;failed not equal (non zero)
>
2b3f : 68 > pla ;load status
> eor_flag 0
2b40 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2b42 : dd3002 > cmp fASL,x ;test flags
> trap_ne
2b45 : d0fe > bne * ;failed not equal (non zero)
>
2b47 : ca dex
2b48 : 10e3 bpl tasl6
2b4a : a203 ldx #3
2b4c : tasl7
set_zx zp1,$ff
> load_flag $ff
2b4c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2b4e : 48 > pha ;use stack to load status
2b4f : b509 > lda zp1,x ;load to indexed zeropage
2b51 : 9502 > sta zpt,x
2b53 : 28 > plp
2b54 : 1602 asl zpt,x
tst_zx rASL,fASL,$ff-fnzc
2b56 : 08 > php ;save flags
2b57 : b502 > lda zpt,x
2b59 : dd2002 > cmp rASL,x ;test result
> trap_ne
2b5c : d0fe > bne * ;failed not equal (non zero)
>
2b5e : 68 > pla ;load status
> eor_flag $ff-fnzc
2b5f : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2b61 : dd3002 > cmp fASL,x ;test flags
> trap_ne
2b64 : d0fe > bne * ;failed not equal (non zero)
>
2b66 : ca dex
2b67 : 10e3 bpl tasl7
2b69 : a203 ldx #3
2b6b : tlsr6
set_zx zp1,0
> load_flag 0
2b6b : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2b6d : 48 > pha ;use stack to load status
2b6e : b509 > lda zp1,x ;load to indexed zeropage
2b70 : 9502 > sta zpt,x
2b72 : 28 > plp
2b73 : 5602 lsr zpt,x
tst_zx rLSR,fLSR,0
2b75 : 08 > php ;save flags
2b76 : b502 > lda zpt,x
2b78 : dd2802 > cmp rLSR,x ;test result
> trap_ne
2b7b : d0fe > bne * ;failed not equal (non zero)
>
2b7d : 68 > pla ;load status
> eor_flag 0
2b7e : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2b80 : dd3802 > cmp fLSR,x ;test flags
> trap_ne
2b83 : d0fe > bne * ;failed not equal (non zero)
>
2b85 : ca dex
2b86 : 10e3 bpl tlsr6
2b88 : a203 ldx #3
2b8a : tlsr7
set_zx zp1,$ff
> load_flag $ff
2b8a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2b8c : 48 > pha ;use stack to load status
2b8d : b509 > lda zp1,x ;load to indexed zeropage
2b8f : 9502 > sta zpt,x
2b91 : 28 > plp
2b92 : 5602 lsr zpt,x
tst_zx rLSR,fLSR,$ff-fnzc
2b94 : 08 > php ;save flags
2b95 : b502 > lda zpt,x
2b97 : dd2802 > cmp rLSR,x ;test result
> trap_ne
2b9a : d0fe > bne * ;failed not equal (non zero)
>
2b9c : 68 > pla ;load status
> eor_flag $ff-fnzc
2b9d : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2b9f : dd3802 > cmp fLSR,x ;test flags
> trap_ne
2ba2 : d0fe > bne * ;failed not equal (non zero)
>
2ba4 : ca dex
2ba5 : 10e3 bpl tlsr7
2ba7 : a203 ldx #3
2ba9 : trol6
set_zx zp1,0
> load_flag 0
2ba9 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2bab : 48 > pha ;use stack to load status
2bac : b509 > lda zp1,x ;load to indexed zeropage
2bae : 9502 > sta zpt,x
2bb0 : 28 > plp
2bb1 : 3602 rol zpt,x
tst_zx rROL,fROL,0
2bb3 : 08 > php ;save flags
2bb4 : b502 > lda zpt,x
2bb6 : dd2002 > cmp rROL,x ;test result
> trap_ne
2bb9 : d0fe > bne * ;failed not equal (non zero)
>
2bbb : 68 > pla ;load status
> eor_flag 0
2bbc : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2bbe : dd3002 > cmp fROL,x ;test flags
> trap_ne
2bc1 : d0fe > bne * ;failed not equal (non zero)
>
2bc3 : ca dex
2bc4 : 10e3 bpl trol6
2bc6 : a203 ldx #3
2bc8 : trol7
set_zx zp1,$ff-fc
> load_flag $ff-fc
2bc8 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
>
2bca : 48 > pha ;use stack to load status
2bcb : b509 > lda zp1,x ;load to indexed zeropage
2bcd : 9502 > sta zpt,x
2bcf : 28 > plp
2bd0 : 3602 rol zpt,x
tst_zx rROL,fROL,$ff-fnzc
2bd2 : 08 > php ;save flags
2bd3 : b502 > lda zpt,x
2bd5 : dd2002 > cmp rROL,x ;test result
> trap_ne
2bd8 : d0fe > bne * ;failed not equal (non zero)
>
2bda : 68 > pla ;load status
> eor_flag $ff-fnzc
2bdb : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2bdd : dd3002 > cmp fROL,x ;test flags
> trap_ne
2be0 : d0fe > bne * ;failed not equal (non zero)
>
2be2 : ca dex
2be3 : 10e3 bpl trol7
2be5 : a203 ldx #3
2be7 : trolc6
set_zx zp1,fc
> load_flag fc
2be7 : a901 > lda #fc ;allow test to change I-flag (no mask)
>
2be9 : 48 > pha ;use stack to load status
2bea : b509 > lda zp1,x ;load to indexed zeropage
2bec : 9502 > sta zpt,x
2bee : 28 > plp
2bef : 3602 rol zpt,x
tst_zx rROLc,fROLc,0
2bf1 : 08 > php ;save flags
2bf2 : b502 > lda zpt,x
2bf4 : dd2402 > cmp rROLc,x ;test result
> trap_ne
2bf7 : d0fe > bne * ;failed not equal (non zero)
>
2bf9 : 68 > pla ;load status
> eor_flag 0
2bfa : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2bfc : dd3402 > cmp fROLc,x ;test flags
> trap_ne
2bff : d0fe > bne * ;failed not equal (non zero)
>
2c01 : ca dex
2c02 : 10e3 bpl trolc6
2c04 : a203 ldx #3
2c06 : trolc7
set_zx zp1,$ff
> load_flag $ff
2c06 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2c08 : 48 > pha ;use stack to load status
2c09 : b509 > lda zp1,x ;load to indexed zeropage
2c0b : 9502 > sta zpt,x
2c0d : 28 > plp
2c0e : 3602 rol zpt,x
tst_zx rROLc,fROLc,$ff-fnzc
2c10 : 08 > php ;save flags
2c11 : b502 > lda zpt,x
2c13 : dd2402 > cmp rROLc,x ;test result
> trap_ne
2c16 : d0fe > bne * ;failed not equal (non zero)
>
2c18 : 68 > pla ;load status
> eor_flag $ff-fnzc
2c19 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2c1b : dd3402 > cmp fROLc,x ;test flags
> trap_ne
2c1e : d0fe > bne * ;failed not equal (non zero)
>
2c20 : ca dex
2c21 : 10e3 bpl trolc7
2c23 : a203 ldx #3
2c25 : tror6
set_zx zp1,0
> load_flag 0
2c25 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2c27 : 48 > pha ;use stack to load status
2c28 : b509 > lda zp1,x ;load to indexed zeropage
2c2a : 9502 > sta zpt,x
2c2c : 28 > plp
2c2d : 7602 ror zpt,x
tst_zx rROR,fROR,0
2c2f : 08 > php ;save flags
2c30 : b502 > lda zpt,x
2c32 : dd2802 > cmp rROR,x ;test result
> trap_ne
2c35 : d0fe > bne * ;failed not equal (non zero)
>
2c37 : 68 > pla ;load status
> eor_flag 0
2c38 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2c3a : dd3802 > cmp fROR,x ;test flags
> trap_ne
2c3d : d0fe > bne * ;failed not equal (non zero)
>
2c3f : ca dex
2c40 : 10e3 bpl tror6
2c42 : a203 ldx #3
2c44 : tror7
set_zx zp1,$ff-fc
> load_flag $ff-fc
2c44 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
>
2c46 : 48 > pha ;use stack to load status
2c47 : b509 > lda zp1,x ;load to indexed zeropage
2c49 : 9502 > sta zpt,x
2c4b : 28 > plp
2c4c : 7602 ror zpt,x
tst_zx rROR,fROR,$ff-fnzc
2c4e : 08 > php ;save flags
2c4f : b502 > lda zpt,x
2c51 : dd2802 > cmp rROR,x ;test result
> trap_ne
2c54 : d0fe > bne * ;failed not equal (non zero)
>
2c56 : 68 > pla ;load status
> eor_flag $ff-fnzc
2c57 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2c59 : dd3802 > cmp fROR,x ;test flags
> trap_ne
2c5c : d0fe > bne * ;failed not equal (non zero)
>
2c5e : ca dex
2c5f : 10e3 bpl tror7
2c61 : a203 ldx #3
2c63 : trorc6
set_zx zp1,fc
> load_flag fc
2c63 : a901 > lda #fc ;allow test to change I-flag (no mask)
>
2c65 : 48 > pha ;use stack to load status
2c66 : b509 > lda zp1,x ;load to indexed zeropage
2c68 : 9502 > sta zpt,x
2c6a : 28 > plp
2c6b : 7602 ror zpt,x
tst_zx rRORc,fRORc,0
2c6d : 08 > php ;save flags
2c6e : b502 > lda zpt,x
2c70 : dd2c02 > cmp rRORc,x ;test result
> trap_ne
2c73 : d0fe > bne * ;failed not equal (non zero)
>
2c75 : 68 > pla ;load status
> eor_flag 0
2c76 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2c78 : dd3c02 > cmp fRORc,x ;test flags
> trap_ne
2c7b : d0fe > bne * ;failed not equal (non zero)
>
2c7d : ca dex
2c7e : 10e3 bpl trorc6
2c80 : a203 ldx #3
2c82 : trorc7
set_zx zp1,$ff
> load_flag $ff
2c82 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2c84 : 48 > pha ;use stack to load status
2c85 : b509 > lda zp1,x ;load to indexed zeropage
2c87 : 9502 > sta zpt,x
2c89 : 28 > plp
2c8a : 7602 ror zpt,x
tst_zx rRORc,fRORc,$ff-fnzc
2c8c : 08 > php ;save flags
2c8d : b502 > lda zpt,x
2c8f : dd2c02 > cmp rRORc,x ;test result
> trap_ne
2c92 : d0fe > bne * ;failed not equal (non zero)
>
2c94 : 68 > pla ;load status
> eor_flag $ff-fnzc
2c95 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2c97 : dd3c02 > cmp fRORc,x ;test flags
> trap_ne
2c9a : d0fe > bne * ;failed not equal (non zero)
>
2c9c : ca dex
2c9d : 10e3 bpl trorc7
next_test
2c9f : ad0002 > lda test_case ;previous test
2ca2 : c920 > cmp #test_num
> trap_ne ;test is out of sequence
2ca4 : d0fe > bne * ;failed not equal (non zero)
>
0021 = >test_num = test_num + 1
2ca6 : a921 > lda #test_num ;*** next tests' number
2ca8 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; shifts - abs indexed
2cab : a203 ldx #3
2cad : tasl8
set_absx zp1,0
> load_flag 0
2cad : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2caf : 48 > pha ;use stack to load status
2cb0 : b509 > lda zp1,x ;load to indexed memory
2cb2 : 9d0302 > sta abst,x
2cb5 : 28 > plp
2cb6 : 1e0302 asl abst,x
tst_absx rASL,fASL,0
2cb9 : 08 > php ;save flags
2cba : bd0302 > lda abst,x
2cbd : dd2002 > cmp rASL,x ;test result
> trap_ne
2cc0 : d0fe > bne * ;failed not equal (non zero)
>
2cc2 : 68 > pla ;load status
> eor_flag 0
2cc3 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2cc5 : dd3002 > cmp fASL,x ;test flags
> trap_ne
2cc8 : d0fe > bne * ;failed not equal (non zero)
>
2cca : ca dex
2ccb : 10e0 bpl tasl8
2ccd : a203 ldx #3
2ccf : tasl9
set_absx zp1,$ff
> load_flag $ff
2ccf : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2cd1 : 48 > pha ;use stack to load status
2cd2 : b509 > lda zp1,x ;load to indexed memory
2cd4 : 9d0302 > sta abst,x
2cd7 : 28 > plp
2cd8 : 1e0302 asl abst,x
tst_absx rASL,fASL,$ff-fnzc
2cdb : 08 > php ;save flags
2cdc : bd0302 > lda abst,x
2cdf : dd2002 > cmp rASL,x ;test result
> trap_ne
2ce2 : d0fe > bne * ;failed not equal (non zero)
>
2ce4 : 68 > pla ;load status
> eor_flag $ff-fnzc
2ce5 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2ce7 : dd3002 > cmp fASL,x ;test flags
> trap_ne
2cea : d0fe > bne * ;failed not equal (non zero)
>
2cec : ca dex
2ced : 10e0 bpl tasl9
2cef : a203 ldx #3
2cf1 : tlsr8
set_absx zp1,0
> load_flag 0
2cf1 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2cf3 : 48 > pha ;use stack to load status
2cf4 : b509 > lda zp1,x ;load to indexed memory
2cf6 : 9d0302 > sta abst,x
2cf9 : 28 > plp
2cfa : 5e0302 lsr abst,x
tst_absx rLSR,fLSR,0
2cfd : 08 > php ;save flags
2cfe : bd0302 > lda abst,x
2d01 : dd2802 > cmp rLSR,x ;test result
> trap_ne
2d04 : d0fe > bne * ;failed not equal (non zero)
>
2d06 : 68 > pla ;load status
> eor_flag 0
2d07 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2d09 : dd3802 > cmp fLSR,x ;test flags
> trap_ne
2d0c : d0fe > bne * ;failed not equal (non zero)
>
2d0e : ca dex
2d0f : 10e0 bpl tlsr8
2d11 : a203 ldx #3
2d13 : tlsr9
set_absx zp1,$ff
> load_flag $ff
2d13 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2d15 : 48 > pha ;use stack to load status
2d16 : b509 > lda zp1,x ;load to indexed memory
2d18 : 9d0302 > sta abst,x
2d1b : 28 > plp
2d1c : 5e0302 lsr abst,x
tst_absx rLSR,fLSR,$ff-fnzc
2d1f : 08 > php ;save flags
2d20 : bd0302 > lda abst,x
2d23 : dd2802 > cmp rLSR,x ;test result
> trap_ne
2d26 : d0fe > bne * ;failed not equal (non zero)
>
2d28 : 68 > pla ;load status
> eor_flag $ff-fnzc
2d29 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2d2b : dd3802 > cmp fLSR,x ;test flags
> trap_ne
2d2e : d0fe > bne * ;failed not equal (non zero)
>
2d30 : ca dex
2d31 : 10e0 bpl tlsr9
2d33 : a203 ldx #3
2d35 : trol8
set_absx zp1,0
> load_flag 0
2d35 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2d37 : 48 > pha ;use stack to load status
2d38 : b509 > lda zp1,x ;load to indexed memory
2d3a : 9d0302 > sta abst,x
2d3d : 28 > plp
2d3e : 3e0302 rol abst,x
tst_absx rROL,fROL,0
2d41 : 08 > php ;save flags
2d42 : bd0302 > lda abst,x
2d45 : dd2002 > cmp rROL,x ;test result
> trap_ne
2d48 : d0fe > bne * ;failed not equal (non zero)
>
2d4a : 68 > pla ;load status
> eor_flag 0
2d4b : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2d4d : dd3002 > cmp fROL,x ;test flags
> trap_ne
2d50 : d0fe > bne * ;failed not equal (non zero)
>
2d52 : ca dex
2d53 : 10e0 bpl trol8
2d55 : a203 ldx #3
2d57 : trol9
set_absx zp1,$ff-fc
> load_flag $ff-fc
2d57 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
>
2d59 : 48 > pha ;use stack to load status
2d5a : b509 > lda zp1,x ;load to indexed memory
2d5c : 9d0302 > sta abst,x
2d5f : 28 > plp
2d60 : 3e0302 rol abst,x
tst_absx rROL,fROL,$ff-fnzc
2d63 : 08 > php ;save flags
2d64 : bd0302 > lda abst,x
2d67 : dd2002 > cmp rROL,x ;test result
> trap_ne
2d6a : d0fe > bne * ;failed not equal (non zero)
>
2d6c : 68 > pla ;load status
> eor_flag $ff-fnzc
2d6d : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2d6f : dd3002 > cmp fROL,x ;test flags
> trap_ne
2d72 : d0fe > bne * ;failed not equal (non zero)
>
2d74 : ca dex
2d75 : 10e0 bpl trol9
2d77 : a203 ldx #3
2d79 : trolc8
set_absx zp1,fc
> load_flag fc
2d79 : a901 > lda #fc ;allow test to change I-flag (no mask)
>
2d7b : 48 > pha ;use stack to load status
2d7c : b509 > lda zp1,x ;load to indexed memory
2d7e : 9d0302 > sta abst,x
2d81 : 28 > plp
2d82 : 3e0302 rol abst,x
tst_absx rROLc,fROLc,0
2d85 : 08 > php ;save flags
2d86 : bd0302 > lda abst,x
2d89 : dd2402 > cmp rROLc,x ;test result
> trap_ne
2d8c : d0fe > bne * ;failed not equal (non zero)
>
2d8e : 68 > pla ;load status
> eor_flag 0
2d8f : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2d91 : dd3402 > cmp fROLc,x ;test flags
> trap_ne
2d94 : d0fe > bne * ;failed not equal (non zero)
>
2d96 : ca dex
2d97 : 10e0 bpl trolc8
2d99 : a203 ldx #3
2d9b : trolc9
set_absx zp1,$ff
> load_flag $ff
2d9b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2d9d : 48 > pha ;use stack to load status
2d9e : b509 > lda zp1,x ;load to indexed memory
2da0 : 9d0302 > sta abst,x
2da3 : 28 > plp
2da4 : 3e0302 rol abst,x
tst_absx rROLc,fROLc,$ff-fnzc
2da7 : 08 > php ;save flags
2da8 : bd0302 > lda abst,x
2dab : dd2402 > cmp rROLc,x ;test result
> trap_ne
2dae : d0fe > bne * ;failed not equal (non zero)
>
2db0 : 68 > pla ;load status
> eor_flag $ff-fnzc
2db1 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2db3 : dd3402 > cmp fROLc,x ;test flags
> trap_ne
2db6 : d0fe > bne * ;failed not equal (non zero)
>
2db8 : ca dex
2db9 : 10e0 bpl trolc9
2dbb : a203 ldx #3
2dbd : tror8
set_absx zp1,0
> load_flag 0
2dbd : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2dbf : 48 > pha ;use stack to load status
2dc0 : b509 > lda zp1,x ;load to indexed memory
2dc2 : 9d0302 > sta abst,x
2dc5 : 28 > plp
2dc6 : 7e0302 ror abst,x
tst_absx rROR,fROR,0
2dc9 : 08 > php ;save flags
2dca : bd0302 > lda abst,x
2dcd : dd2802 > cmp rROR,x ;test result
> trap_ne
2dd0 : d0fe > bne * ;failed not equal (non zero)
>
2dd2 : 68 > pla ;load status
> eor_flag 0
2dd3 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2dd5 : dd3802 > cmp fROR,x ;test flags
> trap_ne
2dd8 : d0fe > bne * ;failed not equal (non zero)
>
2dda : ca dex
2ddb : 10e0 bpl tror8
2ddd : a203 ldx #3
2ddf : tror9
set_absx zp1,$ff-fc
> load_flag $ff-fc
2ddf : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
>
2de1 : 48 > pha ;use stack to load status
2de2 : b509 > lda zp1,x ;load to indexed memory
2de4 : 9d0302 > sta abst,x
2de7 : 28 > plp
2de8 : 7e0302 ror abst,x
tst_absx rROR,fROR,$ff-fnzc
2deb : 08 > php ;save flags
2dec : bd0302 > lda abst,x
2def : dd2802 > cmp rROR,x ;test result
> trap_ne
2df2 : d0fe > bne * ;failed not equal (non zero)
>
2df4 : 68 > pla ;load status
> eor_flag $ff-fnzc
2df5 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2df7 : dd3802 > cmp fROR,x ;test flags
> trap_ne
2dfa : d0fe > bne * ;failed not equal (non zero)
>
2dfc : ca dex
2dfd : 10e0 bpl tror9
2dff : a203 ldx #3
2e01 : trorc8
set_absx zp1,fc
> load_flag fc
2e01 : a901 > lda #fc ;allow test to change I-flag (no mask)
>
2e03 : 48 > pha ;use stack to load status
2e04 : b509 > lda zp1,x ;load to indexed memory
2e06 : 9d0302 > sta abst,x
2e09 : 28 > plp
2e0a : 7e0302 ror abst,x
tst_absx rRORc,fRORc,0
2e0d : 08 > php ;save flags
2e0e : bd0302 > lda abst,x
2e11 : dd2c02 > cmp rRORc,x ;test result
> trap_ne
2e14 : d0fe > bne * ;failed not equal (non zero)
>
2e16 : 68 > pla ;load status
> eor_flag 0
2e17 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2e19 : dd3c02 > cmp fRORc,x ;test flags
> trap_ne
2e1c : d0fe > bne * ;failed not equal (non zero)
>
2e1e : ca dex
2e1f : 10e0 bpl trorc8
2e21 : a203 ldx #3
2e23 : trorc9
set_absx zp1,$ff
> load_flag $ff
2e23 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2e25 : 48 > pha ;use stack to load status
2e26 : b509 > lda zp1,x ;load to indexed memory
2e28 : 9d0302 > sta abst,x
2e2b : 28 > plp
2e2c : 7e0302 ror abst,x
tst_absx rRORc,fRORc,$ff-fnzc
2e2f : 08 > php ;save flags
2e30 : bd0302 > lda abst,x
2e33 : dd2c02 > cmp rRORc,x ;test result
> trap_ne
2e36 : d0fe > bne * ;failed not equal (non zero)
>
2e38 : 68 > pla ;load status
> eor_flag $ff-fnzc
2e39 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2e3b : dd3c02 > cmp fRORc,x ;test flags
> trap_ne
2e3e : d0fe > bne * ;failed not equal (non zero)
>
2e40 : ca dex
2e41 : 10e0 bpl trorc9
next_test
2e43 : ad0002 > lda test_case ;previous test
2e46 : c921 > cmp #test_num
> trap_ne ;test is out of sequence
2e48 : d0fe > bne * ;failed not equal (non zero)
>
0022 = >test_num = test_num + 1
2e4a : a922 > lda #test_num ;*** next tests' number
2e4c : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; testing memory increment/decrement - INC DEC all addressing modes
; zeropage
2e4f : a200 ldx #0
2e51 : a97e lda #$7e
2e53 : 8502 sta zpt
2e55 : tinc
set_stat 0
> load_flag 0
2e55 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2e57 : 48 > pha ;use stack to load status
2e58 : 28 > plp
2e59 : e602 inc zpt
tst_z rINC,fINC,0
2e5b : 08 > php ;save flags
2e5c : a502 > lda zpt
2e5e : dd4002 > cmp rINC,x ;test result
> trap_ne
2e61 : d0fe > bne * ;failed not equal (non zero)
>
2e63 : 68 > pla ;load status
> eor_flag 0
2e64 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2e66 : dd4502 > cmp fINC,x ;test flags
> trap_ne
2e69 : d0fe > bne * ;failed not equal (non zero)
>
2e6b : e8 inx
2e6c : e002 cpx #2
2e6e : d004 bne tinc1
2e70 : a9fe lda #$fe
2e72 : 8502 sta zpt
2e74 : e005 tinc1 cpx #5
2e76 : d0dd bne tinc
2e78 : ca dex
2e79 : e602 inc zpt
2e7b : tdec
set_stat 0
> load_flag 0
2e7b : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2e7d : 48 > pha ;use stack to load status
2e7e : 28 > plp
2e7f : c602 dec zpt
tst_z rINC,fINC,0
2e81 : 08 > php ;save flags
2e82 : a502 > lda zpt
2e84 : dd4002 > cmp rINC,x ;test result
> trap_ne
2e87 : d0fe > bne * ;failed not equal (non zero)
>
2e89 : 68 > pla ;load status
> eor_flag 0
2e8a : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2e8c : dd4502 > cmp fINC,x ;test flags
> trap_ne
2e8f : d0fe > bne * ;failed not equal (non zero)
>
2e91 : ca dex
2e92 : 300a bmi tdec1
2e94 : e001 cpx #1
2e96 : d0e3 bne tdec
2e98 : a981 lda #$81
2e9a : 8502 sta zpt
2e9c : d0dd bne tdec
2e9e : tdec1
2e9e : a200 ldx #0
2ea0 : a97e lda #$7e
2ea2 : 8502 sta zpt
2ea4 : tinc10
set_stat $ff
> load_flag $ff
2ea4 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2ea6 : 48 > pha ;use stack to load status
2ea7 : 28 > plp
2ea8 : e602 inc zpt
tst_z rINC,fINC,$ff-fnz
2eaa : 08 > php ;save flags
2eab : a502 > lda zpt
2ead : dd4002 > cmp rINC,x ;test result
> trap_ne
2eb0 : d0fe > bne * ;failed not equal (non zero)
>
2eb2 : 68 > pla ;load status
> eor_flag $ff-fnz
2eb3 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
2eb5 : dd4502 > cmp fINC,x ;test flags
> trap_ne
2eb8 : d0fe > bne * ;failed not equal (non zero)
>
2eba : e8 inx
2ebb : e002 cpx #2
2ebd : d004 bne tinc11
2ebf : a9fe lda #$fe
2ec1 : 8502 sta zpt
2ec3 : e005 tinc11 cpx #5
2ec5 : d0dd bne tinc10
2ec7 : ca dex
2ec8 : e602 inc zpt
2eca : tdec10
set_stat $ff
> load_flag $ff
2eca : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2ecc : 48 > pha ;use stack to load status
2ecd : 28 > plp
2ece : c602 dec zpt
tst_z rINC,fINC,$ff-fnz
2ed0 : 08 > php ;save flags
2ed1 : a502 > lda zpt
2ed3 : dd4002 > cmp rINC,x ;test result
> trap_ne
2ed6 : d0fe > bne * ;failed not equal (non zero)
>
2ed8 : 68 > pla ;load status
> eor_flag $ff-fnz
2ed9 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
2edb : dd4502 > cmp fINC,x ;test flags
> trap_ne
2ede : d0fe > bne * ;failed not equal (non zero)
>
2ee0 : ca dex
2ee1 : 300a bmi tdec11
2ee3 : e001 cpx #1
2ee5 : d0e3 bne tdec10
2ee7 : a981 lda #$81
2ee9 : 8502 sta zpt
2eeb : d0dd bne tdec10
2eed : tdec11
next_test
2eed : ad0002 > lda test_case ;previous test
2ef0 : c922 > cmp #test_num
> trap_ne ;test is out of sequence
2ef2 : d0fe > bne * ;failed not equal (non zero)
>
0023 = >test_num = test_num + 1
2ef4 : a923 > lda #test_num ;*** next tests' number
2ef6 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; absolute memory
2ef9 : a200 ldx #0
2efb : a97e lda #$7e
2efd : 8d0302 sta abst
2f00 : tinc2
set_stat 0
> load_flag 0
2f00 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2f02 : 48 > pha ;use stack to load status
2f03 : 28 > plp
2f04 : ee0302 inc abst
tst_abs rINC,fINC,0
2f07 : 08 > php ;save flags
2f08 : ad0302 > lda abst
2f0b : dd4002 > cmp rINC,x ;test result
> trap_ne
2f0e : d0fe > bne * ;failed not equal (non zero)
>
2f10 : 68 > pla ;load status
> eor_flag 0
2f11 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2f13 : dd4502 > cmp fINC,x ;test flags
> trap_ne
2f16 : d0fe > bne * ;failed not equal (non zero)
>
2f18 : e8 inx
2f19 : e002 cpx #2
2f1b : d005 bne tinc3
2f1d : a9fe lda #$fe
2f1f : 8d0302 sta abst
2f22 : e005 tinc3 cpx #5
2f24 : d0da bne tinc2
2f26 : ca dex
2f27 : ee0302 inc abst
2f2a : tdec2
set_stat 0
> load_flag 0
2f2a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2f2c : 48 > pha ;use stack to load status
2f2d : 28 > plp
2f2e : ce0302 dec abst
tst_abs rINC,fINC,0
2f31 : 08 > php ;save flags
2f32 : ad0302 > lda abst
2f35 : dd4002 > cmp rINC,x ;test result
> trap_ne
2f38 : d0fe > bne * ;failed not equal (non zero)
>
2f3a : 68 > pla ;load status
> eor_flag 0
2f3b : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2f3d : dd4502 > cmp fINC,x ;test flags
> trap_ne
2f40 : d0fe > bne * ;failed not equal (non zero)
>
2f42 : ca dex
2f43 : 300b bmi tdec3
2f45 : e001 cpx #1
2f47 : d0e1 bne tdec2
2f49 : a981 lda #$81
2f4b : 8d0302 sta abst
2f4e : d0da bne tdec2
2f50 : tdec3
2f50 : a200 ldx #0
2f52 : a97e lda #$7e
2f54 : 8d0302 sta abst
2f57 : tinc12
set_stat $ff
> load_flag $ff
2f57 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2f59 : 48 > pha ;use stack to load status
2f5a : 28 > plp
2f5b : ee0302 inc abst
tst_abs rINC,fINC,$ff-fnz
2f5e : 08 > php ;save flags
2f5f : ad0302 > lda abst
2f62 : dd4002 > cmp rINC,x ;test result
> trap_ne
2f65 : d0fe > bne * ;failed not equal (non zero)
>
2f67 : 68 > pla ;load status
> eor_flag $ff-fnz
2f68 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
2f6a : dd4502 > cmp fINC,x ;test flags
> trap_ne
2f6d : d0fe > bne * ;failed not equal (non zero)
>
2f6f : e8 inx
2f70 : e002 cpx #2
2f72 : d005 bne tinc13
2f74 : a9fe lda #$fe
2f76 : 8d0302 sta abst
2f79 : e005 tinc13 cpx #5
2f7b : d0da bne tinc12
2f7d : ca dex
2f7e : ee0302 inc abst
2f81 : tdec12
set_stat $ff
> load_flag $ff
2f81 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2f83 : 48 > pha ;use stack to load status
2f84 : 28 > plp
2f85 : ce0302 dec abst
tst_abs rINC,fINC,$ff-fnz
2f88 : 08 > php ;save flags
2f89 : ad0302 > lda abst
2f8c : dd4002 > cmp rINC,x ;test result
> trap_ne
2f8f : d0fe > bne * ;failed not equal (non zero)
>
2f91 : 68 > pla ;load status
> eor_flag $ff-fnz
2f92 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
2f94 : dd4502 > cmp fINC,x ;test flags
> trap_ne
2f97 : d0fe > bne * ;failed not equal (non zero)
>
2f99 : ca dex
2f9a : 300b bmi tdec13
2f9c : e001 cpx #1
2f9e : d0e1 bne tdec12
2fa0 : a981 lda #$81
2fa2 : 8d0302 sta abst
2fa5 : d0da bne tdec12
2fa7 : tdec13
next_test
2fa7 : ad0002 > lda test_case ;previous test
2faa : c923 > cmp #test_num
> trap_ne ;test is out of sequence
2fac : d0fe > bne * ;failed not equal (non zero)
>
0024 = >test_num = test_num + 1
2fae : a924 > lda #test_num ;*** next tests' number
2fb0 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; zeropage indexed
2fb3 : a200 ldx #0
2fb5 : a97e lda #$7e
2fb7 : 9502 tinc4 sta zpt,x
set_stat 0
> load_flag 0
2fb9 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2fbb : 48 > pha ;use stack to load status
2fbc : 28 > plp
2fbd : f602 inc zpt,x
tst_zx rINC,fINC,0
2fbf : 08 > php ;save flags
2fc0 : b502 > lda zpt,x
2fc2 : dd4002 > cmp rINC,x ;test result
> trap_ne
2fc5 : d0fe > bne * ;failed not equal (non zero)
>
2fc7 : 68 > pla ;load status
> eor_flag 0
2fc8 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2fca : dd4502 > cmp fINC,x ;test flags
> trap_ne
2fcd : d0fe > bne * ;failed not equal (non zero)
>
2fcf : b502 lda zpt,x
2fd1 : e8 inx
2fd2 : e002 cpx #2
2fd4 : d002 bne tinc5
2fd6 : a9fe lda #$fe
2fd8 : e005 tinc5 cpx #5
2fda : d0db bne tinc4
2fdc : ca dex
2fdd : a902 lda #2
2fdf : 9502 tdec4 sta zpt,x
set_stat 0
> load_flag 0
2fe1 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2fe3 : 48 > pha ;use stack to load status
2fe4 : 28 > plp
2fe5 : d602 dec zpt,x
tst_zx rINC,fINC,0
2fe7 : 08 > php ;save flags
2fe8 : b502 > lda zpt,x
2fea : dd4002 > cmp rINC,x ;test result
> trap_ne
2fed : d0fe > bne * ;failed not equal (non zero)
>
2fef : 68 > pla ;load status
> eor_flag 0
2ff0 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2ff2 : dd4502 > cmp fINC,x ;test flags
> trap_ne
2ff5 : d0fe > bne * ;failed not equal (non zero)
>
2ff7 : b502 lda zpt,x
2ff9 : ca dex
2ffa : 3008 bmi tdec5
2ffc : e001 cpx #1
2ffe : d0df bne tdec4
3000 : a981 lda #$81
3002 : d0db bne tdec4
3004 : tdec5
3004 : a200 ldx #0
3006 : a97e lda #$7e
3008 : 9502 tinc14 sta zpt,x
set_stat $ff
> load_flag $ff
300a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
300c : 48 > pha ;use stack to load status
300d : 28 > plp
300e : f602 inc zpt,x
tst_zx rINC,fINC,$ff-fnz
3010 : 08 > php ;save flags
3011 : b502 > lda zpt,x
3013 : dd4002 > cmp rINC,x ;test result
> trap_ne
3016 : d0fe > bne * ;failed not equal (non zero)
>
3018 : 68 > pla ;load status
> eor_flag $ff-fnz
3019 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
301b : dd4502 > cmp fINC,x ;test flags
> trap_ne
301e : d0fe > bne * ;failed not equal (non zero)
>
3020 : b502 lda zpt,x
3022 : e8 inx
3023 : e002 cpx #2
3025 : d002 bne tinc15
3027 : a9fe lda #$fe
3029 : e005 tinc15 cpx #5
302b : d0db bne tinc14
302d : ca dex
302e : a902 lda #2
3030 : 9502 tdec14 sta zpt,x
set_stat $ff
> load_flag $ff
3032 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
3034 : 48 > pha ;use stack to load status
3035 : 28 > plp
3036 : d602 dec zpt,x
tst_zx rINC,fINC,$ff-fnz
3038 : 08 > php ;save flags
3039 : b502 > lda zpt,x
303b : dd4002 > cmp rINC,x ;test result
> trap_ne
303e : d0fe > bne * ;failed not equal (non zero)
>
3040 : 68 > pla ;load status
> eor_flag $ff-fnz
3041 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
3043 : dd4502 > cmp fINC,x ;test flags
> trap_ne
3046 : d0fe > bne * ;failed not equal (non zero)
>
3048 : b502 lda zpt,x
304a : ca dex
304b : 3008 bmi tdec15
304d : e001 cpx #1
304f : d0df bne tdec14
3051 : a981 lda #$81
3053 : d0db bne tdec14
3055 : tdec15
next_test
3055 : ad0002 > lda test_case ;previous test
3058 : c924 > cmp #test_num
> trap_ne ;test is out of sequence
305a : d0fe > bne * ;failed not equal (non zero)
>
0025 = >test_num = test_num + 1
305c : a925 > lda #test_num ;*** next tests' number
305e : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; memory indexed
3061 : a200 ldx #0
3063 : a97e lda #$7e
3065 : 9d0302 tinc6 sta abst,x
set_stat 0
> load_flag 0
3068 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
306a : 48 > pha ;use stack to load status
306b : 28 > plp
306c : fe0302 inc abst,x
tst_absx rINC,fINC,0
306f : 08 > php ;save flags
3070 : bd0302 > lda abst,x
3073 : dd4002 > cmp rINC,x ;test result
> trap_ne
3076 : d0fe > bne * ;failed not equal (non zero)
>
3078 : 68 > pla ;load status
> eor_flag 0
3079 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
307b : dd4502 > cmp fINC,x ;test flags
> trap_ne
307e : d0fe > bne * ;failed not equal (non zero)
>
3080 : bd0302 lda abst,x
3083 : e8 inx
3084 : e002 cpx #2
3086 : d002 bne tinc7
3088 : a9fe lda #$fe
308a : e005 tinc7 cpx #5
308c : d0d7 bne tinc6
308e : ca dex
308f : a902 lda #2
3091 : 9d0302 tdec6 sta abst,x
set_stat 0
> load_flag 0
3094 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
3096 : 48 > pha ;use stack to load status
3097 : 28 > plp
3098 : de0302 dec abst,x
tst_absx rINC,fINC,0
309b : 08 > php ;save flags
309c : bd0302 > lda abst,x
309f : dd4002 > cmp rINC,x ;test result
> trap_ne
30a2 : d0fe > bne * ;failed not equal (non zero)
>
30a4 : 68 > pla ;load status
> eor_flag 0
30a5 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
30a7 : dd4502 > cmp fINC,x ;test flags
> trap_ne
30aa : d0fe > bne * ;failed not equal (non zero)
>
30ac : bd0302 lda abst,x
30af : ca dex
30b0 : 3008 bmi tdec7
30b2 : e001 cpx #1
30b4 : d0db bne tdec6
30b6 : a981 lda #$81
30b8 : d0d7 bne tdec6
30ba : tdec7
30ba : a200 ldx #0
30bc : a97e lda #$7e
30be : 9d0302 tinc16 sta abst,x
set_stat $ff
> load_flag $ff
30c1 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
30c3 : 48 > pha ;use stack to load status
30c4 : 28 > plp
30c5 : fe0302 inc abst,x
tst_absx rINC,fINC,$ff-fnz
30c8 : 08 > php ;save flags
30c9 : bd0302 > lda abst,x
30cc : dd4002 > cmp rINC,x ;test result
> trap_ne
30cf : d0fe > bne * ;failed not equal (non zero)
>
30d1 : 68 > pla ;load status
> eor_flag $ff-fnz
30d2 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
30d4 : dd4502 > cmp fINC,x ;test flags
> trap_ne
30d7 : d0fe > bne * ;failed not equal (non zero)
>
30d9 : bd0302 lda abst,x
30dc : e8 inx
30dd : e002 cpx #2
30df : d002 bne tinc17
30e1 : a9fe lda #$fe
30e3 : e005 tinc17 cpx #5
30e5 : d0d7 bne tinc16
30e7 : ca dex
30e8 : a902 lda #2
30ea : 9d0302 tdec16 sta abst,x
set_stat $ff
> load_flag $ff
30ed : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
30ef : 48 > pha ;use stack to load status
30f0 : 28 > plp
30f1 : de0302 dec abst,x
tst_absx rINC,fINC,$ff-fnz
30f4 : 08 > php ;save flags
30f5 : bd0302 > lda abst,x
30f8 : dd4002 > cmp rINC,x ;test result
> trap_ne
30fb : d0fe > bne * ;failed not equal (non zero)
>
30fd : 68 > pla ;load status
> eor_flag $ff-fnz
30fe : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
3100 : dd4502 > cmp fINC,x ;test flags
> trap_ne
3103 : d0fe > bne * ;failed not equal (non zero)
>
3105 : bd0302 lda abst,x
3108 : ca dex
3109 : 3008 bmi tdec17
310b : e001 cpx #1
310d : d0db bne tdec16
310f : a981 lda #$81
3111 : d0d7 bne tdec16
3113 : tdec17
next_test
3113 : ad0002 > lda test_case ;previous test
3116 : c925 > cmp #test_num
> trap_ne ;test is out of sequence
3118 : d0fe > bne * ;failed not equal (non zero)
>
0026 = >test_num = test_num + 1
311a : a926 > lda #test_num ;*** next tests' number
311c : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; testing logical instructions - AND EOR ORA all addressing modes
; AND
311f : a203 ldx #3 ;immediate
3121 : b512 tand lda zpAN,x
3123 : 8d0902 sta ex_andi+1 ;set AND # operand
set_ax absANa,0
> load_flag 0
3126 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
3128 : 48 > pha ;use stack to load status
3129 : bd5a02 > lda absANa,x ;precharge accu
312c : 28 > plp
312d : 200802 jsr ex_andi ;execute AND # in RAM
tst_ax absrlo,absflo,0
3130 : 08 > php ;save flags
3131 : dd6202 > cmp absrlo,x ;test result
> trap_ne
3134 : d0fe > bne * ;failed not equal (non zero)
>
3136 : 68 > pla ;load status
> eor_flag 0
3137 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
3139 : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
313c : d0fe > bne * ;failed not equal (non zero)
>
313e : ca dex
313f : 10e0 bpl tand
3141 : a203 ldx #3
3143 : b512 tand1 lda zpAN,x
3145 : 8d0902 sta ex_andi+1 ;set AND # operand
set_ax absANa,$ff
> load_flag $ff
3148 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
314a : 48 > pha ;use stack to load status
314b : bd5a02 > lda absANa,x ;precharge accu
314e : 28 > plp
314f : 200802 jsr ex_andi ;execute AND # in RAM
tst_ax absrlo,absflo,$ff-fnz
3152 : 08 > php ;save flags
3153 : dd6202 > cmp absrlo,x ;test result
> trap_ne
3156 : d0fe > bne * ;failed not equal (non zero)
>
3158 : 68 > pla ;load status
> eor_flag $ff-fnz
3159 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
315b : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
315e : d0fe > bne * ;failed not equal (non zero)
>
3160 : ca dex
3161 : 10e0 bpl tand1
3163 : a203 ldx #3 ;zp
3165 : b512 tand2 lda zpAN,x
3167 : 8502 sta zpt
set_ax absANa,0
> load_flag 0
3169 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
316b : 48 > pha ;use stack to load status
316c : bd5a02 > lda absANa,x ;precharge accu
316f : 28 > plp
3170 : 2502 and zpt
tst_ax absrlo,absflo,0
3172 : 08 > php ;save flags
3173 : dd6202 > cmp absrlo,x ;test result
> trap_ne
3176 : d0fe > bne * ;failed not equal (non zero)
>
3178 : 68 > pla ;load status
> eor_flag 0
3179 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
317b : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
317e : d0fe > bne * ;failed not equal (non zero)
>
3180 : ca dex
3181 : 10e2 bpl tand2
3183 : a203 ldx #3
3185 : b512 tand3 lda zpAN,x
3187 : 8502 sta zpt
set_ax absANa,$ff
> load_flag $ff
3189 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
318b : 48 > pha ;use stack to load status
318c : bd5a02 > lda absANa,x ;precharge accu
318f : 28 > plp
3190 : 2502 and zpt
tst_ax absrlo,absflo,$ff-fnz
3192 : 08 > php ;save flags
3193 : dd6202 > cmp absrlo,x ;test result
> trap_ne
3196 : d0fe > bne * ;failed not equal (non zero)
>
3198 : 68 > pla ;load status
> eor_flag $ff-fnz
3199 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
319b : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
319e : d0fe > bne * ;failed not equal (non zero)
>
31a0 : ca dex
31a1 : 10e2 bpl tand3
31a3 : a203 ldx #3 ;abs
31a5 : b512 tand4 lda zpAN,x
31a7 : 8d0302 sta abst
set_ax absANa,0
> load_flag 0
31aa : a900 > lda #0 ;allow test to change I-flag (no mask)
>
31ac : 48 > pha ;use stack to load status
31ad : bd5a02 > lda absANa,x ;precharge accu
31b0 : 28 > plp
31b1 : 2d0302 and abst
tst_ax absrlo,absflo,0
31b4 : 08 > php ;save flags
31b5 : dd6202 > cmp absrlo,x ;test result
> trap_ne
31b8 : d0fe > bne * ;failed not equal (non zero)
>
31ba : 68 > pla ;load status
> eor_flag 0
31bb : 4930 > eor #0|fao ;invert expected flags + always on bits
>
31bd : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
31c0 : d0fe > bne * ;failed not equal (non zero)
>
31c2 : ca dex
31c3 : 10e0 bpl tand4
31c5 : a203 ldx #3
31c7 : b512 tand5 lda zpAN,x
31c9 : 8d0302 sta abst
set_ax absANa,$ff
> load_flag $ff
31cc : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
31ce : 48 > pha ;use stack to load status
31cf : bd5a02 > lda absANa,x ;precharge accu
31d2 : 28 > plp
31d3 : 2d0302 and abst
tst_ax absrlo,absflo,$ff-fnz
31d6 : 08 > php ;save flags
31d7 : dd6202 > cmp absrlo,x ;test result
> trap_ne
31da : d0fe > bne * ;failed not equal (non zero)
>
31dc : 68 > pla ;load status
> eor_flag $ff-fnz
31dd : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
31df : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
31e2 : d0fe > bne * ;failed not equal (non zero)
>
31e4 : ca dex
31e5 : 1002 bpl tand6
31e7 : a203 ldx #3 ;zp,x
31e9 : tand6
set_ax absANa,0
> load_flag 0
31e9 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
31eb : 48 > pha ;use stack to load status
31ec : bd5a02 > lda absANa,x ;precharge accu
31ef : 28 > plp
31f0 : 3512 and zpAN,x
tst_ax absrlo,absflo,0
31f2 : 08 > php ;save flags
31f3 : dd6202 > cmp absrlo,x ;test result
> trap_ne
31f6 : d0fe > bne * ;failed not equal (non zero)
>
31f8 : 68 > pla ;load status
> eor_flag 0
31f9 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
31fb : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
31fe : d0fe > bne * ;failed not equal (non zero)
>
3200 : ca dex
3201 : 10e6 bpl tand6
3203 : a203 ldx #3
3205 : tand7
set_ax absANa,$ff
> load_flag $ff
3205 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
3207 : 48 > pha ;use stack to load status
3208 : bd5a02 > lda absANa,x ;precharge accu
320b : 28 > plp
320c : 3512 and zpAN,x
tst_ax absrlo,absflo,$ff-fnz
320e : 08 > php ;save flags
320f : dd6202 > cmp absrlo,x ;test result
> trap_ne
3212 : d0fe > bne * ;failed not equal (non zero)
>
3214 : 68 > pla ;load status
> eor_flag $ff-fnz
3215 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
3217 : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
321a : d0fe > bne * ;failed not equal (non zero)
>
321c : ca dex
321d : 10e6 bpl tand7
321f : a203 ldx #3 ;abs,x
3221 : tand8
set_ax absANa,0
> load_flag 0
3221 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
3223 : 48 > pha ;use stack to load status
3224 : bd5a02 > lda absANa,x ;precharge accu
3227 : 28 > plp
3228 : 3d4e02 and absAN,x
tst_ax absrlo,absflo,0
322b : 08 > php ;save flags
322c : dd6202 > cmp absrlo,x ;test result
> trap_ne
322f : d0fe > bne * ;failed not equal (non zero)
>
3231 : 68 > pla ;load status
> eor_flag 0
3232 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
3234 : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
3237 : d0fe > bne * ;failed not equal (non zero)
>
3239 : ca dex
323a : 10e5 bpl tand8
323c : a203 ldx #3
323e : tand9
set_ax absANa,$ff
> load_flag $ff
323e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
3240 : 48 > pha ;use stack to load status
3241 : bd5a02 > lda absANa,x ;precharge accu
3244 : 28 > plp
3245 : 3d4e02 and absAN,x
tst_ax absrlo,absflo,$ff-fnz
3248 : 08 > php ;save flags
3249 : dd6202 > cmp absrlo,x ;test result
> trap_ne
324c : d0fe > bne * ;failed not equal (non zero)
>
324e : 68 > pla ;load status
> eor_flag $ff-fnz
324f : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
3251 : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
3254 : d0fe > bne * ;failed not equal (non zero)
>
3256 : ca dex
3257 : 10e5 bpl tand9
3259 : a003 ldy #3 ;abs,y
325b : tand10
set_ay absANa,0
> load_flag 0
325b : a900 > lda #0 ;allow test to change I-flag (no mask)
>
325d : 48 > pha ;use stack to load status
325e : b95a02 > lda absANa,y ;precharge accu
3261 : 28 > plp
3262 : 394e02 and absAN,y
tst_ay absrlo,absflo,0
3265 : 08 > php ;save flags
3266 : d96202 > cmp absrlo,y ;test result
> trap_ne ;
3269 : d0fe > bne * ;failed not equal (non zero)
>
326b : 68 > pla ;load status
> eor_flag 0
326c : 4930 > eor #0|fao ;invert expected flags + always on bits
>
326e : d96602 > cmp absflo,y ;test flags
> trap_ne
3271 : d0fe > bne * ;failed not equal (non zero)
>
3273 : 88 dey
3274 : 10e5 bpl tand10
3276 : a003 ldy #3
3278 : tand11
set_ay absANa,$ff
> load_flag $ff
3278 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
327a : 48 > pha ;use stack to load status
327b : b95a02 > lda absANa,y ;precharge accu
327e : 28 > plp
327f : 394e02 and absAN,y
tst_ay absrlo,absflo,$ff-fnz
3282 : 08 > php ;save flags
3283 : d96202 > cmp absrlo,y ;test result
> trap_ne ;
3286 : d0fe > bne * ;failed not equal (non zero)
>
3288 : 68 > pla ;load status
> eor_flag $ff-fnz
3289 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
328b : d96602 > cmp absflo,y ;test flags
> trap_ne
328e : d0fe > bne * ;failed not equal (non zero)
>
3290 : 88 dey
3291 : 10e5 bpl tand11
3293 : a206 ldx #6 ;(zp,x)
3295 : a003 ldy #3
3297 : tand12
set_ay absANa,0
> load_flag 0
3297 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
3299 : 48 > pha ;use stack to load status
329a : b95a02 > lda absANa,y ;precharge accu
329d : 28 > plp
329e : 2130 and (indAN,x)
tst_ay absrlo,absflo,0
32a0 : 08 > php ;save flags
32a1 : d96202 > cmp absrlo,y ;test result
> trap_ne ;
32a4 : d0fe > bne * ;failed not equal (non zero)
>
32a6 : 68 > pla ;load status
> eor_flag 0
32a7 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
32a9 : d96602 > cmp absflo,y ;test flags
> trap_ne
32ac : d0fe > bne * ;failed not equal (non zero)
>
32ae : ca dex
32af : ca dex
32b0 : 88 dey
32b1 : 10e4 bpl tand12
32b3 : a206 ldx #6
32b5 : a003 ldy #3
32b7 : tand13
set_ay absANa,$ff
> load_flag $ff
32b7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
32b9 : 48 > pha ;use stack to load status
32ba : b95a02 > lda absANa,y ;precharge accu
32bd : 28 > plp
32be : 2130 and (indAN,x)
tst_ay absrlo,absflo,$ff-fnz
32c0 : 08 > php ;save flags
32c1 : d96202 > cmp absrlo,y ;test result
> trap_ne ;
32c4 : d0fe > bne * ;failed not equal (non zero)
>
32c6 : 68 > pla ;load status
> eor_flag $ff-fnz
32c7 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
32c9 : d96602 > cmp absflo,y ;test flags
> trap_ne
32cc : d0fe > bne * ;failed not equal (non zero)
>
32ce : ca dex
32cf : ca dex
32d0 : 88 dey
32d1 : 10e4 bpl tand13
32d3 : a003 ldy #3 ;(zp),y
32d5 : tand14
set_ay absANa,0
> load_flag 0
32d5 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
32d7 : 48 > pha ;use stack to load status
32d8 : b95a02 > lda absANa,y ;precharge accu
32db : 28 > plp
32dc : 3130 and (indAN),y
tst_ay absrlo,absflo,0
32de : 08 > php ;save flags
32df : d96202 > cmp absrlo,y ;test result
> trap_ne ;
32e2 : d0fe > bne * ;failed not equal (non zero)
>
32e4 : 68 > pla ;load status
> eor_flag 0
32e5 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
32e7 : d96602 > cmp absflo,y ;test flags
> trap_ne
32ea : d0fe > bne * ;failed not equal (non zero)
>
32ec : 88 dey
32ed : 10e6 bpl tand14
32ef : a003 ldy #3
32f1 : tand15
set_ay absANa,$ff
> load_flag $ff
32f1 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
32f3 : 48 > pha ;use stack to load status
32f4 : b95a02 > lda absANa,y ;precharge accu
32f7 : 28 > plp
32f8 : 3130 and (indAN),y
tst_ay absrlo,absflo,$ff-fnz
32fa : 08 > php ;save flags
32fb : d96202 > cmp absrlo,y ;test result
> trap_ne ;
32fe : d0fe > bne * ;failed not equal (non zero)
>
3300 : 68 > pla ;load status
> eor_flag $ff-fnz
3301 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
3303 : d96602 > cmp absflo,y ;test flags
> trap_ne
3306 : d0fe > bne * ;failed not equal (non zero)
>
3308 : 88 dey
3309 : 10e6 bpl tand15
next_test
330b : ad0002 > lda test_case ;previous test
330e : c926 > cmp #test_num
> trap_ne ;test is out of sequence
3310 : d0fe > bne * ;failed not equal (non zero)
>
0027 = >test_num = test_num + 1
3312 : a927 > lda #test_num ;*** next tests' number
3314 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; EOR
3317 : a203 ldx #3 ;immediate - self modifying code
3319 : b516 teor lda zpEO,x
331b : 8d0c02 sta ex_eori+1 ;set EOR # operand
set_ax absEOa,0
> load_flag 0
331e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
3320 : 48 > pha ;use stack to load status
3321 : bd5e02 > lda absEOa,x ;precharge accu
3324 : 28 > plp
3325 : 200b02 jsr ex_eori ;execute EOR # in RAM
tst_ax absrlo,absflo,0
3328 : 08 > php ;save flags
3329 : dd6202 > cmp absrlo,x ;test result
> trap_ne
332c : d0fe > bne * ;failed not equal (non zero)
>
332e : 68 > pla ;load status
> eor_flag 0
332f : 4930 > eor #0|fao ;invert expected flags + always on bits
>
3331 : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
3334 : d0fe > bne * ;failed not equal (non zero)
>
3336 : ca dex
3337 : 10e0 bpl teor
3339 : a203 ldx #3
333b : b516 teor1 lda zpEO,x
333d : 8d0c02 sta ex_eori+1 ;set EOR # operand
set_ax absEOa,$ff
> load_flag $ff
3340 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
3342 : 48 > pha ;use stack to load status
3343 : bd5e02 > lda absEOa,x ;precharge accu
3346 : 28 > plp
3347 : 200b02 jsr ex_eori ;execute EOR # in RAM
tst_ax absrlo,absflo,$ff-fnz
334a : 08 > php ;save flags
334b : dd6202 > cmp absrlo,x ;test result
> trap_ne
334e : d0fe > bne * ;failed not equal (non zero)
>
3350 : 68 > pla ;load status
> eor_flag $ff-fnz
3351 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
3353 : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
3356 : d0fe > bne * ;failed not equal (non zero)
>
3358 : ca dex
3359 : 10e0 bpl teor1
335b : a203 ldx #3 ;zp
335d : b516 teor2 lda zpEO,x
335f : 8502 sta zpt
set_ax absEOa,0
> load_flag 0
3361 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
3363 : 48 > pha ;use stack to load status
3364 : bd5e02 > lda absEOa,x ;precharge accu
3367 : 28 > plp
3368 : 4502 eor zpt
tst_ax absrlo,absflo,0
336a : 08 > php ;save flags
336b : dd6202 > cmp absrlo,x ;test result
> trap_ne
336e : d0fe > bne * ;failed not equal (non zero)
>
3370 : 68 > pla ;load status
> eor_flag 0
3371 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
3373 : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
3376 : d0fe > bne * ;failed not equal (non zero)
>
3378 : ca dex
3379 : 10e2 bpl teor2
337b : a203 ldx #3
337d : b516 teor3 lda zpEO,x
337f : 8502 sta zpt
set_ax absEOa,$ff
> load_flag $ff
3381 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
3383 : 48 > pha ;use stack to load status
3384 : bd5e02 > lda absEOa,x ;precharge accu
3387 : 28 > plp
3388 : 4502 eor zpt
tst_ax absrlo,absflo,$ff-fnz
338a : 08 > php ;save flags
338b : dd6202 > cmp absrlo,x ;test result
> trap_ne
338e : d0fe > bne * ;failed not equal (non zero)
>
3390 : 68 > pla ;load status
> eor_flag $ff-fnz
3391 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
3393 : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
3396 : d0fe > bne * ;failed not equal (non zero)
>
3398 : ca dex
3399 : 10e2 bpl teor3
339b : a203 ldx #3 ;abs
339d : b516 teor4 lda zpEO,x
339f : 8d0302 sta abst
set_ax absEOa,0
> load_flag 0
33a2 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
33a4 : 48 > pha ;use stack to load status
33a5 : bd5e02 > lda absEOa,x ;precharge accu
33a8 : 28 > plp
33a9 : 4d0302 eor abst
tst_ax absrlo,absflo,0
33ac : 08 > php ;save flags
33ad : dd6202 > cmp absrlo,x ;test result
> trap_ne
33b0 : d0fe > bne * ;failed not equal (non zero)
>
33b2 : 68 > pla ;load status
> eor_flag 0
33b3 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
33b5 : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
33b8 : d0fe > bne * ;failed not equal (non zero)
>
33ba : ca dex
33bb : 10e0 bpl teor4
33bd : a203 ldx #3
33bf : b516 teor5 lda zpEO,x
33c1 : 8d0302 sta abst
set_ax absEOa,$ff
> load_flag $ff
33c4 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
33c6 : 48 > pha ;use stack to load status
33c7 : bd5e02 > lda absEOa,x ;precharge accu
33ca : 28 > plp
33cb : 4d0302 eor abst
tst_ax absrlo,absflo,$ff-fnz
33ce : 08 > php ;save flags
33cf : dd6202 > cmp absrlo,x ;test result
> trap_ne
33d2 : d0fe > bne * ;failed not equal (non zero)
>
33d4 : 68 > pla ;load status
> eor_flag $ff-fnz
33d5 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
33d7 : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
33da : d0fe > bne * ;failed not equal (non zero)
>
33dc : ca dex
33dd : 1002 bpl teor6
33df : a203 ldx #3 ;zp,x
33e1 : teor6
set_ax absEOa,0
> load_flag 0
33e1 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
33e3 : 48 > pha ;use stack to load status
33e4 : bd5e02 > lda absEOa,x ;precharge accu
33e7 : 28 > plp
33e8 : 5516 eor zpEO,x
tst_ax absrlo,absflo,0
33ea : 08 > php ;save flags
33eb : dd6202 > cmp absrlo,x ;test result
> trap_ne
33ee : d0fe > bne * ;failed not equal (non zero)
>
33f0 : 68 > pla ;load status
> eor_flag 0
33f1 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
33f3 : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
33f6 : d0fe > bne * ;failed not equal (non zero)
>
33f8 : ca dex
33f9 : 10e6 bpl teor6
33fb : a203 ldx #3
33fd : teor7
set_ax absEOa,$ff
> load_flag $ff
33fd : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
33ff : 48 > pha ;use stack to load status
3400 : bd5e02 > lda absEOa,x ;precharge accu
3403 : 28 > plp
3404 : 5516 eor zpEO,x
tst_ax absrlo,absflo,$ff-fnz
3406 : 08 > php ;save flags
3407 : dd6202 > cmp absrlo,x ;test result
> trap_ne
340a : d0fe > bne * ;failed not equal (non zero)
>
340c : 68 > pla ;load status
> eor_flag $ff-fnz
340d : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
340f : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
3412 : d0fe > bne * ;failed not equal (non zero)
>
3414 : ca dex
3415 : 10e6 bpl teor7
3417 : a203 ldx #3 ;abs,x
3419 : teor8
set_ax absEOa,0
> load_flag 0
3419 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
341b : 48 > pha ;use stack to load status
341c : bd5e02 > lda absEOa,x ;precharge accu
341f : 28 > plp
3420 : 5d5202 eor absEO,x
tst_ax absrlo,absflo,0
3423 : 08 > php ;save flags
3424 : dd6202 > cmp absrlo,x ;test result
> trap_ne
3427 : d0fe > bne * ;failed not equal (non zero)
>
3429 : 68 > pla ;load status
> eor_flag 0
342a : 4930 > eor #0|fao ;invert expected flags + always on bits
>
342c : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
342f : d0fe > bne * ;failed not equal (non zero)
>
3431 : ca dex
3432 : 10e5 bpl teor8
3434 : a203 ldx #3
3436 : teor9
set_ax absEOa,$ff
> load_flag $ff
3436 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
3438 : 48 > pha ;use stack to load status
3439 : bd5e02 > lda absEOa,x ;precharge accu
343c : 28 > plp
343d : 5d5202 eor absEO,x
tst_ax absrlo,absflo,$ff-fnz
3440 : 08 > php ;save flags
3441 : dd6202 > cmp absrlo,x ;test result
> trap_ne
3444 : d0fe > bne * ;failed not equal (non zero)
>
3446 : 68 > pla ;load status
> eor_flag $ff-fnz
3447 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
3449 : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
344c : d0fe > bne * ;failed not equal (non zero)
>
344e : ca dex
344f : 10e5 bpl teor9
3451 : a003 ldy #3 ;abs,y
3453 : teor10
set_ay absEOa,0
> load_flag 0
3453 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
3455 : 48 > pha ;use stack to load status
3456 : b95e02 > lda absEOa,y ;precharge accu
3459 : 28 > plp
345a : 595202 eor absEO,y
tst_ay absrlo,absflo,0
345d : 08 > php ;save flags
345e : d96202 > cmp absrlo,y ;test result
> trap_ne ;
3461 : d0fe > bne * ;failed not equal (non zero)
>
3463 : 68 > pla ;load status
> eor_flag 0
3464 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
3466 : d96602 > cmp absflo,y ;test flags
> trap_ne
3469 : d0fe > bne * ;failed not equal (non zero)
>
346b : 88 dey
346c : 10e5 bpl teor10
346e : a003 ldy #3
3470 : teor11
set_ay absEOa,$ff
> load_flag $ff
3470 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
3472 : 48 > pha ;use stack to load status
3473 : b95e02 > lda absEOa,y ;precharge accu
3476 : 28 > plp
3477 : 595202 eor absEO,y
tst_ay absrlo,absflo,$ff-fnz
347a : 08 > php ;save flags
347b : d96202 > cmp absrlo,y ;test result
> trap_ne ;
347e : d0fe > bne * ;failed not equal (non zero)
>
3480 : 68 > pla ;load status
> eor_flag $ff-fnz
3481 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
3483 : d96602 > cmp absflo,y ;test flags
> trap_ne
3486 : d0fe > bne * ;failed not equal (non zero)
>
3488 : 88 dey
3489 : 10e5 bpl teor11
348b : a206 ldx #6 ;(zp,x)
348d : a003 ldy #3
348f : teor12
set_ay absEOa,0
> load_flag 0
348f : a900 > lda #0 ;allow test to change I-flag (no mask)
>
3491 : 48 > pha ;use stack to load status
3492 : b95e02 > lda absEOa,y ;precharge accu
3495 : 28 > plp
3496 : 4138 eor (indEO,x)
tst_ay absrlo,absflo,0
3498 : 08 > php ;save flags
3499 : d96202 > cmp absrlo,y ;test result
> trap_ne ;
349c : d0fe > bne * ;failed not equal (non zero)
>
349e : 68 > pla ;load status
> eor_flag 0
349f : 4930 > eor #0|fao ;invert expected flags + always on bits
>
34a1 : d96602 > cmp absflo,y ;test flags
> trap_ne
34a4 : d0fe > bne * ;failed not equal (non zero)
>
34a6 : ca dex
34a7 : ca dex
34a8 : 88 dey
34a9 : 10e4 bpl teor12
34ab : a206 ldx #6
34ad : a003 ldy #3
34af : teor13
set_ay absEOa,$ff
> load_flag $ff
34af : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
34b1 : 48 > pha ;use stack to load status
34b2 : b95e02 > lda absEOa,y ;precharge accu
34b5 : 28 > plp
34b6 : 4138 eor (indEO,x)
tst_ay absrlo,absflo,$ff-fnz
34b8 : 08 > php ;save flags
34b9 : d96202 > cmp absrlo,y ;test result
> trap_ne ;
34bc : d0fe > bne * ;failed not equal (non zero)
>
34be : 68 > pla ;load status
> eor_flag $ff-fnz
34bf : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
34c1 : d96602 > cmp absflo,y ;test flags
> trap_ne
34c4 : d0fe > bne * ;failed not equal (non zero)
>
34c6 : ca dex
34c7 : ca dex
34c8 : 88 dey
34c9 : 10e4 bpl teor13
34cb : a003 ldy #3 ;(zp),y
34cd : teor14
set_ay absEOa,0
> load_flag 0
34cd : a900 > lda #0 ;allow test to change I-flag (no mask)
>
34cf : 48 > pha ;use stack to load status
34d0 : b95e02 > lda absEOa,y ;precharge accu
34d3 : 28 > plp
34d4 : 5138 eor (indEO),y
tst_ay absrlo,absflo,0
34d6 : 08 > php ;save flags
34d7 : d96202 > cmp absrlo,y ;test result
> trap_ne ;
34da : d0fe > bne * ;failed not equal (non zero)
>
34dc : 68 > pla ;load status
> eor_flag 0
34dd : 4930 > eor #0|fao ;invert expected flags + always on bits
>
34df : d96602 > cmp absflo,y ;test flags
> trap_ne
34e2 : d0fe > bne * ;failed not equal (non zero)
>
34e4 : 88 dey
34e5 : 10e6 bpl teor14
34e7 : a003 ldy #3
34e9 : teor15
set_ay absEOa,$ff
> load_flag $ff
34e9 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
34eb : 48 > pha ;use stack to load status
34ec : b95e02 > lda absEOa,y ;precharge accu
34ef : 28 > plp
34f0 : 5138 eor (indEO),y
tst_ay absrlo,absflo,$ff-fnz
34f2 : 08 > php ;save flags
34f3 : d96202 > cmp absrlo,y ;test result
> trap_ne ;
34f6 : d0fe > bne * ;failed not equal (non zero)
>
34f8 : 68 > pla ;load status
> eor_flag $ff-fnz
34f9 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
34fb : d96602 > cmp absflo,y ;test flags
> trap_ne
34fe : d0fe > bne * ;failed not equal (non zero)
>
3500 : 88 dey
3501 : 10e6 bpl teor15
next_test
3503 : ad0002 > lda test_case ;previous test
3506 : c927 > cmp #test_num
> trap_ne ;test is out of sequence
3508 : d0fe > bne * ;failed not equal (non zero)
>
0028 = >test_num = test_num + 1
350a : a928 > lda #test_num ;*** next tests' number
350c : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; OR
350f : a203 ldx #3 ;immediate - self modifying code
3511 : b50e tora lda zpOR,x
3513 : 8d0f02 sta ex_orai+1 ;set ORA # operand
set_ax absORa,0
> load_flag 0
3516 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
3518 : 48 > pha ;use stack to load status
3519 : bd5602 > lda absORa,x ;precharge accu
351c : 28 > plp
351d : 200e02 jsr ex_orai ;execute ORA # in RAM
tst_ax absrlo,absflo,0
3520 : 08 > php ;save flags
3521 : dd6202 > cmp absrlo,x ;test result
> trap_ne
3524 : d0fe > bne * ;failed not equal (non zero)
>
3526 : 68 > pla ;load status
> eor_flag 0
3527 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
3529 : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
352c : d0fe > bne * ;failed not equal (non zero)
>
352e : ca dex
352f : 10e0 bpl tora
3531 : a203 ldx #3
3533 : b50e tora1 lda zpOR,x
3535 : 8d0f02 sta ex_orai+1 ;set ORA # operand
set_ax absORa,$ff
> load_flag $ff
3538 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
353a : 48 > pha ;use stack to load status
353b : bd5602 > lda absORa,x ;precharge accu
353e : 28 > plp
353f : 200e02 jsr ex_orai ;execute ORA # in RAM
tst_ax absrlo,absflo,$ff-fnz
3542 : 08 > php ;save flags
3543 : dd6202 > cmp absrlo,x ;test result
> trap_ne
3546 : d0fe > bne * ;failed not equal (non zero)
>
3548 : 68 > pla ;load status
> eor_flag $ff-fnz
3549 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
354b : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
354e : d0fe > bne * ;failed not equal (non zero)
>
3550 : ca dex
3551 : 10e0 bpl tora1
3553 : a203 ldx #3 ;zp
3555 : b50e tora2 lda zpOR,x
3557 : 8502 sta zpt
set_ax absORa,0
> load_flag 0
3559 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
355b : 48 > pha ;use stack to load status
355c : bd5602 > lda absORa,x ;precharge accu
355f : 28 > plp
3560 : 0502 ora zpt
tst_ax absrlo,absflo,0
3562 : 08 > php ;save flags
3563 : dd6202 > cmp absrlo,x ;test result
> trap_ne
3566 : d0fe > bne * ;failed not equal (non zero)
>
3568 : 68 > pla ;load status
> eor_flag 0
3569 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
356b : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
356e : d0fe > bne * ;failed not equal (non zero)
>
3570 : ca dex
3571 : 10e2 bpl tora2
3573 : a203 ldx #3
3575 : b50e tora3 lda zpOR,x
3577 : 8502 sta zpt
set_ax absORa,$ff
> load_flag $ff
3579 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
357b : 48 > pha ;use stack to load status
357c : bd5602 > lda absORa,x ;precharge accu
357f : 28 > plp
3580 : 0502 ora zpt
tst_ax absrlo,absflo,$ff-fnz
3582 : 08 > php ;save flags
3583 : dd6202 > cmp absrlo,x ;test result
> trap_ne
3586 : d0fe > bne * ;failed not equal (non zero)
>
3588 : 68 > pla ;load status
> eor_flag $ff-fnz
3589 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
358b : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
358e : d0fe > bne * ;failed not equal (non zero)
>
3590 : ca dex
3591 : 10e2 bpl tora3
3593 : a203 ldx #3 ;abs
3595 : b50e tora4 lda zpOR,x
3597 : 8d0302 sta abst
set_ax absORa,0
> load_flag 0
359a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
359c : 48 > pha ;use stack to load status
359d : bd5602 > lda absORa,x ;precharge accu
35a0 : 28 > plp
35a1 : 0d0302 ora abst
tst_ax absrlo,absflo,0
35a4 : 08 > php ;save flags
35a5 : dd6202 > cmp absrlo,x ;test result
> trap_ne
35a8 : d0fe > bne * ;failed not equal (non zero)
>
35aa : 68 > pla ;load status
> eor_flag 0
35ab : 4930 > eor #0|fao ;invert expected flags + always on bits
>
35ad : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
35b0 : d0fe > bne * ;failed not equal (non zero)
>
35b2 : ca dex
35b3 : 10e0 bpl tora4
35b5 : a203 ldx #3
35b7 : b50e tora5 lda zpOR,x
35b9 : 8d0302 sta abst
set_ax absORa,$ff
> load_flag $ff
35bc : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
35be : 48 > pha ;use stack to load status
35bf : bd5602 > lda absORa,x ;precharge accu
35c2 : 28 > plp
35c3 : 0d0302 ora abst
tst_ax absrlo,absflo,$ff-fnz
35c6 : 08 > php ;save flags
35c7 : dd6202 > cmp absrlo,x ;test result
> trap_ne
35ca : d0fe > bne * ;failed not equal (non zero)
>
35cc : 68 > pla ;load status
> eor_flag $ff-fnz
35cd : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
35cf : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
35d2 : d0fe > bne * ;failed not equal (non zero)
>
35d4 : ca dex
35d5 : 1002 bpl tora6
35d7 : a203 ldx #3 ;zp,x
35d9 : tora6
set_ax absORa,0
> load_flag 0
35d9 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
35db : 48 > pha ;use stack to load status
35dc : bd5602 > lda absORa,x ;precharge accu
35df : 28 > plp
35e0 : 150e ora zpOR,x
tst_ax absrlo,absflo,0
35e2 : 08 > php ;save flags
35e3 : dd6202 > cmp absrlo,x ;test result
> trap_ne
35e6 : d0fe > bne * ;failed not equal (non zero)
>
35e8 : 68 > pla ;load status
> eor_flag 0
35e9 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
35eb : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
35ee : d0fe > bne * ;failed not equal (non zero)
>
35f0 : ca dex
35f1 : 10e6 bpl tora6
35f3 : a203 ldx #3
35f5 : tora7
set_ax absORa,$ff
> load_flag $ff
35f5 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
35f7 : 48 > pha ;use stack to load status
35f8 : bd5602 > lda absORa,x ;precharge accu
35fb : 28 > plp
35fc : 150e ora zpOR,x
tst_ax absrlo,absflo,$ff-fnz
35fe : 08 > php ;save flags
35ff : dd6202 > cmp absrlo,x ;test result
> trap_ne
3602 : d0fe > bne * ;failed not equal (non zero)
>
3604 : 68 > pla ;load status
> eor_flag $ff-fnz
3605 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
3607 : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
360a : d0fe > bne * ;failed not equal (non zero)
>
360c : ca dex
360d : 10e6 bpl tora7
360f : a203 ldx #3 ;abs,x
3611 : tora8
set_ax absORa,0
> load_flag 0
3611 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
3613 : 48 > pha ;use stack to load status
3614 : bd5602 > lda absORa,x ;precharge accu
3617 : 28 > plp
3618 : 1d4a02 ora absOR,x
tst_ax absrlo,absflo,0
361b : 08 > php ;save flags
361c : dd6202 > cmp absrlo,x ;test result
> trap_ne
361f : d0fe > bne * ;failed not equal (non zero)
>
3621 : 68 > pla ;load status
> eor_flag 0
3622 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
3624 : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
3627 : d0fe > bne * ;failed not equal (non zero)
>
3629 : ca dex
362a : 10e5 bpl tora8
362c : a203 ldx #3
362e : tora9
set_ax absORa,$ff
> load_flag $ff
362e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
3630 : 48 > pha ;use stack to load status
3631 : bd5602 > lda absORa,x ;precharge accu
3634 : 28 > plp
3635 : 1d4a02 ora absOR,x
tst_ax absrlo,absflo,$ff-fnz
3638 : 08 > php ;save flags
3639 : dd6202 > cmp absrlo,x ;test result
> trap_ne
363c : d0fe > bne * ;failed not equal (non zero)
>
363e : 68 > pla ;load status
> eor_flag $ff-fnz
363f : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
3641 : dd6602 > cmp absflo,x ;test flags
> trap_ne ;
3644 : d0fe > bne * ;failed not equal (non zero)
>
3646 : ca dex
3647 : 10e5 bpl tora9
3649 : a003 ldy #3 ;abs,y
364b : tora10
set_ay absORa,0
> load_flag 0
364b : a900 > lda #0 ;allow test to change I-flag (no mask)
>
364d : 48 > pha ;use stack to load status
364e : b95602 > lda absORa,y ;precharge accu
3651 : 28 > plp
3652 : 194a02 ora absOR,y
tst_ay absrlo,absflo,0
3655 : 08 > php ;save flags
3656 : d96202 > cmp absrlo,y ;test result
> trap_ne ;
3659 : d0fe > bne * ;failed not equal (non zero)
>
365b : 68 > pla ;load status
> eor_flag 0
365c : 4930 > eor #0|fao ;invert expected flags + always on bits
>
365e : d96602 > cmp absflo,y ;test flags
> trap_ne
3661 : d0fe > bne * ;failed not equal (non zero)
>
3663 : 88 dey
3664 : 10e5 bpl tora10
3666 : a003 ldy #3
3668 : tora11
set_ay absORa,$ff
> load_flag $ff
3668 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
366a : 48 > pha ;use stack to load status
366b : b95602 > lda absORa,y ;precharge accu
366e : 28 > plp
366f : 194a02 ora absOR,y
tst_ay absrlo,absflo,$ff-fnz
3672 : 08 > php ;save flags
3673 : d96202 > cmp absrlo,y ;test result
> trap_ne ;
3676 : d0fe > bne * ;failed not equal (non zero)
>
3678 : 68 > pla ;load status
> eor_flag $ff-fnz
3679 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
367b : d96602 > cmp absflo,y ;test flags
> trap_ne
367e : d0fe > bne * ;failed not equal (non zero)
>
3680 : 88 dey
3681 : 10e5 bpl tora11
3683 : a206 ldx #6 ;(zp,x)
3685 : a003 ldy #3
3687 : tora12
set_ay absORa,0
> load_flag 0
3687 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
3689 : 48 > pha ;use stack to load status
368a : b95602 > lda absORa,y ;precharge accu
368d : 28 > plp
368e : 0140 ora (indOR,x)
tst_ay absrlo,absflo,0
3690 : 08 > php ;save flags
3691 : d96202 > cmp absrlo,y ;test result
> trap_ne ;
3694 : d0fe > bne * ;failed not equal (non zero)
>
3696 : 68 > pla ;load status
> eor_flag 0
3697 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
3699 : d96602 > cmp absflo,y ;test flags
> trap_ne
369c : d0fe > bne * ;failed not equal (non zero)
>
369e : ca dex
369f : ca dex
36a0 : 88 dey
36a1 : 10e4 bpl tora12
36a3 : a206 ldx #6
36a5 : a003 ldy #3
36a7 : tora13
set_ay absORa,$ff
> load_flag $ff
36a7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
36a9 : 48 > pha ;use stack to load status
36aa : b95602 > lda absORa,y ;precharge accu
36ad : 28 > plp
36ae : 0140 ora (indOR,x)
tst_ay absrlo,absflo,$ff-fnz
36b0 : 08 > php ;save flags
36b1 : d96202 > cmp absrlo,y ;test result
> trap_ne ;
36b4 : d0fe > bne * ;failed not equal (non zero)
>
36b6 : 68 > pla ;load status
> eor_flag $ff-fnz
36b7 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
36b9 : d96602 > cmp absflo,y ;test flags
> trap_ne
36bc : d0fe > bne * ;failed not equal (non zero)
>
36be : ca dex
36bf : ca dex
36c0 : 88 dey
36c1 : 10e4 bpl tora13
36c3 : a003 ldy #3 ;(zp),y
36c5 : tora14
set_ay absORa,0
> load_flag 0
36c5 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
36c7 : 48 > pha ;use stack to load status
36c8 : b95602 > lda absORa,y ;precharge accu
36cb : 28 > plp
36cc : 1140 ora (indOR),y
tst_ay absrlo,absflo,0
36ce : 08 > php ;save flags
36cf : d96202 > cmp absrlo,y ;test result
> trap_ne ;
36d2 : d0fe > bne * ;failed not equal (non zero)
>
36d4 : 68 > pla ;load status
> eor_flag 0
36d5 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
36d7 : d96602 > cmp absflo,y ;test flags
> trap_ne
36da : d0fe > bne * ;failed not equal (non zero)
>
36dc : 88 dey
36dd : 10e6 bpl tora14
36df : a003 ldy #3
36e1 : tora15
set_ay absORa,$ff
> load_flag $ff
36e1 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
36e3 : 48 > pha ;use stack to load status
36e4 : b95602 > lda absORa,y ;precharge accu
36e7 : 28 > plp
36e8 : 1140 ora (indOR),y
tst_ay absrlo,absflo,$ff-fnz
36ea : 08 > php ;save flags
36eb : d96202 > cmp absrlo,y ;test result
> trap_ne ;
36ee : d0fe > bne * ;failed not equal (non zero)
>
36f0 : 68 > pla ;load status
> eor_flag $ff-fnz
36f1 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
36f3 : d96602 > cmp absflo,y ;test flags
> trap_ne
36f6 : d0fe > bne * ;failed not equal (non zero)
>
36f8 : 88 dey
36f9 : 10e6 bpl tora15
if I_flag = 3
36fb : 58 cli
endif
next_test
36fc : ad0002 > lda test_case ;previous test
36ff : c928 > cmp #test_num
> trap_ne ;test is out of sequence
3701 : d0fe > bne * ;failed not equal (non zero)
>
0029 = >test_num = test_num + 1
3703 : a929 > lda #test_num ;*** next tests' number
3705 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; full binary add/subtract test
; iterates through all combinations of operands and carry input
; uses increments/decrements to predict result & result flags
3708 : d8 cld
3709 : a204 ldx #ad2 ;for indexed test
370b : a0ff ldy #$ff ;max range
370d : a900 lda #0 ;start with adding zeroes & no carry
370f : 8502 sta adfc ;carry in - for diag
3711 : 8503 sta ad1 ;operand 1 - accumulator
3713 : 8504 sta ad2 ;operand 2 - memory or immediate
3715 : 8d0302 sta ada2 ;non zp
3718 : 8505 sta adrl ;expected result bits 0-7
371a : 8506 sta adrh ;expected result bit 8 (carry out)
371c : a9ff lda #$ff ;complemented operand 2 for subtract
371e : 8508 sta sb2
3720 : 8d0402 sta sba2 ;non zp
3723 : a902 lda #2 ;expected Z-flag
3725 : 8507 sta adrf
3727 : 18 tadd clc ;test with carry clear
3728 : 20a239 jsr chkadd
372b : e602 inc adfc ;now with carry
372d : e605 inc adrl ;result +1
372f : 08 php ;save N & Z from low result
3730 : 08 php
3731 : 68 pla ;accu holds expected flags
3732 : 2982 and #$82 ;mask N & Z
3734 : 28 plp
3735 : d002 bne tadd1
3737 : e606 inc adrh ;result bit 8 - carry
3739 : 0506 tadd1 ora adrh ;merge C to expected flags
373b : 8507 sta adrf ;save expected flags except overflow
373d : 38 sec ;test with carry set
373e : 20a239 jsr chkadd
3741 : c602 dec adfc ;same for operand +1 but no carry
3743 : e603 inc ad1
3745 : d0e0 bne tadd ;iterate op1
3747 : a900 lda #0 ;preset result to op2 when op1 = 0
3749 : 8506 sta adrh
374b : ee0302 inc ada2
374e : e604 inc ad2
3750 : 08 php ;save NZ as operand 2 becomes the new result
3751 : 68 pla
3752 : 2982 and #$82 ;mask N00000Z0
3754 : 8507 sta adrf ;no need to check carry as we are adding to 0
3756 : c608 dec sb2 ;complement subtract operand 2
3758 : ce0402 dec sba2
375b : a504 lda ad2
375d : 8505 sta adrl
375f : d0c6 bne tadd ;iterate op2
if disable_decimal < 1
next_test
3761 : ad0002 > lda test_case ;previous test
3764 : c929 > cmp #test_num
> trap_ne ;test is out of sequence
3766 : d0fe > bne * ;failed not equal (non zero)
>
002a = >test_num = test_num + 1
3768 : a92a > lda #test_num ;*** next tests' number
376a : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; decimal add/subtract test
; *** WARNING - tests documented behavior only! ***
; only valid BCD operands are tested, N V Z flags are ignored
; iterates through all valid combinations of operands and carry input
; uses increments/decrements to predict result & carry flag
376d : f8 sed
376e : a204 ldx #ad2 ;for indexed test
3770 : a0ff ldy #$ff ;max range
3772 : a999 lda #$99 ;start with adding 99 to 99 with carry
3774 : 8503 sta ad1 ;operand 1 - accumulator
3776 : 8504 sta ad2 ;operand 2 - memory or immediate
3778 : 8d0302 sta ada2 ;non zp
377b : 8505 sta adrl ;expected result bits 0-7
377d : a901 lda #1 ;set carry in & out
377f : 8502 sta adfc ;carry in - for diag
3781 : 8506 sta adrh ;expected result bit 8 (carry out)
3783 : a900 lda #0 ;complemented operand 2 for subtract
3785 : 8508 sta sb2
3787 : 8d0402 sta sba2 ;non zp
378a : 38 tdad sec ;test with carry set
378b : 206f38 jsr chkdad
378e : c602 dec adfc ;now with carry clear
3790 : a505 lda adrl ;decimal adjust result
3792 : d008 bne tdad1 ;skip clear carry & preset result 99 (9A-1)
3794 : c606 dec adrh
3796 : a999 lda #$99
3798 : 8505 sta adrl
379a : d012 bne tdad3
379c : 290f tdad1 and #$f ;lower nibble mask
379e : d00c bne tdad2 ;no decimal adjust needed
37a0 : c605 dec adrl ;decimal adjust (?0-6)
37a2 : c605 dec adrl
37a4 : c605 dec adrl
37a6 : c605 dec adrl
37a8 : c605 dec adrl
37aa : c605 dec adrl
37ac : c605 tdad2 dec adrl ;result -1
37ae : 18 tdad3 clc ;test with carry clear
37af : 206f38 jsr chkdad
37b2 : e602 inc adfc ;same for operand -1 but with carry
37b4 : a503 lda ad1 ;decimal adjust operand 1
37b6 : f015 beq tdad5 ;iterate operand 2
37b8 : 290f and #$f ;lower nibble mask
37ba : d00c bne tdad4 ;skip decimal adjust
37bc : c603 dec ad1 ;decimal adjust (?0-6)
37be : c603 dec ad1
37c0 : c603 dec ad1
37c2 : c603 dec ad1
37c4 : c603 dec ad1
37c6 : c603 dec ad1
37c8 : c603 tdad4 dec ad1 ;operand 1 -1
37ca : 4c8a37 jmp tdad ;iterate op1
37cd : a999 tdad5 lda #$99 ;precharge op1 max
37cf : 8503 sta ad1
37d1 : a504 lda ad2 ;decimal adjust operand 2
37d3 : f030 beq tdad7 ;end of iteration
37d5 : 290f and #$f ;lower nibble mask
37d7 : d018 bne tdad6 ;skip decimal adjust
37d9 : c604 dec ad2 ;decimal adjust (?0-6)
37db : c604 dec ad2
37dd : c604 dec ad2
37df : c604 dec ad2
37e1 : c604 dec ad2
37e3 : c604 dec ad2
37e5 : e608 inc sb2 ;complemented decimal adjust for subtract (?9+6)
37e7 : e608 inc sb2
37e9 : e608 inc sb2
37eb : e608 inc sb2
37ed : e608 inc sb2
37ef : e608 inc sb2
37f1 : c604 tdad6 dec ad2 ;operand 2 -1
37f3 : e608 inc sb2 ;complemented operand for subtract
37f5 : a508 lda sb2
37f7 : 8d0402 sta sba2 ;copy as non zp operand
37fa : a504 lda ad2
37fc : 8d0302 sta ada2 ;copy as non zp operand
37ff : 8505 sta adrl ;new result since op1+carry=00+carry +op2=op2
3801 : e606 inc adrh ;result carry
3803 : d085 bne tdad ;iterate op2
3805 : tdad7
next_test
3805 : ad0002 > lda test_case ;previous test
3808 : c92a > cmp #test_num
> trap_ne ;test is out of sequence
380a : d0fe > bne * ;failed not equal (non zero)
>
002b = >test_num = test_num + 1
380c : a92b > lda #test_num ;*** next tests' number
380e : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; decimal/binary switch test
; tests CLD, SED, PLP, RTI to properly switch between decimal & binary opcode
; tables
3811 : 18 clc
3812 : d8 cld
3813 : 08 php
3814 : a955 lda #$55
3816 : 6955 adc #$55
3818 : c9aa cmp #$aa
trap_ne ;expected binary result after cld
381a : d0fe > bne * ;failed not equal (non zero)
381c : 18 clc
381d : f8 sed
381e : 08 php
381f : a955 lda #$55
3821 : 6955 adc #$55
3823 : c910 cmp #$10
trap_ne ;expected decimal result after sed
3825 : d0fe > bne * ;failed not equal (non zero)
3827 : d8 cld
3828 : 28 plp
3829 : a955 lda #$55
382b : 6955 adc #$55
382d : c910 cmp #$10
trap_ne ;expected decimal result after plp D=1
382f : d0fe > bne * ;failed not equal (non zero)
3831 : 28 plp
3832 : a955 lda #$55
3834 : 6955 adc #$55
3836 : c9aa cmp #$aa
trap_ne ;expected binary result after plp D=0
3838 : d0fe > bne * ;failed not equal (non zero)
383a : 18 clc
383b : a938 lda #hi bin_rti_ret ;emulated interrupt for rti
383d : 48 pha
383e : a955 lda #lo bin_rti_ret
3840 : 48 pha
3841 : 08 php
3842 : f8 sed
3843 : a938 lda #hi dec_rti_ret ;emulated interrupt for rti
3845 : 48 pha
3846 : a94c lda #lo dec_rti_ret
3848 : 48 pha
3849 : 08 php
384a : d8 cld
384b : 40 rti
384c : dec_rti_ret
384c : a955 lda #$55
384e : 6955 adc #$55
3850 : c910 cmp #$10
trap_ne ;expected decimal result after rti D=1
3852 : d0fe > bne * ;failed not equal (non zero)
3854 : 40 rti
3855 : bin_rti_ret
3855 : a955 lda #$55
3857 : 6955 adc #$55
3859 : c9aa cmp #$aa
trap_ne ;expected binary result after rti D=0
385b : d0fe > bne * ;failed not equal (non zero)
endif
385d : ad0002 lda test_case
3860 : c92b cmp #test_num
trap_ne ;previous test is out of sequence
3862 : d0fe > bne * ;failed not equal (non zero)
3864 : a9f0 lda #$f0 ;mark opcode testing complete
3866 : 8d0002 sta test_case
; final RAM integrity test
; verifies that none of the previous tests has altered RAM outside of the
; designated write areas.
check_ram
> ;RAM check disabled - RAM size not set
; *** DEBUG INFO ***
; to debug checksum errors uncomment check_ram in the next_test macro to
; narrow down the responsible opcode.
; may give false errors when monitor, OS or other background activity is
; allowed during previous tests.
; S U C C E S S ************************************************
; -------------
success ;if you get here everything went well
3869 : 4c6938 > jmp * ;test passed, no errors
; -------------
; S U C C E S S ************************************************
386c : 4c0008 jmp start ;run again
if disable_decimal < 1
; core subroutine of the decimal add/subtract test
; *** WARNING - tests documented behavior only! ***
; only valid BCD operands are tested, N V Z flags are ignored
; iterates through all valid combinations of operands and carry input
; uses increments/decrements to predict result & carry flag
386f : chkdad
; decimal ADC / SBC zp
386f : 08 php ;save carry for subtract
3870 : a503 lda ad1
3872 : 6504 adc ad2 ;perform add
3874 : 08 php
3875 : c505 cmp adrl ;check result
trap_ne ;bad result
3877 : d0fe > bne * ;failed not equal (non zero)
3879 : 68 pla ;check flags
387a : 2901 and #1 ;mask carry
387c : c506 cmp adrh
trap_ne ;bad carry
387e : d0fe > bne * ;failed not equal (non zero)
3880 : 28 plp
3881 : 08 php ;save carry for next add
3882 : a503 lda ad1
3884 : e508 sbc sb2 ;perform subtract
3886 : 08 php
3887 : c505 cmp adrl ;check result
trap_ne ;bad result
3889 : d0fe > bne * ;failed not equal (non zero)
388b : 68 pla ;check flags
388c : 2901 and #1 ;mask carry
388e : c506 cmp adrh
trap_ne ;bad flags
3890 : d0fe > bne * ;failed not equal (non zero)
3892 : 28 plp
; decimal ADC / SBC abs
3893 : 08 php ;save carry for subtract
3894 : a503 lda ad1
3896 : 6d0302 adc ada2 ;perform add
3899 : 08 php
389a : c505 cmp adrl ;check result
trap_ne ;bad result
389c : d0fe > bne * ;failed not equal (non zero)
389e : 68 pla ;check flags
389f : 2901 and #1 ;mask carry
38a1 : c506 cmp adrh
trap_ne ;bad carry
38a3 : d0fe > bne * ;failed not equal (non zero)
38a5 : 28 plp
38a6 : 08 php ;save carry for next add
38a7 : a503 lda ad1
38a9 : ed0402 sbc sba2 ;perform subtract
38ac : 08 php
38ad : c505 cmp adrl ;check result
trap_ne ;bad result
38af : d0fe > bne * ;failed not equal (non zero)
38b1 : 68 pla ;check flags
38b2 : 2901 and #1 ;mask carry
38b4 : c506 cmp adrh
trap_ne ;bad carry
38b6 : d0fe > bne * ;failed not equal (non zero)
38b8 : 28 plp
; decimal ADC / SBC #
38b9 : 08 php ;save carry for subtract
38ba : a504 lda ad2
38bc : 8d1202 sta ex_adci+1 ;set ADC # operand
38bf : a503 lda ad1
38c1 : 201102 jsr ex_adci ;execute ADC # in RAM
38c4 : 08 php
38c5 : c505 cmp adrl ;check result
trap_ne ;bad result
38c7 : d0fe > bne * ;failed not equal (non zero)
38c9 : 68 pla ;check flags
38ca : 2901 and #1 ;mask carry
38cc : c506 cmp adrh
trap_ne ;bad carry
38ce : d0fe > bne * ;failed not equal (non zero)
38d0 : 28 plp
38d1 : 08 php ;save carry for next add
38d2 : a508 lda sb2
38d4 : 8d1502 sta ex_sbci+1 ;set SBC # operand
38d7 : a503 lda ad1
38d9 : 201402 jsr ex_sbci ;execute SBC # in RAM
38dc : 08 php
38dd : c505 cmp adrl ;check result
trap_ne ;bad result
38df : d0fe > bne * ;failed not equal (non zero)
38e1 : 68 pla ;check flags
38e2 : 2901 and #1 ;mask carry
38e4 : c506 cmp adrh
trap_ne ;bad carry
38e6 : d0fe > bne * ;failed not equal (non zero)
38e8 : 28 plp
; decimal ADC / SBC zp,x
38e9 : 08 php ;save carry for subtract
38ea : a503 lda ad1
38ec : 7500 adc 0,x ;perform add
38ee : 08 php
38ef : c505 cmp adrl ;check result
trap_ne ;bad result
38f1 : d0fe > bne * ;failed not equal (non zero)
38f3 : 68 pla ;check flags
38f4 : 2901 and #1 ;mask carry
38f6 : c506 cmp adrh
trap_ne ;bad carry
38f8 : d0fe > bne * ;failed not equal (non zero)
38fa : 28 plp
38fb : 08 php ;save carry for next add
38fc : a503 lda ad1
38fe : f504 sbc sb2-ad2,x ;perform subtract
3900 : 08 php
3901 : c505 cmp adrl ;check result
trap_ne ;bad result
3903 : d0fe > bne * ;failed not equal (non zero)
3905 : 68 pla ;check flags
3906 : 2901 and #1 ;mask carry
3908 : c506 cmp adrh
trap_ne ;bad carry
390a : d0fe > bne * ;failed not equal (non zero)
390c : 28 plp
; decimal ADC / SBC abs,x
390d : 08 php ;save carry for subtract
390e : a503 lda ad1
3910 : 7dff01 adc ada2-ad2,x ;perform add
3913 : 08 php
3914 : c505 cmp adrl ;check result
trap_ne ;bad result
3916 : d0fe > bne * ;failed not equal (non zero)
3918 : 68 pla ;check flags
3919 : 2901 and #1 ;mask carry
391b : c506 cmp adrh
trap_ne ;bad carry
391d : d0fe > bne * ;failed not equal (non zero)
391f : 28 plp
3920 : 08 php ;save carry for next add
3921 : a503 lda ad1
3923 : fd0002 sbc sba2-ad2,x ;perform subtract
3926 : 08 php
3927 : c505 cmp adrl ;check result
trap_ne ;bad result
3929 : d0fe > bne * ;failed not equal (non zero)
392b : 68 pla ;check flags
392c : 2901 and #1 ;mask carry
392e : c506 cmp adrh
trap_ne ;bad carry
3930 : d0fe > bne * ;failed not equal (non zero)
3932 : 28 plp
; decimal ADC / SBC abs,y
3933 : 08 php ;save carry for subtract
3934 : a503 lda ad1
3936 : 790401 adc ada2-$ff,y ;perform add
3939 : 08 php
393a : c505 cmp adrl ;check result
trap_ne ;bad result
393c : d0fe > bne * ;failed not equal (non zero)
393e : 68 pla ;check flags
393f : 2901 and #1 ;mask carry
3941 : c506 cmp adrh
trap_ne ;bad carry
3943 : d0fe > bne * ;failed not equal (non zero)
3945 : 28 plp
3946 : 08 php ;save carry for next add
3947 : a503 lda ad1
3949 : f90501 sbc sba2-$ff,y ;perform subtract
394c : 08 php
394d : c505 cmp adrl ;check result
trap_ne ;bad result
394f : d0fe > bne * ;failed not equal (non zero)
3951 : 68 pla ;check flags
3952 : 2901 and #1 ;mask carry
3954 : c506 cmp adrh
trap_ne ;bad carry
3956 : d0fe > bne * ;failed not equal (non zero)
3958 : 28 plp
; decimal ADC / SBC (zp,x)
3959 : 08 php ;save carry for subtract
395a : a503 lda ad1
395c : 6144 adc (lo adi2-ad2,x) ;perform add
395e : 08 php
395f : c505 cmp adrl ;check result
trap_ne ;bad result
3961 : d0fe > bne * ;failed not equal (non zero)
3963 : 68 pla ;check flags
3964 : 2901 and #1 ;mask carry
3966 : c506 cmp adrh
trap_ne ;bad carry
3968 : d0fe > bne * ;failed not equal (non zero)
396a : 28 plp
396b : 08 php ;save carry for next add
396c : a503 lda ad1
396e : e146 sbc (lo sbi2-ad2,x) ;perform subtract
3970 : 08 php
3971 : c505 cmp adrl ;check result
trap_ne ;bad result
3973 : d0fe > bne * ;failed not equal (non zero)
3975 : 68 pla ;check flags
3976 : 2901 and #1 ;mask carry
3978 : c506 cmp adrh
trap_ne ;bad carry
397a : d0fe > bne * ;failed not equal (non zero)
397c : 28 plp
; decimal ADC / SBC (abs),y
397d : 08 php ;save carry for subtract
397e : a503 lda ad1
3980 : 714c adc (adiy2),y ;perform add
3982 : 08 php
3983 : c505 cmp adrl ;check result
trap_ne ;bad result
3985 : d0fe > bne * ;failed not equal (non zero)
3987 : 68 pla ;check flags
3988 : 2901 and #1 ;mask carry
398a : c506 cmp adrh
trap_ne ;bad carry
398c : d0fe > bne * ;failed not equal (non zero)
398e : 28 plp
398f : 08 php ;save carry for next add
3990 : a503 lda ad1
3992 : f14e sbc (sbiy2),y ;perform subtract
3994 : 08 php
3995 : c505 cmp adrl ;check result
trap_ne ;bad result
3997 : d0fe > bne * ;failed not equal (non zero)
3999 : 68 pla ;check flags
399a : 2901 and #1 ;mask carry
399c : c506 cmp adrh
trap_ne ;bad carry
399e : d0fe > bne * ;failed not equal (non zero)
39a0 : 28 plp
39a1 : 60 rts
endif
; core subroutine of the full binary add/subtract test
; iterates through all combinations of operands and carry input
; uses increments/decrements to predict result & result flags
39a2 : a507 chkadd lda adrf ;add V-flag if overflow
39a4 : 2983 and #$83 ;keep N-----ZC / clear V
39a6 : 48 pha
39a7 : a503 lda ad1 ;test sign unequal between operands
39a9 : 4504 eor ad2
39ab : 300a bmi ckad1 ;no overflow possible - operands have different sign
39ad : a503 lda ad1 ;test sign equal between operands and result
39af : 4505 eor adrl
39b1 : 1004 bpl ckad1 ;no overflow occured - operand and result have same sign
39b3 : 68 pla
39b4 : 0940 ora #$40 ;set V
39b6 : 48 pha
39b7 : 68 ckad1 pla
39b8 : 8507 sta adrf ;save expected flags
; binary ADC / SBC zp
39ba : 08 php ;save carry for subtract
39bb : a503 lda ad1
39bd : 6504 adc ad2 ;perform add
39bf : 08 php
39c0 : c505 cmp adrl ;check result
trap_ne ;bad result
39c2 : d0fe > bne * ;failed not equal (non zero)
39c4 : 68 pla ;check flags
39c5 : 29c3 and #$c3 ;mask NV----ZC
39c7 : c507 cmp adrf
trap_ne ;bad flags
39c9 : d0fe > bne * ;failed not equal (non zero)
39cb : 28 plp
39cc : 08 php ;save carry for next add
39cd : a503 lda ad1
39cf : e508 sbc sb2 ;perform subtract
39d1 : 08 php
39d2 : c505 cmp adrl ;check result
trap_ne ;bad result
39d4 : d0fe > bne * ;failed not equal (non zero)
39d6 : 68 pla ;check flags
39d7 : 29c3 and #$c3 ;mask NV----ZC
39d9 : c507 cmp adrf
trap_ne ;bad flags
39db : d0fe > bne * ;failed not equal (non zero)
39dd : 28 plp
; binary ADC / SBC abs
39de : 08 php ;save carry for subtract
39df : a503 lda ad1
39e1 : 6d0302 adc ada2 ;perform add
39e4 : 08 php
39e5 : c505 cmp adrl ;check result
trap_ne ;bad result
39e7 : d0fe > bne * ;failed not equal (non zero)
39e9 : 68 pla ;check flags
39ea : 29c3 and #$c3 ;mask NV----ZC
39ec : c507 cmp adrf
trap_ne ;bad flags
39ee : d0fe > bne * ;failed not equal (non zero)
39f0 : 28 plp
39f1 : 08 php ;save carry for next add
39f2 : a503 lda ad1
39f4 : ed0402 sbc sba2 ;perform subtract
39f7 : 08 php
39f8 : c505 cmp adrl ;check result
trap_ne ;bad result
39fa : d0fe > bne * ;failed not equal (non zero)
39fc : 68 pla ;check flags
39fd : 29c3 and #$c3 ;mask NV----ZC
39ff : c507 cmp adrf
trap_ne ;bad flags
3a01 : d0fe > bne * ;failed not equal (non zero)
3a03 : 28 plp
; binary ADC / SBC #
3a04 : 08 php ;save carry for subtract
3a05 : a504 lda ad2
3a07 : 8d1202 sta ex_adci+1 ;set ADC # operand
3a0a : a503 lda ad1
3a0c : 201102 jsr ex_adci ;execute ADC # in RAM
3a0f : 08 php
3a10 : c505 cmp adrl ;check result
trap_ne ;bad result
3a12 : d0fe > bne * ;failed not equal (non zero)
3a14 : 68 pla ;check flags
3a15 : 29c3 and #$c3 ;mask NV----ZC
3a17 : c507 cmp adrf
trap_ne ;bad flags
3a19 : d0fe > bne * ;failed not equal (non zero)
3a1b : 28 plp
3a1c : 08 php ;save carry for next add
3a1d : a508 lda sb2
3a1f : 8d1502 sta ex_sbci+1 ;set SBC # operand
3a22 : a503 lda ad1
3a24 : 201402 jsr ex_sbci ;execute SBC # in RAM
3a27 : 08 php
3a28 : c505 cmp adrl ;check result
trap_ne ;bad result
3a2a : d0fe > bne * ;failed not equal (non zero)
3a2c : 68 pla ;check flags
3a2d : 29c3 and #$c3 ;mask NV----ZC
3a2f : c507 cmp adrf
trap_ne ;bad flags
3a31 : d0fe > bne * ;failed not equal (non zero)
3a33 : 28 plp
; binary ADC / SBC zp,x
3a34 : 08 php ;save carry for subtract
3a35 : a503 lda ad1
3a37 : 7500 adc 0,x ;perform add
3a39 : 08 php
3a3a : c505 cmp adrl ;check result
trap_ne ;bad result
3a3c : d0fe > bne * ;failed not equal (non zero)
3a3e : 68 pla ;check flags
3a3f : 29c3 and #$c3 ;mask NV----ZC
3a41 : c507 cmp adrf
trap_ne ;bad flags
3a43 : d0fe > bne * ;failed not equal (non zero)
3a45 : 28 plp
3a46 : 08 php ;save carry for next add
3a47 : a503 lda ad1
3a49 : f504 sbc sb2-ad2,x ;perform subtract
3a4b : 08 php
3a4c : c505 cmp adrl ;check result
trap_ne ;bad result
3a4e : d0fe > bne * ;failed not equal (non zero)
3a50 : 68 pla ;check flags
3a51 : 29c3 and #$c3 ;mask NV----ZC
3a53 : c507 cmp adrf
trap_ne ;bad flags
3a55 : d0fe > bne * ;failed not equal (non zero)
3a57 : 28 plp
; binary ADC / SBC abs,x
3a58 : 08 php ;save carry for subtract
3a59 : a503 lda ad1
3a5b : 7dff01 adc ada2-ad2,x ;perform add
3a5e : 08 php
3a5f : c505 cmp adrl ;check result
trap_ne ;bad result
3a61 : d0fe > bne * ;failed not equal (non zero)
3a63 : 68 pla ;check flags
3a64 : 29c3 and #$c3 ;mask NV----ZC
3a66 : c507 cmp adrf
trap_ne ;bad flags
3a68 : d0fe > bne * ;failed not equal (non zero)
3a6a : 28 plp
3a6b : 08 php ;save carry for next add
3a6c : a503 lda ad1
3a6e : fd0002 sbc sba2-ad2,x ;perform subtract
3a71 : 08 php
3a72 : c505 cmp adrl ;check result
trap_ne ;bad result
3a74 : d0fe > bne * ;failed not equal (non zero)
3a76 : 68 pla ;check flags
3a77 : 29c3 and #$c3 ;mask NV----ZC
3a79 : c507 cmp adrf
trap_ne ;bad flags
3a7b : d0fe > bne * ;failed not equal (non zero)
3a7d : 28 plp
; binary ADC / SBC abs,y
3a7e : 08 php ;save carry for subtract
3a7f : a503 lda ad1
3a81 : 790401 adc ada2-$ff,y ;perform add
3a84 : 08 php
3a85 : c505 cmp adrl ;check result
trap_ne ;bad result
3a87 : d0fe > bne * ;failed not equal (non zero)
3a89 : 68 pla ;check flags
3a8a : 29c3 and #$c3 ;mask NV----ZC
3a8c : c507 cmp adrf
trap_ne ;bad flags
3a8e : d0fe > bne * ;failed not equal (non zero)
3a90 : 28 plp
3a91 : 08 php ;save carry for next add
3a92 : a503 lda ad1
3a94 : f90501 sbc sba2-$ff,y ;perform subtract
3a97 : 08 php
3a98 : c505 cmp adrl ;check result
trap_ne ;bad result
3a9a : d0fe > bne * ;failed not equal (non zero)
3a9c : 68 pla ;check flags
3a9d : 29c3 and #$c3 ;mask NV----ZC
3a9f : c507 cmp adrf
trap_ne ;bad flags
3aa1 : d0fe > bne * ;failed not equal (non zero)
3aa3 : 28 plp
; binary ADC / SBC (zp,x)
3aa4 : 08 php ;save carry for subtract
3aa5 : a503 lda ad1
3aa7 : 6144 adc (lo adi2-ad2,x) ;perform add
3aa9 : 08 php
3aaa : c505 cmp adrl ;check result
trap_ne ;bad result
3aac : d0fe > bne * ;failed not equal (non zero)
3aae : 68 pla ;check flags
3aaf : 29c3 and #$c3 ;mask NV----ZC
3ab1 : c507 cmp adrf
trap_ne ;bad flags
3ab3 : d0fe > bne * ;failed not equal (non zero)
3ab5 : 28 plp
3ab6 : 08 php ;save carry for next add
3ab7 : a503 lda ad1
3ab9 : e146 sbc (lo sbi2-ad2,x) ;perform subtract
3abb : 08 php
3abc : c505 cmp adrl ;check result
trap_ne ;bad result
3abe : d0fe > bne * ;failed not equal (non zero)
3ac0 : 68 pla ;check flags
3ac1 : 29c3 and #$c3 ;mask NV----ZC
3ac3 : c507 cmp adrf
trap_ne ;bad flags
3ac5 : d0fe > bne * ;failed not equal (non zero)
3ac7 : 28 plp
; binary ADC / SBC (abs),y
3ac8 : 08 php ;save carry for subtract
3ac9 : a503 lda ad1
3acb : 714c adc (adiy2),y ;perform add
3acd : 08 php
3ace : c505 cmp adrl ;check result
trap_ne ;bad result
3ad0 : d0fe > bne * ;failed not equal (non zero)
3ad2 : 68 pla ;check flags
3ad3 : 29c3 and #$c3 ;mask NV----ZC
3ad5 : c507 cmp adrf
trap_ne ;bad flags
3ad7 : d0fe > bne * ;failed not equal (non zero)
3ad9 : 28 plp
3ada : 08 php ;save carry for next add
3adb : a503 lda ad1
3add : f14e sbc (sbiy2),y ;perform subtract
3adf : 08 php
3ae0 : c505 cmp adrl ;check result
trap_ne ;bad result
3ae2 : d0fe > bne * ;failed not equal (non zero)
3ae4 : 68 pla ;check flags
3ae5 : 29c3 and #$c3 ;mask NV----ZC
3ae7 : c507 cmp adrf
trap_ne ;bad flags
3ae9 : d0fe > bne * ;failed not equal (non zero)
3aeb : 28 plp
3aec : 60 rts
; target for the jump absolute test
3aed : 88 dey
3aee : 88 dey
3aef : test_far
3aef : 08 php ;either SP or Y count will fail, if we do not hit
3af0 : 88 dey
3af1 : 88 dey
3af2 : 88 dey
3af3 : 28 plp
trap_cs ;flags loaded?
3af4 : b0fe > bcs * ;failed carry set
trap_vs
3af6 : 70fe > bvs * ;failed overflow set
trap_mi
3af8 : 30fe > bmi * ;failed minus (bit 7 set)
trap_eq
3afa : f0fe > beq * ;failed equal (zero)
3afc : c946 cmp #'F' ;registers loaded?
trap_ne
3afe : d0fe > bne * ;failed not equal (non zero)
3b00 : e041 cpx #'A'
trap_ne
3b02 : d0fe > bne * ;failed not equal (non zero)
3b04 : c04f cpy #('R'-3)
trap_ne
3b06 : d0fe > bne * ;failed not equal (non zero)
3b08 : 48 pha ;save a,x
3b09 : 8a txa
3b0a : 48 pha
3b0b : ba tsx
3b0c : e0fd cpx #$fd ;check SP
trap_ne
3b0e : d0fe > bne * ;failed not equal (non zero)
3b10 : 68 pla ;restore x
3b11 : aa tax
set_stat $ff
> load_flag $ff
3b12 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
3b14 : 48 > pha ;use stack to load status
3b15 : 28 > plp
3b16 : 68 pla ;restore a
3b17 : e8 inx ;return registers with modifications
3b18 : 49aa eor #$aa ;N=1, V=1, Z=0, C=1
3b1a : 4c0f0d jmp far_ret
; target for the jump indirect test
3b1d : 00 align
3b1e : 273b ptr_tst_ind dw test_ind
3b20 : 640d ptr_ind_ret dw ind_ret
trap ;runover protection
3b22 : 4c223b > jmp * ;failed anyway
3b25 : 88 dey
3b26 : 88 dey
3b27 : test_ind
3b27 : 08 php ;either SP or Y count will fail, if we do not hit
3b28 : 88 dey
3b29 : 88 dey
3b2a : 88 dey
3b2b : 28 plp
trap_cs ;flags loaded?
3b2c : b0fe > bcs * ;failed carry set
trap_vs
3b2e : 70fe > bvs * ;failed overflow set
trap_mi
3b30 : 30fe > bmi * ;failed minus (bit 7 set)
trap_eq
3b32 : f0fe > beq * ;failed equal (zero)
3b34 : c949 cmp #'I' ;registers loaded?
trap_ne
3b36 : d0fe > bne * ;failed not equal (non zero)
3b38 : e04e cpx #'N'
trap_ne
3b3a : d0fe > bne * ;failed not equal (non zero)
3b3c : c041 cpy #('D'-3)
trap_ne
3b3e : d0fe > bne * ;failed not equal (non zero)
3b40 : 48 pha ;save a,x
3b41 : 8a txa
3b42 : 48 pha
3b43 : ba tsx
3b44 : e0fd cpx #$fd ;check SP
trap_ne
3b46 : d0fe > bne * ;failed not equal (non zero)
3b48 : 68 pla ;restore x
3b49 : aa tax
set_stat $ff
> load_flag $ff
3b4a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
3b4c : 48 > pha ;use stack to load status
3b4d : 28 > plp
3b4e : 68 pla ;restore a
3b4f : e8 inx ;return registers with modifications
3b50 : 49aa eor #$aa ;N=1, V=1, Z=0, C=1
3b52 : 6c203b jmp (ptr_ind_ret)
trap ;runover protection
3b55 : 4c553b > jmp * ;failed anyway
3b58 : 4c0008 jmp start ;catastrophic error - cannot continue
; target for the jump subroutine test
3b5b : 88 dey
3b5c : 88 dey
3b5d : test_jsr
3b5d : 08 php ;either SP or Y count will fail, if we do not hit
3b5e : 88 dey
3b5f : 88 dey
3b60 : 88 dey
3b61 : 28 plp
trap_cs ;flags loaded?
3b62 : b0fe > bcs * ;failed carry set
trap_vs
3b64 : 70fe > bvs * ;failed overflow set
trap_mi
3b66 : 30fe > bmi * ;failed minus (bit 7 set)
trap_eq
3b68 : f0fe > beq * ;failed equal (zero)
3b6a : c94a cmp #'J' ;registers loaded?
trap_ne
3b6c : d0fe > bne * ;failed not equal (non zero)
3b6e : e053 cpx #'S'
trap_ne
3b70 : d0fe > bne * ;failed not equal (non zero)
3b72 : c04f cpy #('R'-3)
trap_ne
3b74 : d0fe > bne * ;failed not equal (non zero)
3b76 : 48 pha ;save a,x
3b77 : 8a txa
3b78 : 48 pha
3b79 : ba tsx ;sp -4? (return addr,a,x)
3b7a : e0fb cpx #$fb
trap_ne
3b7c : d0fe > bne * ;failed not equal (non zero)
3b7e : adff01 lda $1ff ;propper return on stack
3b81 : c90d cmp #hi(jsr_ret)
trap_ne
3b83 : d0fe > bne * ;failed not equal (non zero)
3b85 : adfe01 lda $1fe
3b88 : c99a cmp #lo(jsr_ret)
trap_ne
3b8a : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
3b8c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
3b8e : 48 > pha ;use stack to load status
3b8f : 28 > plp
3b90 : 68 pla ;pull x,a
3b91 : aa tax
3b92 : 68 pla
3b93 : e8 inx ;return registers with modifications
3b94 : 49aa eor #$aa ;N=1, V=1, Z=0, C=1
3b96 : 60 rts
trap ;runover protection
3b97 : 4c973b > jmp * ;failed anyway
3b9a : 4c0008 jmp start ;catastrophic error - cannot continue
;trap in case of unexpected IRQ, NMI, BRK, RESET - BRK test target
3b9d : nmi_trap
trap ;check stack for conditions at NMI
3b9d : 4c9d3b > jmp * ;failed anyway
3ba0 : 4c0008 jmp start ;catastrophic error - cannot continue
3ba3 : res_trap
trap ;unexpected RESET
3ba3 : 4ca33b > jmp * ;failed anyway
3ba6 : 4c0008 jmp start ;catastrophic error - cannot continue
3ba9 : 88 dey
3baa : 88 dey
3bab : irq_trap ;BRK test or unextpected BRK or IRQ
3bab : 08 php ;either SP or Y count will fail, if we do not hit
3bac : 88 dey
3bad : 88 dey
3bae : 88 dey
;next traps could be caused by unexpected BRK or IRQ
;check stack for BREAK and originating location
;possible jump/branch into weeds (uninitialized space)
3baf : c9bd cmp #$ff-'B' ;BRK pass 2 registers loaded?
3bb1 : f042 beq break2
3bb3 : c942 cmp #'B' ;BRK pass 1 registers loaded?
trap_ne
3bb5 : d0fe > bne * ;failed not equal (non zero)
3bb7 : e052 cpx #'R'
trap_ne
3bb9 : d0fe > bne * ;failed not equal (non zero)
3bbb : c048 cpy #'K'-3
trap_ne
3bbd : d0fe > bne * ;failed not equal (non zero)
3bbf : 8500 sta irq_a ;save registers during break test
3bc1 : 8601 stx irq_x
3bc3 : ba tsx ;test break on stack
3bc4 : bd0201 lda $102,x
cmp_flag 0 ;break test should have B=1 & unused=1 on stack
3bc7 : c930 > cmp #(0 |fao)&m8 ;expected flags + always on bits
trap_ne ; - no break flag on stack
3bc9 : d0fe > bne * ;failed not equal (non zero)
3bcb : 68 pla
cmp_flag intdis ;should have added interrupt disable
3bcc : c934 > cmp #(intdis |fao)&m8 ;expected flags + always on bits
trap_ne
3bce : d0fe > bne * ;failed not equal (non zero)
3bd0 : ba tsx
3bd1 : e0fc cpx #$fc ;sp -3? (return addr, flags)
trap_ne
3bd3 : d0fe > bne * ;failed not equal (non zero)
3bd5 : adff01 lda $1ff ;propper return on stack
3bd8 : c90d cmp #hi(brk_ret0)
trap_ne
3bda : d0fe > bne * ;failed not equal (non zero)
3bdc : adfe01 lda $1fe
3bdf : c9d1 cmp #lo(brk_ret0)
trap_ne
3be1 : d0fe > bne * ;failed not equal (non zero)
load_flag $ff
3be3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
3be5 : 48 pha
3be6 : a601 ldx irq_x
3be8 : e8 inx ;return registers with modifications
3be9 : a500 lda irq_a
3beb : 49aa eor #$aa
3bed : 28 plp ;N=1, V=1, Z=1, C=1 but original flags should be restored
3bee : 40 rti
trap ;runover protection
3bef : 4cef3b > jmp * ;failed anyway
3bf2 : 4c0008 jmp start ;catastrophic error - cannot continue
3bf5 : break2 ;BRK pass 2
3bf5 : e0ad cpx #$ff-'R'
trap_ne
3bf7 : d0fe > bne * ;failed not equal (non zero)
3bf9 : c0b1 cpy #$ff-'K'-3
trap_ne
3bfb : d0fe > bne * ;failed not equal (non zero)
3bfd : 8500 sta irq_a ;save registers during break test
3bff : 8601 stx irq_x
3c01 : ba tsx ;test break on stack
3c02 : bd0201 lda $102,x
cmp_flag $ff ;break test should have B=1
3c05 : c9ff > cmp #($ff |fao)&m8 ;expected flags + always on bits
trap_ne ; - no break flag on stack
3c07 : d0fe > bne * ;failed not equal (non zero)
3c09 : 68 pla
3c0a : 0908 ora #decmode ;ignore decmode cleared if 65c02
cmp_flag $ff ;actual passed flags
3c0c : c9ff > cmp #($ff |fao)&m8 ;expected flags + always on bits
trap_ne
3c0e : d0fe > bne * ;failed not equal (non zero)
3c10 : ba tsx
3c11 : e0fc cpx #$fc ;sp -3? (return addr, flags)
trap_ne
3c13 : d0fe > bne * ;failed not equal (non zero)
3c15 : adff01 lda $1ff ;propper return on stack
3c18 : c90d cmp #hi(brk_ret1)
trap_ne
3c1a : d0fe > bne * ;failed not equal (non zero)
3c1c : adfe01 lda $1fe
3c1f : c9f7 cmp #lo(brk_ret1)
trap_ne
3c21 : d0fe > bne * ;failed not equal (non zero)
load_flag intdis
3c23 : a904 > lda #intdis ;allow test to change I-flag (no mask)
3c25 : 48 pha
3c26 : a601 ldx irq_x
3c28 : e8 inx ;return registers with modifications
3c29 : a500 lda irq_a
3c2b : 49aa eor #$aa
3c2d : 28 plp ;N=0, V=0, Z=0, C=0 but original flags should be restored
3c2e : 40 rti
trap ;runover protection
3c2f : 4c2f3c > jmp * ;failed anyway
3c32 : 4c0008 jmp start ;catastrophic error - cannot continue
if report = 1
include "report.i65"
endif
;copy of data to initialize BSS segment
if load_data_direct != 1
zp_init
zp1_ db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR
zp7f_ db $7f ;test pattern for compare
;logical zeropage operands
zpOR_ db 0,$1f,$71,$80 ;test pattern for OR
zpAN_ db $0f,$ff,$7f,$80 ;test pattern for AND
zpEO_ db $ff,$0f,$8f,$8f ;test pattern for EOR
;indirect addressing pointers
ind1_ dw abs1 ;indirect pointer to pattern in absolute memory
dw abs1+1
dw abs1+2
dw abs1+3
dw abs7f
inw1_ dw abs1-$f8 ;indirect pointer for wrap-test pattern
indt_ dw abst ;indirect pointer to store area in absolute memory
dw abst+1
dw abst+2
dw abst+3
inwt_ dw abst-$f8 ;indirect pointer for wrap-test store
indAN_ dw absAN ;indirect pointer to AND pattern in absolute memory
dw absAN+1
dw absAN+2
dw absAN+3
indEO_ dw absEO ;indirect pointer to EOR pattern in absolute memory
dw absEO+1
dw absEO+2
dw absEO+3
indOR_ dw absOR ;indirect pointer to OR pattern in absolute memory
dw absOR+1
dw absOR+2
dw absOR+3
;add/subtract indirect pointers
adi2_ dw ada2 ;indirect pointer to operand 2 in absolute memory
sbi2_ dw sba2 ;indirect pointer to complemented operand 2 (SBC)
adiy2_ dw ada2-$ff ;with offset for indirect indexed
sbiy2_ dw sba2-$ff
zp_end
if (zp_end - zp_init) != (zp_bss_end - zp_bss)
;force assembler error if size is different
ERROR ERROR ERROR ;mismatch between bss and zeropage data
endif
data_init
ex_and_ and #0 ;execute immediate opcodes
rts
ex_eor_ eor #0 ;execute immediate opcodes
rts
ex_ora_ ora #0 ;execute immediate opcodes
rts
ex_adc_ adc #0 ;execute immediate opcodes
rts
ex_sbc_ sbc #0 ;execute immediate opcodes
rts
abs1_ db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR
abs7f_ db $7f ;test pattern for compare
;loads
fLDx_ db fn,fn,0,fz ;expected flags for load
;shifts
rASL_ ;expected result ASL & ROL -carry
rROL_ db $86,$04,$82,0 ; "
rROLc_ db $87,$05,$83,1 ;expected result ROL +carry
rLSR_ ;expected result LSR & ROR -carry
rROR_ db $61,$41,$20,0 ; "
rRORc_ db $e1,$c1,$a0,$80 ;expected result ROR +carry
fASL_ ;expected flags for shifts
fROL_ db fnc,fc,fn,fz ;no carry in
fROLc_ db fnc,fc,fn,0 ;carry in
fLSR_
fROR_ db fc,0,fc,fz ;no carry in
fRORc_ db fnc,fn,fnc,fn ;carry in
;increments (decrements)
rINC_ db $7f,$80,$ff,0,1 ;expected result for INC/DEC
fINC_ db 0,fn,fn,fz,0 ;expected flags for INC/DEC
;logical memory operand
absOR_ db 0,$1f,$71,$80 ;test pattern for OR
absAN_ db $0f,$ff,$7f,$80 ;test pattern for AND
absEO_ db $ff,$0f,$8f,$8f ;test pattern for EOR
;logical accu operand
absORa_ db 0,$f1,$1f,0 ;test pattern for OR
absANa_ db $f0,$ff,$ff,$ff ;test pattern for AND
absEOa_ db $ff,$f0,$f0,$0f ;test pattern for EOR
;logical results
absrlo_ db 0,$ff,$7f,$80
absflo_ db fz,fn,0,fn
data_end
if (data_end - data_init) != (data_bss_end - data_bss)
;force assembler error if size is different
ERROR ERROR ERROR ;mismatch between bss and data
endif
vec_init
dw nmi_trap
dw res_trap
dw irq_trap
vec_bss equ $fffa
endif ;end of RAM init data
if (load_data_direct = 1) & (ROM_vectors = 1)
fffa = org $fffa ;vectors
fffa : 9d3b dw nmi_trap
fffc : a33b dw res_trap
fffe : ab3b dw irq_trap
endif
fffa = end start
No errors in pass 2.
Wrote binary from address $0000 through $ffff.
Total size 65536 bytes.
Program start address is at $0800 (2048).
Reference in New Issue View Git Blame Copy Permalink