izapple2/core6502/testdata/65C02_extended_opcodes_test.lst
2019-10-11 00:06:42 +02:00

11510 lines
574 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
------------------------------------------------ 65C02_extended_opcodes_test.a65c ------------------------------------------------
2884 lines read, no errors in pass 1.
;
; 6 5 C 0 2 E X T E N D E D O P C O D E S T E S T
;
; Copyright (C) 2013-2017 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 additional 65C02 opcodes, addressing
; modes and functionality not available in the NMOS version of the 6502.
; The 6502_functional_test is a prerequisite to this test.
; NMI, IRQ, STP & WAI are covered in the 6502_interrupt_test.
;
; 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 -x -h0
; | | | | | no page headers in listing
; | | | | 65C02 extensions
; | | | 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 65C02 only!
; Decimal ops will only be tested with valid BCD operands and the V flag will
; be ignored as it is absolutely useless in decimal mode.
;
; 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:
; 19-jul-2013 1st version distributed for testing
; 23-jul-2013 fixed BRA out of range due to larger trap macros
; added RAM integrity check
; 16-aug-2013 added error report to standard output option
; 23-aug-2015 change revoked
; 24-aug-2015 all self modifying immediate opcodes now execute in data RAM
; 28-aug-2015 fixed decimal adc/sbc immediate only testing carry
; 09-feb-2017 fixed RMB/SMB tested when they shouldn't be tested
; 04-dec-2017 fixed BRK not tested for actually going through the IRQ vector
; added option to skip the remainder of a failing test
; in report.i65
; added skip override to undefined opcode as NOP test
; 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.
0003 = I_flag = 3
;configure memory - try to stay away from memory used by the system
;zero_page memory start address, $4e (78) consecutive Bytes required
; add 2 if I_flag = 2
000a = zero_page = $a
;data_segment memory start address, $63 (99) consecutive Bytes required
; + 12 Bytes at data_segment + $f9 (JMP indirect page cross test)
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, 10kB of consecutive space required
; add 1 kB if I_flag = 2
0400 = code_segment = $400
;added WDC only opcodes WAI & STP (0=test as NOPs, >0=no test)
0001 = wdc_op = 1
;added Rockwell & WDC opcodes BBR, BBS, RMB & SMB
;(0=test as NOPs, 1=full test, >1=no test)
0001 = rkwl_wdc_op = 1
;skip testing all undefined opcodes override
;0=test as NOP, >0=skip
0000 = skip_nop = 0
;report errors through I/O channel (0=use standard self trap loops, 1=include
;report.i65 as I/O channel, add 3 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
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
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 of interrupt enable/disable on load and compare
;masking of always on bits after PHP or BRK (unused & break) on compare
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
;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_as macro ;testing result in accu & flags, save accu
pha
php ;save flags
cmp #\1 ;test result
trap_ne
pla ;load status
pha
cmp_flag \2
trap_ne
plp ;restore status
pla
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
ldx #11 ;reset modifiable RAM
ccs1\? sta jxi_tab,x ;JMP indirect page cross area
dex
bpl ccs1\?
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
; org zero_page
0000 = org 0 ;edited to provide binaries loading from 0
0000 : 00000000000000.. ds zero_page
;break test interrupt save
000a : 00 irq_a ds 1 ;a register
000b : 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
000c : zpt ;5 bytes store/modify test area
;add/subtract operand generation and result/flag prediction
000c : 00 adfc ds 1 ;carry flag before op
000d : 00 ad1 ds 1 ;operand 1 - accumulator
000e : 00 ad2 ds 1 ;operand 2 - memory / immediate
000f : 00 adrl ds 1 ;expected result bits 0-7
0010 : 00 adrh ds 1 ;expected result bit 8 (carry)
0011 : 00 adrf ds 1 ;expected flags NV0000ZC (-V in decimal mode)
0012 : 00 sb2 ds 1 ;operand 2 complemented for subtract
0013 : zp_bss
0013 : c3824100 zp1 db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR
0017 : 7f zp7f db $7f ;test pattern for compare
;logical zeropage operands
0018 : 001f7180 zpOR db 0,$1f,$71,$80 ;test pattern for OR
001c : 0fff7f80 zpAN db $0f,$ff,$7f,$80 ;test pattern for AND
0020 : ff0f8f8f zpEO db $ff,$0f,$8f,$8f ;test pattern for EOR
;indirect addressing pointers
0024 : 1002 ind1 dw abs1 ;indirect pointer to pattern in absolute memory
0026 : 1102 dw abs1+1
0028 : 1202 dw abs1+2
002a : 1302 dw abs1+3
002c : 1402 dw abs7f
002e : 1801 inw1 dw abs1-$f8 ;indirect pointer for wrap-test pattern
0030 : 0502 indt dw abst ;indirect pointer to store area in absolute memory
0032 : 0602 dw abst+1
0034 : 0702 dw abst+2
0036 : 0802 dw abst+3
0038 : 0d01 inwt dw abst-$f8 ;indirect pointer for wrap-test store
003a : 4702 indAN dw absAN ;indirect pointer to AND pattern in absolute memory
003c : 4802 dw absAN+1
003e : 4902 dw absAN+2
0040 : 4a02 dw absAN+3
0042 : 4b02 indEO dw absEO ;indirect pointer to EOR pattern in absolute memory
0044 : 4c02 dw absEO+1
0046 : 4d02 dw absEO+2
0048 : 4e02 dw absEO+3
004a : 4302 indOR dw absOR ;indirect pointer to OR pattern in absolute memory
004c : 4402 dw absOR+1
004e : 4502 dw absOR+2
0050 : 4602 dw absOR+3
;add/subtract indirect pointers
0052 : 0502 adi2 dw ada2 ;indirect pointer to operand 2 in absolute memory
0054 : 0602 sbi2 dw sba2 ;indirect pointer to complemented operand 2 (SBC)
0056 : 0601 adiy2 dw ada2-$ff ;with offset for indirect indexed
0058 : 0701 sbiy2 dw sba2-$ff
005a : zp_bss_end
0200 = org data_segment
0200 : 0000 pg_x ds 2 ;high JMP indirect address for page cross bug
0202 : 00 test_case ds 1 ;current test number
0203 : 0000 ram_chksm ds 2 ;checksum for RAM integrity test
;add/subtract operand copy - abs tests write area
0205 : abst ;5 bytes store/modify test area
0205 : 00 ada2 ds 1 ;operand 2
0206 : 00 sba2 ds 1 ;operand 2 complemented for subtract
0207 : 000000 ds 3 ;fill remaining bytes
020a : data_bss
if load_data_direct = 1
020a : 6900 ex_adci adc #0 ;execute immediate opcodes
020c : 60 rts
020d : e900 ex_sbci sbc #0 ;execute immediate opcodes
020f : 60 rts
else
ex_adci ds 3
ex_sbci ds 3
endif
0210 : c3824100 abs1 db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR
0214 : 7f abs7f db $7f ;test pattern for compare
;loads
0215 : 80800002 fLDx db fn,fn,0,fz ;expected flags for load
;shifts
0219 : rASL ;expected result ASL & ROL -carry
0219 : 86048200 rROL db $86,$04,$82,0 ; "
021d : 87058301 rROLc db $87,$05,$83,1 ;expected result ROL +carry
0221 : rLSR ;expected result LSR & ROR -carry
0221 : 61412000 rROR db $61,$41,$20,0 ; "
0225 : e1c1a080 rRORc db $e1,$c1,$a0,$80 ;expected result ROR +carry
0229 : fASL ;expected flags for shifts
0229 : 81018002 fROL db fnc,fc,fn,fz ;no carry in
022d : 81018000 fROLc db fnc,fc,fn,0 ;carry in
0231 : fLSR
0231 : 01000102 fROR db fc,0,fc,fz ;no carry in
0235 : 81808180 fRORc db fnc,fn,fnc,fn ;carry in
;increments (decrements)
0239 : 7f80ff0001 rINC db $7f,$80,$ff,0,1 ;expected result for INC/DEC
023e : 0080800200 fINC db 0,fn,fn,fz,0 ;expected flags for INC/DEC
;logical memory operand
0243 : 001f7180 absOR db 0,$1f,$71,$80 ;test pattern for OR
0247 : 0fff7f80 absAN db $0f,$ff,$7f,$80 ;test pattern for AND
024b : ff0f8f8f absEO db $ff,$0f,$8f,$8f ;test pattern for EOR
;logical accu operand
024f : 00f11f00 absORa db 0,$f1,$1f,0 ;test pattern for OR
0253 : f0ffffff absANa db $f0,$ff,$ff,$ff ;test pattern for AND
0257 : fff0f00f absEOa db $ff,$f0,$f0,$0f ;test pattern for EOR
;logical results
025b : 00ff7f80 absrlo db 0,$ff,$7f,$80
025f : 02800080 absflo db fz,fn,0,fn
0263 : data_bss_end
;define area for page crossing JMP (abs) & JMP (abs,x) test
02f9 = jxi_tab equ data_segment + $100 - 7 ;JMP (jxi_tab,x) x=6
02fd = ji_tab equ data_segment + $100 - 3 ;JMP (ji_tab+2)
0300 = jxp_tab equ data_segment + $100 ;JMP (jxp_tab-255) x=255
code
0400 = org code_segment
0400 : d8 start cld
0401 : a2ff ldx #$ff
0403 : 9a txs
0404 : a900 lda #0 ;*** test 0 = initialize
0406 : 8d0202 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
;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
ldx #11 ;reset modifiable RAM
gcs1 sta jxi_tab,x ;JMP indirect page cross area
dex
bpl gcs1
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
0409 : ad0202 > lda test_case ;previous test
040c : c900 > cmp #test_num
> trap_ne ;test is out of sequence
040e : d0fe > bne * ;failed not equal (non zero)
>
0001 = >test_num = test_num + 1
0410 : a901 > lda #test_num ;*** next tests' number
0412 : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
;testing stack operations PHX PHY PLX PLY
0415 : a999 lda #$99 ;protect a
0417 : a2ff ldx #$ff ;initialize stack
0419 : 9a txs
041a : a255 ldx #$55
041c : da phx
041d : a2aa ldx #$aa
041f : da phx
0420 : ecfe01 cpx $1fe ;on stack ?
trap_ne
0423 : d0fe > bne * ;failed not equal (non zero)
0425 : ba tsx
0426 : e0fd cpx #$fd ;sp decremented?
trap_ne
0428 : d0fe > bne * ;failed not equal (non zero)
042a : 7a ply
042b : c0aa cpy #$aa ;successful retreived from stack?
trap_ne
042d : d0fe > bne * ;failed not equal (non zero)
042f : 7a ply
0430 : c055 cpy #$55
trap_ne
0432 : d0fe > bne * ;failed not equal (non zero)
0434 : ccff01 cpy $1ff ;remains on stack?
trap_ne
0437 : d0fe > bne * ;failed not equal (non zero)
0439 : ba tsx
043a : e0ff cpx #$ff ;sp incremented?
trap_ne
043c : d0fe > bne * ;failed not equal (non zero)
043e : a0a5 ldy #$a5
0440 : 5a phy
0441 : a05a ldy #$5a
0443 : 5a phy
0444 : ccfe01 cpy $1fe ;on stack ?
trap_ne
0447 : d0fe > bne * ;failed not equal (non zero)
0449 : ba tsx
044a : e0fd cpx #$fd ;sp decremented?
trap_ne
044c : d0fe > bne * ;failed not equal (non zero)
044e : fa plx
044f : e05a cpx #$5a ;successful retreived from stack?
trap_ne
0451 : d0fe > bne * ;failed not equal (non zero)
0453 : fa plx
0454 : e0a5 cpx #$a5
trap_ne
0456 : d0fe > bne * ;failed not equal (non zero)
0458 : ecff01 cpx $1ff ;remains on stack?
trap_ne
045b : d0fe > bne * ;failed not equal (non zero)
045d : ba tsx
045e : e0ff cpx #$ff ;sp incremented?
trap_ne
0460 : d0fe > bne * ;failed not equal (non zero)
0462 : c999 cmp #$99 ;unchanged?
trap_ne
0464 : d0fe > bne * ;failed not equal (non zero)
next_test
0466 : ad0202 > lda test_case ;previous test
0469 : c901 > cmp #test_num
> trap_ne ;test is out of sequence
046b : d0fe > bne * ;failed not equal (non zero)
>
0002 = >test_num = test_num + 1
046d : a902 > lda #test_num ;*** next tests' number
046f : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; test PHX does not alter flags or X but PLX does
0472 : a0aa ldy #$aa ;protect y
set_x 1,$ff ;push
> load_flag $ff
0474 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0476 : 48 > pha ;use stack to load status
0477 : a201 > ldx #1 ;precharge index x
0479 : 28 > plp
047a : da phx
tst_x 1,$ff
047b : 08 > php ;save flags
047c : e001 > cpx #1 ;test result
> trap_ne
047e : d0fe > bne * ;failed not equal (non zero)
>
0480 : 68 > pla ;load status
0481 : 48 > pha
> cmp_flag $ff
0482 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0484 : d0fe > bne * ;failed not equal (non zero)
>
0486 : 28 > plp ;restore status
set_x 0,0
> load_flag 0
0487 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0489 : 48 > pha ;use stack to load status
048a : a200 > ldx #0 ;precharge index x
048c : 28 > plp
048d : da phx
tst_x 0,0
048e : 08 > php ;save flags
048f : e000 > cpx #0 ;test result
> trap_ne
0491 : d0fe > bne * ;failed not equal (non zero)
>
0493 : 68 > pla ;load status
0494 : 48 > pha
> cmp_flag 0
0495 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0497 : d0fe > bne * ;failed not equal (non zero)
>
0499 : 28 > plp ;restore status
set_x $ff,$ff
> load_flag $ff
049a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
049c : 48 > pha ;use stack to load status
049d : a2ff > ldx #$ff ;precharge index x
049f : 28 > plp
04a0 : da phx
tst_x $ff,$ff
04a1 : 08 > php ;save flags
04a2 : e0ff > cpx #$ff ;test result
> trap_ne
04a4 : d0fe > bne * ;failed not equal (non zero)
>
04a6 : 68 > pla ;load status
04a7 : 48 > pha
> cmp_flag $ff
04a8 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
04aa : d0fe > bne * ;failed not equal (non zero)
>
04ac : 28 > plp ;restore status
set_x 1,0
> load_flag 0
04ad : a900 > lda #0 ;allow test to change I-flag (no mask)
>
04af : 48 > pha ;use stack to load status
04b0 : a201 > ldx #1 ;precharge index x
04b2 : 28 > plp
04b3 : da phx
tst_x 1,0
04b4 : 08 > php ;save flags
04b5 : e001 > cpx #1 ;test result
> trap_ne
04b7 : d0fe > bne * ;failed not equal (non zero)
>
04b9 : 68 > pla ;load status
04ba : 48 > pha
> cmp_flag 0
04bb : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
04bd : d0fe > bne * ;failed not equal (non zero)
>
04bf : 28 > plp ;restore status
set_x 0,$ff
> load_flag $ff
04c0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
04c2 : 48 > pha ;use stack to load status
04c3 : a200 > ldx #0 ;precharge index x
04c5 : 28 > plp
04c6 : da phx
tst_x 0,$ff
04c7 : 08 > php ;save flags
04c8 : e000 > cpx #0 ;test result
> trap_ne
04ca : d0fe > bne * ;failed not equal (non zero)
>
04cc : 68 > pla ;load status
04cd : 48 > pha
> cmp_flag $ff
04ce : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
04d0 : d0fe > bne * ;failed not equal (non zero)
>
04d2 : 28 > plp ;restore status
set_x $ff,0
> load_flag 0
04d3 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
04d5 : 48 > pha ;use stack to load status
04d6 : a2ff > ldx #$ff ;precharge index x
04d8 : 28 > plp
04d9 : da phx
tst_x $ff,0
04da : 08 > php ;save flags
04db : e0ff > cpx #$ff ;test result
> trap_ne
04dd : d0fe > bne * ;failed not equal (non zero)
>
04df : 68 > pla ;load status
04e0 : 48 > pha
> cmp_flag 0
04e1 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
04e3 : d0fe > bne * ;failed not equal (non zero)
>
04e5 : 28 > plp ;restore status
set_x 0,$ff ;pull
> load_flag $ff
04e6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
04e8 : 48 > pha ;use stack to load status
04e9 : a200 > ldx #0 ;precharge index x
04eb : 28 > plp
04ec : fa plx
tst_x $ff,$ff-zero
04ed : 08 > php ;save flags
04ee : e0ff > cpx #$ff ;test result
> trap_ne
04f0 : d0fe > bne * ;failed not equal (non zero)
>
04f2 : 68 > pla ;load status
04f3 : 48 > pha
> cmp_flag $ff-zero
04f4 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
04f6 : d0fe > bne * ;failed not equal (non zero)
>
04f8 : 28 > plp ;restore status
set_x $ff,0
> load_flag 0
04f9 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
04fb : 48 > pha ;use stack to load status
04fc : a2ff > ldx #$ff ;precharge index x
04fe : 28 > plp
04ff : fa plx
tst_x 0,zero
0500 : 08 > php ;save flags
0501 : e000 > cpx #0 ;test result
> trap_ne
0503 : d0fe > bne * ;failed not equal (non zero)
>
0505 : 68 > pla ;load status
0506 : 48 > pha
> cmp_flag zero
0507 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0509 : d0fe > bne * ;failed not equal (non zero)
>
050b : 28 > plp ;restore status
set_x $fe,$ff
> load_flag $ff
050c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
050e : 48 > pha ;use stack to load status
050f : a2fe > ldx #$fe ;precharge index x
0511 : 28 > plp
0512 : fa plx
tst_x 1,$ff-zero-minus
0513 : 08 > php ;save flags
0514 : e001 > cpx #1 ;test result
> trap_ne
0516 : d0fe > bne * ;failed not equal (non zero)
>
0518 : 68 > pla ;load status
0519 : 48 > pha
> cmp_flag $ff-zero-minus
051a : c97d > cmp #($ff-zero-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
051c : d0fe > bne * ;failed not equal (non zero)
>
051e : 28 > plp ;restore status
set_x 0,0
> load_flag 0
051f : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0521 : 48 > pha ;use stack to load status
0522 : a200 > ldx #0 ;precharge index x
0524 : 28 > plp
0525 : fa plx
tst_x $ff,minus
0526 : 08 > php ;save flags
0527 : e0ff > cpx #$ff ;test result
> trap_ne
0529 : d0fe > bne * ;failed not equal (non zero)
>
052b : 68 > pla ;load status
052c : 48 > pha
> cmp_flag minus
052d : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
052f : d0fe > bne * ;failed not equal (non zero)
>
0531 : 28 > plp ;restore status
set_x $ff,$ff
> load_flag $ff
0532 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0534 : 48 > pha ;use stack to load status
0535 : a2ff > ldx #$ff ;precharge index x
0537 : 28 > plp
0538 : fa plx
tst_x 0,$ff-minus
0539 : 08 > php ;save flags
053a : e000 > cpx #0 ;test result
> trap_ne
053c : d0fe > bne * ;failed not equal (non zero)
>
053e : 68 > pla ;load status
053f : 48 > pha
> cmp_flag $ff-minus
0540 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0542 : d0fe > bne * ;failed not equal (non zero)
>
0544 : 28 > plp ;restore status
set_x $fe,0
> load_flag 0
0545 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0547 : 48 > pha ;use stack to load status
0548 : a2fe > ldx #$fe ;precharge index x
054a : 28 > plp
054b : fa plx
tst_x 1,0
054c : 08 > php ;save flags
054d : e001 > cpx #1 ;test result
> trap_ne
054f : d0fe > bne * ;failed not equal (non zero)
>
0551 : 68 > pla ;load status
0552 : 48 > pha
> cmp_flag 0
0553 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0555 : d0fe > bne * ;failed not equal (non zero)
>
0557 : 28 > plp ;restore status
0558 : c0aa cpy #$aa ;Y unchanged
trap_ne
055a : d0fe > bne * ;failed not equal (non zero)
next_test
055c : ad0202 > lda test_case ;previous test
055f : c902 > cmp #test_num
> trap_ne ;test is out of sequence
0561 : d0fe > bne * ;failed not equal (non zero)
>
0003 = >test_num = test_num + 1
0563 : a903 > lda #test_num ;*** next tests' number
0565 : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; test PHY does not alter flags or Y but PLY does
0568 : a255 ldx #$55 ;x & a protected
set_y 1,$ff ;push
> load_flag $ff
056a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
056c : 48 > pha ;use stack to load status
056d : a001 > ldy #1 ;precharge index y
056f : 28 > plp
0570 : 5a phy
tst_y 1,$ff
0571 : 08 > php ;save flags
0572 : c001 > cpy #1 ;test result
> trap_ne
0574 : d0fe > bne * ;failed not equal (non zero)
>
0576 : 68 > pla ;load status
0577 : 48 > pha
> cmp_flag $ff
0578 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
057a : d0fe > bne * ;failed not equal (non zero)
>
057c : 28 > plp ;restore status
set_y 0,0
> load_flag 0
057d : a900 > lda #0 ;allow test to change I-flag (no mask)
>
057f : 48 > pha ;use stack to load status
0580 : a000 > ldy #0 ;precharge index y
0582 : 28 > plp
0583 : 5a phy
tst_y 0,0
0584 : 08 > php ;save flags
0585 : c000 > cpy #0 ;test result
> trap_ne
0587 : d0fe > bne * ;failed not equal (non zero)
>
0589 : 68 > pla ;load status
058a : 48 > pha
> cmp_flag 0
058b : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
058d : d0fe > bne * ;failed not equal (non zero)
>
058f : 28 > plp ;restore status
set_y $ff,$ff
> load_flag $ff
0590 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0592 : 48 > pha ;use stack to load status
0593 : a0ff > ldy #$ff ;precharge index y
0595 : 28 > plp
0596 : 5a phy
tst_y $ff,$ff
0597 : 08 > php ;save flags
0598 : c0ff > cpy #$ff ;test result
> trap_ne
059a : d0fe > bne * ;failed not equal (non zero)
>
059c : 68 > pla ;load status
059d : 48 > pha
> cmp_flag $ff
059e : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
05a0 : d0fe > bne * ;failed not equal (non zero)
>
05a2 : 28 > plp ;restore status
set_y 1,0
> load_flag 0
05a3 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
05a5 : 48 > pha ;use stack to load status
05a6 : a001 > ldy #1 ;precharge index y
05a8 : 28 > plp
05a9 : 5a phy
tst_y 1,0
05aa : 08 > php ;save flags
05ab : c001 > cpy #1 ;test result
> trap_ne
05ad : d0fe > bne * ;failed not equal (non zero)
>
05af : 68 > pla ;load status
05b0 : 48 > pha
> cmp_flag 0
05b1 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
05b3 : d0fe > bne * ;failed not equal (non zero)
>
05b5 : 28 > plp ;restore status
set_y 0,$ff
> load_flag $ff
05b6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
05b8 : 48 > pha ;use stack to load status
05b9 : a000 > ldy #0 ;precharge index y
05bb : 28 > plp
05bc : 5a phy
tst_y 0,$ff
05bd : 08 > php ;save flags
05be : c000 > cpy #0 ;test result
> trap_ne
05c0 : d0fe > bne * ;failed not equal (non zero)
>
05c2 : 68 > pla ;load status
05c3 : 48 > pha
> cmp_flag $ff
05c4 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
05c6 : d0fe > bne * ;failed not equal (non zero)
>
05c8 : 28 > plp ;restore status
set_y $ff,0
> load_flag 0
05c9 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
05cb : 48 > pha ;use stack to load status
05cc : a0ff > ldy #$ff ;precharge index y
05ce : 28 > plp
05cf : 5a phy
tst_y $ff,0
05d0 : 08 > php ;save flags
05d1 : c0ff > cpy #$ff ;test result
> trap_ne
05d3 : d0fe > bne * ;failed not equal (non zero)
>
05d5 : 68 > pla ;load status
05d6 : 48 > pha
> cmp_flag 0
05d7 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
05d9 : d0fe > bne * ;failed not equal (non zero)
>
05db : 28 > plp ;restore status
set_y 0,$ff ;pull
> load_flag $ff
05dc : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
05de : 48 > pha ;use stack to load status
05df : a000 > ldy #0 ;precharge index y
05e1 : 28 > plp
05e2 : 7a ply
tst_y $ff,$ff-zero
05e3 : 08 > php ;save flags
05e4 : c0ff > cpy #$ff ;test result
> trap_ne
05e6 : d0fe > bne * ;failed not equal (non zero)
>
05e8 : 68 > pla ;load status
05e9 : 48 > pha
> cmp_flag $ff-zero
05ea : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
05ec : d0fe > bne * ;failed not equal (non zero)
>
05ee : 28 > plp ;restore status
set_y $ff,0
> load_flag 0
05ef : a900 > lda #0 ;allow test to change I-flag (no mask)
>
05f1 : 48 > pha ;use stack to load status
05f2 : a0ff > ldy #$ff ;precharge index y
05f4 : 28 > plp
05f5 : 7a ply
tst_y 0,zero
05f6 : 08 > php ;save flags
05f7 : c000 > cpy #0 ;test result
> trap_ne
05f9 : d0fe > bne * ;failed not equal (non zero)
>
05fb : 68 > pla ;load status
05fc : 48 > pha
> cmp_flag zero
05fd : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
05ff : d0fe > bne * ;failed not equal (non zero)
>
0601 : 28 > plp ;restore status
set_y $fe,$ff
> load_flag $ff
0602 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0604 : 48 > pha ;use stack to load status
0605 : a0fe > ldy #$fe ;precharge index y
0607 : 28 > plp
0608 : 7a ply
tst_y 1,$ff-zero-minus
0609 : 08 > php ;save flags
060a : c001 > cpy #1 ;test result
> trap_ne
060c : d0fe > bne * ;failed not equal (non zero)
>
060e : 68 > pla ;load status
060f : 48 > pha
> cmp_flag $ff-zero-minus
0610 : c97d > cmp #($ff-zero-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0612 : d0fe > bne * ;failed not equal (non zero)
>
0614 : 28 > plp ;restore status
set_y 0,0
> load_flag 0
0615 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0617 : 48 > pha ;use stack to load status
0618 : a000 > ldy #0 ;precharge index y
061a : 28 > plp
061b : 7a ply
tst_y $ff,minus
061c : 08 > php ;save flags
061d : c0ff > cpy #$ff ;test result
> trap_ne
061f : d0fe > bne * ;failed not equal (non zero)
>
0621 : 68 > pla ;load status
0622 : 48 > pha
> cmp_flag minus
0623 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0625 : d0fe > bne * ;failed not equal (non zero)
>
0627 : 28 > plp ;restore status
set_y $ff,$ff
> load_flag $ff
0628 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
062a : 48 > pha ;use stack to load status
062b : a0ff > ldy #$ff ;precharge index y
062d : 28 > plp
062e : 7a ply
tst_y 0,$ff-minus
062f : 08 > php ;save flags
0630 : c000 > cpy #0 ;test result
> trap_ne
0632 : d0fe > bne * ;failed not equal (non zero)
>
0634 : 68 > pla ;load status
0635 : 48 > pha
> cmp_flag $ff-minus
0636 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0638 : d0fe > bne * ;failed not equal (non zero)
>
063a : 28 > plp ;restore status
set_y $fe,0
> load_flag 0
063b : a900 > lda #0 ;allow test to change I-flag (no mask)
>
063d : 48 > pha ;use stack to load status
063e : a0fe > ldy #$fe ;precharge index y
0640 : 28 > plp
0641 : 7a ply
tst_y 1,0
0642 : 08 > php ;save flags
0643 : c001 > cpy #1 ;test result
> trap_ne
0645 : d0fe > bne * ;failed not equal (non zero)
>
0647 : 68 > pla ;load status
0648 : 48 > pha
> cmp_flag 0
0649 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
064b : d0fe > bne * ;failed not equal (non zero)
>
064d : 28 > plp ;restore status
064e : e055 cpx #$55 ;x unchanged?
trap_ne
0650 : d0fe > bne * ;failed not equal (non zero)
next_test
0652 : ad0202 > lda test_case ;previous test
0655 : c903 > cmp #test_num
> trap_ne ;test is out of sequence
0657 : d0fe > bne * ;failed not equal (non zero)
>
0004 = >test_num = test_num + 1
0659 : a904 > lda #test_num ;*** next tests' number
065b : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; PC modifying instructions (BRA, BBR, BBS, 1, 2, 3 byte NOPs, JMP(abs,x))
; testing unconditional branch BRA
065e : a281 ldx #$81 ;protect unused registers
0660 : a07e ldy #$7e
set_a 0,$ff
> load_flag $ff
0662 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0664 : 48 > pha ;use stack to load status
0665 : a900 > lda #0 ;precharge accu
0667 : 28 > plp
0668 : 8003 bra br1 ;branch should always be taken
trap
066a : 4c6a06 > jmp * ;failed anyway
066d : br1
tst_a 0,$ff
066d : 08 > php ;save flags
066e : c900 > cmp #0 ;test result
> trap_ne
0670 : d0fe > bne * ;failed not equal (non zero)
>
0672 : 68 > pla ;load status
0673 : 48 > pha
> cmp_flag $ff
0674 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0676 : d0fe > bne * ;failed not equal (non zero)
>
0678 : 28 > plp ;restore status
set_a $ff,0
> load_flag 0
0679 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
067b : 48 > pha ;use stack to load status
067c : a9ff > lda #$ff ;precharge accu
067e : 28 > plp
067f : 8003 bra br2 ;branch should always be taken
trap
0681 : 4c8106 > jmp * ;failed anyway
0684 : br2
tst_a $ff,0
0684 : 08 > php ;save flags
0685 : c9ff > cmp #$ff ;test result
> trap_ne
0687 : d0fe > bne * ;failed not equal (non zero)
>
0689 : 68 > pla ;load status
068a : 48 > pha
> cmp_flag 0
068b : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
068d : d0fe > bne * ;failed not equal (non zero)
>
068f : 28 > plp ;restore status
0690 : e081 cpx #$81
trap_ne
0692 : d0fe > bne * ;failed not equal (non zero)
0694 : c07e cpy #$7e
trap_ne
0696 : d0fe > bne * ;failed not equal (non zero)
next_test
0698 : ad0202 > lda test_case ;previous test
069b : c904 > cmp #test_num
> trap_ne ;test is out of sequence
069d : d0fe > bne * ;failed not equal (non zero)
>
0005 = >test_num = test_num + 1
069f : a905 > lda #test_num ;*** next tests' number
06a1 : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
06a4 : a000 ldy #0 ;branch range test
06a6 : 8061 bra bra0
06a8 : c001 bra1 cpy #1
trap_ne ;long range backward
06aa : d0fe > bne * ;failed not equal (non zero)
06ac : c8 iny
06ad : 8053 bra bra2
06af : c003 bra3 cpy #3
trap_ne ;long range backward
06b1 : d0fe > bne * ;failed not equal (non zero)
06b3 : c8 iny
06b4 : 8045 bra bra4
06b6 : c005 bra5 cpy #5
trap_ne ;long range backward
06b8 : d0fe > bne * ;failed not equal (non zero)
06ba : c8 iny
06bb : a000 ldy #0
06bd : 8004 bra brf0
06bf : c8 iny
06c0 : c8 iny
06c1 : c8 iny
06c2 : c8 iny
06c3 : 8003 brf0 bra brf1
06c5 : c8 iny
06c6 : c8 iny
06c7 : c8 iny
06c8 : c8 brf1 iny
06c9 : 8002 bra brf2
06cb : c8 iny
06cc : c8 iny
06cd : c8 brf2 iny
06ce : c8 iny
06cf : 8001 bra brf3
06d1 : c8 iny
06d2 : c8 brf3 iny
06d3 : c8 iny
06d4 : c8 iny
06d5 : 8000 bra brf4
06d7 : c8 brf4 iny
06d8 : c8 iny
06d9 : c8 iny
06da : c8 iny
06db : c00a cpy #10
trap_ne ;short range forward
06dd : d0fe > bne * ;failed not equal (non zero)
06df : 8012 bra brb0
06e1 : 88 brb4 dey
06e2 : 88 dey
06e3 : 88 dey
06e4 : 88 dey
06e5 : 800e bra brb5
06e7 : 88 brb3 dey
06e8 : 88 dey
06e9 : 88 dey
06ea : 80f5 bra brb4
06ec : 88 brb2 dey
06ed : 88 dey
06ee : 80f7 bra brb3
06f0 : 88 brb1 dey
06f1 : 80f9 bra brb2
06f3 : 80fb brb0 bra brb1
06f5 : c000 brb5 cpy #0
trap_ne ;short range backward
06f7 : d0fe > bne * ;failed not equal (non zero)
06f9 : 8015 bra bra6
06fb : c004 bra4 cpy #4
trap_ne ;long range forward
06fd : d0fe > bne * ;failed not equal (non zero)
06ff : c8 iny
0700 : 80b4 bra bra5
0702 : c002 bra2 cpy #2
trap_ne ;long range forward
0704 : d0fe > bne * ;failed not equal (non zero)
0706 : c8 iny
0707 : 80a6 bra bra3
0709 : c000 bra0 cpy #0
trap_ne ;long range forward
070b : d0fe > bne * ;failed not equal (non zero)
070d : c8 iny
070e : 8098 bra bra1
0710 : bra6
next_test
0710 : ad0202 > lda test_case ;previous test
0713 : c905 > cmp #test_num
> trap_ne ;test is out of sequence
0715 : d0fe > bne * ;failed not equal (non zero)
>
0006 = >test_num = test_num + 1
0717 : a906 > lda #test_num ;*** next tests' number
0719 : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
if rkwl_wdc_op = 1
; testing BBR & BBS
bbt macro ;\1 = bitnum
lda #(1<<\1) ;testing 1 bit on
sta zpt
set_a $33,0 ;with flags off
bbr \1,zpt,fail1\?
bbs \1,zpt,ok1\?
trap ;bbs branch not taken
fail1\?
trap ;bbr branch taken
ok1\?
tst_a $33,0
set_a $cc,$ff ;with flags on
bbr \1,zpt,fail2\?
bbs \1,zpt,ok2\?
trap ;bbs branch not taken
fail2\?
trap ;bbr branch taken
ok2\?
tst_a $cc,$ff
lda zpt
cmp #(1<<\1)
trap_ne ;zp altered
lda #$ff-(1<<\1) ;testing 1 bit off
sta zpt
set_a $33,0 ;with flags off
bbs \1,zpt,fail3\?
bbr \1,zpt,ok3\?
trap ;bbr branch not taken
fail3\?
trap ;bbs branch taken
ok3\?
tst_a $33,0
set_a $cc,$ff ;with flags on
bbs \1,zpt,fail4\?
bbr \1,zpt,ok4\?
trap ;bbr branch not taken
fail4\?
trap ;bbs branch taken
ok4\?
tst_a $cc,$ff
lda zpt
cmp #$ff-(1<<\1)
trap_ne ;zp altered
endm
071c : a211 ldx #$11 ;test bbr/bbs integrity
071e : a022 ldy #$22
bbt 0
0720 : a901 > lda #(1<<0) ;testing 1 bit on
0722 : 850c > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
0724 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0726 : 48 > pha ;use stack to load status
0727 : a933 > lda #$33 ;precharge accu
0729 : 28 > plp
>
072a : 0f0c06 > bbr 0,zpt,fail10196
072d : 8f0c06 > bbs 0,zpt,ok10196
> trap ;bbs branch not taken
0730 : 4c3007 > jmp * ;failed anyway
>
0733 : >fail10196
> trap ;bbr branch taken
0733 : 4c3307 > jmp * ;failed anyway
>
0736 : >ok10196
> tst_a $33,0
0736 : 08 > php ;save flags
0737 : c933 > cmp #$33 ;test result
> trap_ne
0739 : d0fe > bne * ;failed not equal (non zero)
>
073b : 68 > pla ;load status
073c : 48 > pha
> cmp_flag 0
073d : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
073f : d0fe > bne * ;failed not equal (non zero)
>
0741 : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
0742 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0744 : 48 > pha ;use stack to load status
0745 : a9cc > lda #$cc ;precharge accu
0747 : 28 > plp
>
0748 : 0f0c06 > bbr 0,zpt,fail20196
074b : 8f0c06 > bbs 0,zpt,ok20196
> trap ;bbs branch not taken
074e : 4c4e07 > jmp * ;failed anyway
>
0751 : >fail20196
> trap ;bbr branch taken
0751 : 4c5107 > jmp * ;failed anyway
>
0754 : >ok20196
> tst_a $cc,$ff
0754 : 08 > php ;save flags
0755 : c9cc > cmp #$cc ;test result
> trap_ne
0757 : d0fe > bne * ;failed not equal (non zero)
>
0759 : 68 > pla ;load status
075a : 48 > pha
> cmp_flag $ff
075b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
075d : d0fe > bne * ;failed not equal (non zero)
>
075f : 28 > plp ;restore status
>
0760 : a50c > lda zpt
0762 : c901 > cmp #(1<<0)
> trap_ne ;zp altered
0764 : d0fe > bne * ;failed not equal (non zero)
>
0766 : a9fe > lda #$ff-(1<<0) ;testing 1 bit off
0768 : 850c > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
076a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
076c : 48 > pha ;use stack to load status
076d : a933 > lda #$33 ;precharge accu
076f : 28 > plp
>
0770 : 8f0c06 > bbs 0,zpt,fail30196
0773 : 0f0c06 > bbr 0,zpt,ok30196
> trap ;bbr branch not taken
0776 : 4c7607 > jmp * ;failed anyway
>
0779 : >fail30196
> trap ;bbs branch taken
0779 : 4c7907 > jmp * ;failed anyway
>
077c : >ok30196
> tst_a $33,0
077c : 08 > php ;save flags
077d : c933 > cmp #$33 ;test result
> trap_ne
077f : d0fe > bne * ;failed not equal (non zero)
>
0781 : 68 > pla ;load status
0782 : 48 > pha
> cmp_flag 0
0783 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0785 : d0fe > bne * ;failed not equal (non zero)
>
0787 : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
0788 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
078a : 48 > pha ;use stack to load status
078b : a9cc > lda #$cc ;precharge accu
078d : 28 > plp
>
078e : 8f0c06 > bbs 0,zpt,fail40196
0791 : 0f0c06 > bbr 0,zpt,ok40196
> trap ;bbr branch not taken
0794 : 4c9407 > jmp * ;failed anyway
>
0797 : >fail40196
> trap ;bbs branch taken
0797 : 4c9707 > jmp * ;failed anyway
>
079a : >ok40196
> tst_a $cc,$ff
079a : 08 > php ;save flags
079b : c9cc > cmp #$cc ;test result
> trap_ne
079d : d0fe > bne * ;failed not equal (non zero)
>
079f : 68 > pla ;load status
07a0 : 48 > pha
> cmp_flag $ff
07a1 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
07a3 : d0fe > bne * ;failed not equal (non zero)
>
07a5 : 28 > plp ;restore status
>
07a6 : a50c > lda zpt
07a8 : c9fe > cmp #$ff-(1<<0)
> trap_ne ;zp altered
07aa : d0fe > bne * ;failed not equal (non zero)
>
bbt 1
07ac : a902 > lda #(1<<1) ;testing 1 bit on
07ae : 850c > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
07b0 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
07b2 : 48 > pha ;use stack to load status
07b3 : a933 > lda #$33 ;precharge accu
07b5 : 28 > plp
>
07b6 : 1f0c06 > bbr 1,zpt,fail10231
07b9 : 9f0c06 > bbs 1,zpt,ok10231
> trap ;bbs branch not taken
07bc : 4cbc07 > jmp * ;failed anyway
>
07bf : >fail10231
> trap ;bbr branch taken
07bf : 4cbf07 > jmp * ;failed anyway
>
07c2 : >ok10231
> tst_a $33,0
07c2 : 08 > php ;save flags
07c3 : c933 > cmp #$33 ;test result
> trap_ne
07c5 : d0fe > bne * ;failed not equal (non zero)
>
07c7 : 68 > pla ;load status
07c8 : 48 > pha
> cmp_flag 0
07c9 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
07cb : d0fe > bne * ;failed not equal (non zero)
>
07cd : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
07ce : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
07d0 : 48 > pha ;use stack to load status
07d1 : a9cc > lda #$cc ;precharge accu
07d3 : 28 > plp
>
07d4 : 1f0c06 > bbr 1,zpt,fail20231
07d7 : 9f0c06 > bbs 1,zpt,ok20231
> trap ;bbs branch not taken
07da : 4cda07 > jmp * ;failed anyway
>
07dd : >fail20231
> trap ;bbr branch taken
07dd : 4cdd07 > jmp * ;failed anyway
>
07e0 : >ok20231
> tst_a $cc,$ff
07e0 : 08 > php ;save flags
07e1 : c9cc > cmp #$cc ;test result
> trap_ne
07e3 : d0fe > bne * ;failed not equal (non zero)
>
07e5 : 68 > pla ;load status
07e6 : 48 > pha
> cmp_flag $ff
07e7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
07e9 : d0fe > bne * ;failed not equal (non zero)
>
07eb : 28 > plp ;restore status
>
07ec : a50c > lda zpt
07ee : c902 > cmp #(1<<1)
> trap_ne ;zp altered
07f0 : d0fe > bne * ;failed not equal (non zero)
>
07f2 : a9fd > lda #$ff-(1<<1) ;testing 1 bit off
07f4 : 850c > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
07f6 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
07f8 : 48 > pha ;use stack to load status
07f9 : a933 > lda #$33 ;precharge accu
07fb : 28 > plp
>
07fc : 9f0c06 > bbs 1,zpt,fail30231
07ff : 1f0c06 > bbr 1,zpt,ok30231
> trap ;bbr branch not taken
0802 : 4c0208 > jmp * ;failed anyway
>
0805 : >fail30231
> trap ;bbs branch taken
0805 : 4c0508 > jmp * ;failed anyway
>
0808 : >ok30231
> tst_a $33,0
0808 : 08 > php ;save flags
0809 : c933 > cmp #$33 ;test result
> trap_ne
080b : d0fe > bne * ;failed not equal (non zero)
>
080d : 68 > pla ;load status
080e : 48 > pha
> cmp_flag 0
080f : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0811 : d0fe > bne * ;failed not equal (non zero)
>
0813 : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
0814 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0816 : 48 > pha ;use stack to load status
0817 : a9cc > lda #$cc ;precharge accu
0819 : 28 > plp
>
081a : 9f0c06 > bbs 1,zpt,fail40231
081d : 1f0c06 > bbr 1,zpt,ok40231
> trap ;bbr branch not taken
0820 : 4c2008 > jmp * ;failed anyway
>
0823 : >fail40231
> trap ;bbs branch taken
0823 : 4c2308 > jmp * ;failed anyway
>
0826 : >ok40231
> tst_a $cc,$ff
0826 : 08 > php ;save flags
0827 : c9cc > cmp #$cc ;test result
> trap_ne
0829 : d0fe > bne * ;failed not equal (non zero)
>
082b : 68 > pla ;load status
082c : 48 > pha
> cmp_flag $ff
082d : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
082f : d0fe > bne * ;failed not equal (non zero)
>
0831 : 28 > plp ;restore status
>
0832 : a50c > lda zpt
0834 : c9fd > cmp #$ff-(1<<1)
> trap_ne ;zp altered
0836 : d0fe > bne * ;failed not equal (non zero)
>
bbt 2
0838 : a904 > lda #(1<<2) ;testing 1 bit on
083a : 850c > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
083c : a900 > lda #0 ;allow test to change I-flag (no mask)
>
083e : 48 > pha ;use stack to load status
083f : a933 > lda #$33 ;precharge accu
0841 : 28 > plp
>
0842 : 2f0c06 > bbr 2,zpt,fail10266
0845 : af0c06 > bbs 2,zpt,ok10266
> trap ;bbs branch not taken
0848 : 4c4808 > jmp * ;failed anyway
>
084b : >fail10266
> trap ;bbr branch taken
084b : 4c4b08 > jmp * ;failed anyway
>
084e : >ok10266
> tst_a $33,0
084e : 08 > php ;save flags
084f : c933 > cmp #$33 ;test result
> trap_ne
0851 : d0fe > bne * ;failed not equal (non zero)
>
0853 : 68 > pla ;load status
0854 : 48 > pha
> cmp_flag 0
0855 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0857 : d0fe > bne * ;failed not equal (non zero)
>
0859 : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
085a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
085c : 48 > pha ;use stack to load status
085d : a9cc > lda #$cc ;precharge accu
085f : 28 > plp
>
0860 : 2f0c06 > bbr 2,zpt,fail20266
0863 : af0c06 > bbs 2,zpt,ok20266
> trap ;bbs branch not taken
0866 : 4c6608 > jmp * ;failed anyway
>
0869 : >fail20266
> trap ;bbr branch taken
0869 : 4c6908 > jmp * ;failed anyway
>
086c : >ok20266
> tst_a $cc,$ff
086c : 08 > php ;save flags
086d : c9cc > cmp #$cc ;test result
> trap_ne
086f : d0fe > bne * ;failed not equal (non zero)
>
0871 : 68 > pla ;load status
0872 : 48 > pha
> cmp_flag $ff
0873 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0875 : d0fe > bne * ;failed not equal (non zero)
>
0877 : 28 > plp ;restore status
>
0878 : a50c > lda zpt
087a : c904 > cmp #(1<<2)
> trap_ne ;zp altered
087c : d0fe > bne * ;failed not equal (non zero)
>
087e : a9fb > lda #$ff-(1<<2) ;testing 1 bit off
0880 : 850c > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
0882 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0884 : 48 > pha ;use stack to load status
0885 : a933 > lda #$33 ;precharge accu
0887 : 28 > plp
>
0888 : af0c06 > bbs 2,zpt,fail30266
088b : 2f0c06 > bbr 2,zpt,ok30266
> trap ;bbr branch not taken
088e : 4c8e08 > jmp * ;failed anyway
>
0891 : >fail30266
> trap ;bbs branch taken
0891 : 4c9108 > jmp * ;failed anyway
>
0894 : >ok30266
> tst_a $33,0
0894 : 08 > php ;save flags
0895 : c933 > cmp #$33 ;test result
> trap_ne
0897 : d0fe > bne * ;failed not equal (non zero)
>
0899 : 68 > pla ;load status
089a : 48 > pha
> cmp_flag 0
089b : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
089d : d0fe > bne * ;failed not equal (non zero)
>
089f : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
08a0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
08a2 : 48 > pha ;use stack to load status
08a3 : a9cc > lda #$cc ;precharge accu
08a5 : 28 > plp
>
08a6 : af0c06 > bbs 2,zpt,fail40266
08a9 : 2f0c06 > bbr 2,zpt,ok40266
> trap ;bbr branch not taken
08ac : 4cac08 > jmp * ;failed anyway
>
08af : >fail40266
> trap ;bbs branch taken
08af : 4caf08 > jmp * ;failed anyway
>
08b2 : >ok40266
> tst_a $cc,$ff
08b2 : 08 > php ;save flags
08b3 : c9cc > cmp #$cc ;test result
> trap_ne
08b5 : d0fe > bne * ;failed not equal (non zero)
>
08b7 : 68 > pla ;load status
08b8 : 48 > pha
> cmp_flag $ff
08b9 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
08bb : d0fe > bne * ;failed not equal (non zero)
>
08bd : 28 > plp ;restore status
>
08be : a50c > lda zpt
08c0 : c9fb > cmp #$ff-(1<<2)
> trap_ne ;zp altered
08c2 : d0fe > bne * ;failed not equal (non zero)
>
bbt 3
08c4 : a908 > lda #(1<<3) ;testing 1 bit on
08c6 : 850c > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
08c8 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
08ca : 48 > pha ;use stack to load status
08cb : a933 > lda #$33 ;precharge accu
08cd : 28 > plp
>
08ce : 3f0c06 > bbr 3,zpt,fail10301
08d1 : bf0c06 > bbs 3,zpt,ok10301
> trap ;bbs branch not taken
08d4 : 4cd408 > jmp * ;failed anyway
>
08d7 : >fail10301
> trap ;bbr branch taken
08d7 : 4cd708 > jmp * ;failed anyway
>
08da : >ok10301
> tst_a $33,0
08da : 08 > php ;save flags
08db : c933 > cmp #$33 ;test result
> trap_ne
08dd : d0fe > bne * ;failed not equal (non zero)
>
08df : 68 > pla ;load status
08e0 : 48 > pha
> cmp_flag 0
08e1 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
08e3 : d0fe > bne * ;failed not equal (non zero)
>
08e5 : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
08e6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
08e8 : 48 > pha ;use stack to load status
08e9 : a9cc > lda #$cc ;precharge accu
08eb : 28 > plp
>
08ec : 3f0c06 > bbr 3,zpt,fail20301
08ef : bf0c06 > bbs 3,zpt,ok20301
> trap ;bbs branch not taken
08f2 : 4cf208 > jmp * ;failed anyway
>
08f5 : >fail20301
> trap ;bbr branch taken
08f5 : 4cf508 > jmp * ;failed anyway
>
08f8 : >ok20301
> tst_a $cc,$ff
08f8 : 08 > php ;save flags
08f9 : c9cc > cmp #$cc ;test result
> trap_ne
08fb : d0fe > bne * ;failed not equal (non zero)
>
08fd : 68 > pla ;load status
08fe : 48 > pha
> cmp_flag $ff
08ff : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0901 : d0fe > bne * ;failed not equal (non zero)
>
0903 : 28 > plp ;restore status
>
0904 : a50c > lda zpt
0906 : c908 > cmp #(1<<3)
> trap_ne ;zp altered
0908 : d0fe > bne * ;failed not equal (non zero)
>
090a : a9f7 > lda #$ff-(1<<3) ;testing 1 bit off
090c : 850c > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
090e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0910 : 48 > pha ;use stack to load status
0911 : a933 > lda #$33 ;precharge accu
0913 : 28 > plp
>
0914 : bf0c06 > bbs 3,zpt,fail30301
0917 : 3f0c06 > bbr 3,zpt,ok30301
> trap ;bbr branch not taken
091a : 4c1a09 > jmp * ;failed anyway
>
091d : >fail30301
> trap ;bbs branch taken
091d : 4c1d09 > jmp * ;failed anyway
>
0920 : >ok30301
> tst_a $33,0
0920 : 08 > php ;save flags
0921 : c933 > cmp #$33 ;test result
> trap_ne
0923 : d0fe > bne * ;failed not equal (non zero)
>
0925 : 68 > pla ;load status
0926 : 48 > pha
> cmp_flag 0
0927 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0929 : d0fe > bne * ;failed not equal (non zero)
>
092b : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
092c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
092e : 48 > pha ;use stack to load status
092f : a9cc > lda #$cc ;precharge accu
0931 : 28 > plp
>
0932 : bf0c06 > bbs 3,zpt,fail40301
0935 : 3f0c06 > bbr 3,zpt,ok40301
> trap ;bbr branch not taken
0938 : 4c3809 > jmp * ;failed anyway
>
093b : >fail40301
> trap ;bbs branch taken
093b : 4c3b09 > jmp * ;failed anyway
>
093e : >ok40301
> tst_a $cc,$ff
093e : 08 > php ;save flags
093f : c9cc > cmp #$cc ;test result
> trap_ne
0941 : d0fe > bne * ;failed not equal (non zero)
>
0943 : 68 > pla ;load status
0944 : 48 > pha
> cmp_flag $ff
0945 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0947 : d0fe > bne * ;failed not equal (non zero)
>
0949 : 28 > plp ;restore status
>
094a : a50c > lda zpt
094c : c9f7 > cmp #$ff-(1<<3)
> trap_ne ;zp altered
094e : d0fe > bne * ;failed not equal (non zero)
>
bbt 4
0950 : a910 > lda #(1<<4) ;testing 1 bit on
0952 : 850c > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
0954 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0956 : 48 > pha ;use stack to load status
0957 : a933 > lda #$33 ;precharge accu
0959 : 28 > plp
>
095a : 4f0c06 > bbr 4,zpt,fail10336
095d : cf0c06 > bbs 4,zpt,ok10336
> trap ;bbs branch not taken
0960 : 4c6009 > jmp * ;failed anyway
>
0963 : >fail10336
> trap ;bbr branch taken
0963 : 4c6309 > jmp * ;failed anyway
>
0966 : >ok10336
> tst_a $33,0
0966 : 08 > php ;save flags
0967 : c933 > cmp #$33 ;test result
> trap_ne
0969 : d0fe > bne * ;failed not equal (non zero)
>
096b : 68 > pla ;load status
096c : 48 > pha
> cmp_flag 0
096d : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
096f : d0fe > bne * ;failed not equal (non zero)
>
0971 : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
0972 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0974 : 48 > pha ;use stack to load status
0975 : a9cc > lda #$cc ;precharge accu
0977 : 28 > plp
>
0978 : 4f0c06 > bbr 4,zpt,fail20336
097b : cf0c06 > bbs 4,zpt,ok20336
> trap ;bbs branch not taken
097e : 4c7e09 > jmp * ;failed anyway
>
0981 : >fail20336
> trap ;bbr branch taken
0981 : 4c8109 > jmp * ;failed anyway
>
0984 : >ok20336
> tst_a $cc,$ff
0984 : 08 > php ;save flags
0985 : c9cc > cmp #$cc ;test result
> trap_ne
0987 : d0fe > bne * ;failed not equal (non zero)
>
0989 : 68 > pla ;load status
098a : 48 > pha
> cmp_flag $ff
098b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
098d : d0fe > bne * ;failed not equal (non zero)
>
098f : 28 > plp ;restore status
>
0990 : a50c > lda zpt
0992 : c910 > cmp #(1<<4)
> trap_ne ;zp altered
0994 : d0fe > bne * ;failed not equal (non zero)
>
0996 : a9ef > lda #$ff-(1<<4) ;testing 1 bit off
0998 : 850c > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
099a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
099c : 48 > pha ;use stack to load status
099d : a933 > lda #$33 ;precharge accu
099f : 28 > plp
>
09a0 : cf0c06 > bbs 4,zpt,fail30336
09a3 : 4f0c06 > bbr 4,zpt,ok30336
> trap ;bbr branch not taken
09a6 : 4ca609 > jmp * ;failed anyway
>
09a9 : >fail30336
> trap ;bbs branch taken
09a9 : 4ca909 > jmp * ;failed anyway
>
09ac : >ok30336
> tst_a $33,0
09ac : 08 > php ;save flags
09ad : c933 > cmp #$33 ;test result
> trap_ne
09af : d0fe > bne * ;failed not equal (non zero)
>
09b1 : 68 > pla ;load status
09b2 : 48 > pha
> cmp_flag 0
09b3 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
09b5 : d0fe > bne * ;failed not equal (non zero)
>
09b7 : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
09b8 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
09ba : 48 > pha ;use stack to load status
09bb : a9cc > lda #$cc ;precharge accu
09bd : 28 > plp
>
09be : cf0c06 > bbs 4,zpt,fail40336
09c1 : 4f0c06 > bbr 4,zpt,ok40336
> trap ;bbr branch not taken
09c4 : 4cc409 > jmp * ;failed anyway
>
09c7 : >fail40336
> trap ;bbs branch taken
09c7 : 4cc709 > jmp * ;failed anyway
>
09ca : >ok40336
> tst_a $cc,$ff
09ca : 08 > php ;save flags
09cb : c9cc > cmp #$cc ;test result
> trap_ne
09cd : d0fe > bne * ;failed not equal (non zero)
>
09cf : 68 > pla ;load status
09d0 : 48 > pha
> cmp_flag $ff
09d1 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
09d3 : d0fe > bne * ;failed not equal (non zero)
>
09d5 : 28 > plp ;restore status
>
09d6 : a50c > lda zpt
09d8 : c9ef > cmp #$ff-(1<<4)
> trap_ne ;zp altered
09da : d0fe > bne * ;failed not equal (non zero)
>
bbt 5
09dc : a920 > lda #(1<<5) ;testing 1 bit on
09de : 850c > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
09e0 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
09e2 : 48 > pha ;use stack to load status
09e3 : a933 > lda #$33 ;precharge accu
09e5 : 28 > plp
>
09e6 : 5f0c06 > bbr 5,zpt,fail10371
09e9 : df0c06 > bbs 5,zpt,ok10371
> trap ;bbs branch not taken
09ec : 4cec09 > jmp * ;failed anyway
>
09ef : >fail10371
> trap ;bbr branch taken
09ef : 4cef09 > jmp * ;failed anyway
>
09f2 : >ok10371
> tst_a $33,0
09f2 : 08 > php ;save flags
09f3 : c933 > cmp #$33 ;test result
> trap_ne
09f5 : d0fe > bne * ;failed not equal (non zero)
>
09f7 : 68 > pla ;load status
09f8 : 48 > pha
> cmp_flag 0
09f9 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
09fb : d0fe > bne * ;failed not equal (non zero)
>
09fd : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
09fe : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0a00 : 48 > pha ;use stack to load status
0a01 : a9cc > lda #$cc ;precharge accu
0a03 : 28 > plp
>
0a04 : 5f0c06 > bbr 5,zpt,fail20371
0a07 : df0c06 > bbs 5,zpt,ok20371
> trap ;bbs branch not taken
0a0a : 4c0a0a > jmp * ;failed anyway
>
0a0d : >fail20371
> trap ;bbr branch taken
0a0d : 4c0d0a > jmp * ;failed anyway
>
0a10 : >ok20371
> tst_a $cc,$ff
0a10 : 08 > php ;save flags
0a11 : c9cc > cmp #$cc ;test result
> trap_ne
0a13 : d0fe > bne * ;failed not equal (non zero)
>
0a15 : 68 > pla ;load status
0a16 : 48 > pha
> cmp_flag $ff
0a17 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0a19 : d0fe > bne * ;failed not equal (non zero)
>
0a1b : 28 > plp ;restore status
>
0a1c : a50c > lda zpt
0a1e : c920 > cmp #(1<<5)
> trap_ne ;zp altered
0a20 : d0fe > bne * ;failed not equal (non zero)
>
0a22 : a9df > lda #$ff-(1<<5) ;testing 1 bit off
0a24 : 850c > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
0a26 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0a28 : 48 > pha ;use stack to load status
0a29 : a933 > lda #$33 ;precharge accu
0a2b : 28 > plp
>
0a2c : df0c06 > bbs 5,zpt,fail30371
0a2f : 5f0c06 > bbr 5,zpt,ok30371
> trap ;bbr branch not taken
0a32 : 4c320a > jmp * ;failed anyway
>
0a35 : >fail30371
> trap ;bbs branch taken
0a35 : 4c350a > jmp * ;failed anyway
>
0a38 : >ok30371
> tst_a $33,0
0a38 : 08 > php ;save flags
0a39 : c933 > cmp #$33 ;test result
> trap_ne
0a3b : d0fe > bne * ;failed not equal (non zero)
>
0a3d : 68 > pla ;load status
0a3e : 48 > pha
> cmp_flag 0
0a3f : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0a41 : d0fe > bne * ;failed not equal (non zero)
>
0a43 : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
0a44 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0a46 : 48 > pha ;use stack to load status
0a47 : a9cc > lda #$cc ;precharge accu
0a49 : 28 > plp
>
0a4a : df0c06 > bbs 5,zpt,fail40371
0a4d : 5f0c06 > bbr 5,zpt,ok40371
> trap ;bbr branch not taken
0a50 : 4c500a > jmp * ;failed anyway
>
0a53 : >fail40371
> trap ;bbs branch taken
0a53 : 4c530a > jmp * ;failed anyway
>
0a56 : >ok40371
> tst_a $cc,$ff
0a56 : 08 > php ;save flags
0a57 : c9cc > cmp #$cc ;test result
> trap_ne
0a59 : d0fe > bne * ;failed not equal (non zero)
>
0a5b : 68 > pla ;load status
0a5c : 48 > pha
> cmp_flag $ff
0a5d : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0a5f : d0fe > bne * ;failed not equal (non zero)
>
0a61 : 28 > plp ;restore status
>
0a62 : a50c > lda zpt
0a64 : c9df > cmp #$ff-(1<<5)
> trap_ne ;zp altered
0a66 : d0fe > bne * ;failed not equal (non zero)
>
bbt 6
0a68 : a940 > lda #(1<<6) ;testing 1 bit on
0a6a : 850c > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
0a6c : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0a6e : 48 > pha ;use stack to load status
0a6f : a933 > lda #$33 ;precharge accu
0a71 : 28 > plp
>
0a72 : 6f0c06 > bbr 6,zpt,fail10406
0a75 : ef0c06 > bbs 6,zpt,ok10406
> trap ;bbs branch not taken
0a78 : 4c780a > jmp * ;failed anyway
>
0a7b : >fail10406
> trap ;bbr branch taken
0a7b : 4c7b0a > jmp * ;failed anyway
>
0a7e : >ok10406
> tst_a $33,0
0a7e : 08 > php ;save flags
0a7f : c933 > cmp #$33 ;test result
> trap_ne
0a81 : d0fe > bne * ;failed not equal (non zero)
>
0a83 : 68 > pla ;load status
0a84 : 48 > pha
> cmp_flag 0
0a85 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0a87 : d0fe > bne * ;failed not equal (non zero)
>
0a89 : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
0a8a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0a8c : 48 > pha ;use stack to load status
0a8d : a9cc > lda #$cc ;precharge accu
0a8f : 28 > plp
>
0a90 : 6f0c06 > bbr 6,zpt,fail20406
0a93 : ef0c06 > bbs 6,zpt,ok20406
> trap ;bbs branch not taken
0a96 : 4c960a > jmp * ;failed anyway
>
0a99 : >fail20406
> trap ;bbr branch taken
0a99 : 4c990a > jmp * ;failed anyway
>
0a9c : >ok20406
> tst_a $cc,$ff
0a9c : 08 > php ;save flags
0a9d : c9cc > cmp #$cc ;test result
> trap_ne
0a9f : d0fe > bne * ;failed not equal (non zero)
>
0aa1 : 68 > pla ;load status
0aa2 : 48 > pha
> cmp_flag $ff
0aa3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0aa5 : d0fe > bne * ;failed not equal (non zero)
>
0aa7 : 28 > plp ;restore status
>
0aa8 : a50c > lda zpt
0aaa : c940 > cmp #(1<<6)
> trap_ne ;zp altered
0aac : d0fe > bne * ;failed not equal (non zero)
>
0aae : a9bf > lda #$ff-(1<<6) ;testing 1 bit off
0ab0 : 850c > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
0ab2 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0ab4 : 48 > pha ;use stack to load status
0ab5 : a933 > lda #$33 ;precharge accu
0ab7 : 28 > plp
>
0ab8 : ef0c06 > bbs 6,zpt,fail30406
0abb : 6f0c06 > bbr 6,zpt,ok30406
> trap ;bbr branch not taken
0abe : 4cbe0a > jmp * ;failed anyway
>
0ac1 : >fail30406
> trap ;bbs branch taken
0ac1 : 4cc10a > jmp * ;failed anyway
>
0ac4 : >ok30406
> tst_a $33,0
0ac4 : 08 > php ;save flags
0ac5 : c933 > cmp #$33 ;test result
> trap_ne
0ac7 : d0fe > bne * ;failed not equal (non zero)
>
0ac9 : 68 > pla ;load status
0aca : 48 > pha
> cmp_flag 0
0acb : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0acd : d0fe > bne * ;failed not equal (non zero)
>
0acf : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
0ad0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0ad2 : 48 > pha ;use stack to load status
0ad3 : a9cc > lda #$cc ;precharge accu
0ad5 : 28 > plp
>
0ad6 : ef0c06 > bbs 6,zpt,fail40406
0ad9 : 6f0c06 > bbr 6,zpt,ok40406
> trap ;bbr branch not taken
0adc : 4cdc0a > jmp * ;failed anyway
>
0adf : >fail40406
> trap ;bbs branch taken
0adf : 4cdf0a > jmp * ;failed anyway
>
0ae2 : >ok40406
> tst_a $cc,$ff
0ae2 : 08 > php ;save flags
0ae3 : c9cc > cmp #$cc ;test result
> trap_ne
0ae5 : d0fe > bne * ;failed not equal (non zero)
>
0ae7 : 68 > pla ;load status
0ae8 : 48 > pha
> cmp_flag $ff
0ae9 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0aeb : d0fe > bne * ;failed not equal (non zero)
>
0aed : 28 > plp ;restore status
>
0aee : a50c > lda zpt
0af0 : c9bf > cmp #$ff-(1<<6)
> trap_ne ;zp altered
0af2 : d0fe > bne * ;failed not equal (non zero)
>
bbt 7
0af4 : a980 > lda #(1<<7) ;testing 1 bit on
0af6 : 850c > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
0af8 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0afa : 48 > pha ;use stack to load status
0afb : a933 > lda #$33 ;precharge accu
0afd : 28 > plp
>
0afe : 7f0c06 > bbr 7,zpt,fail10441
0b01 : ff0c06 > bbs 7,zpt,ok10441
> trap ;bbs branch not taken
0b04 : 4c040b > jmp * ;failed anyway
>
0b07 : >fail10441
> trap ;bbr branch taken
0b07 : 4c070b > jmp * ;failed anyway
>
0b0a : >ok10441
> tst_a $33,0
0b0a : 08 > php ;save flags
0b0b : c933 > cmp #$33 ;test result
> trap_ne
0b0d : d0fe > bne * ;failed not equal (non zero)
>
0b0f : 68 > pla ;load status
0b10 : 48 > pha
> cmp_flag 0
0b11 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0b13 : d0fe > bne * ;failed not equal (non zero)
>
0b15 : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
0b16 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0b18 : 48 > pha ;use stack to load status
0b19 : a9cc > lda #$cc ;precharge accu
0b1b : 28 > plp
>
0b1c : 7f0c06 > bbr 7,zpt,fail20441
0b1f : ff0c06 > bbs 7,zpt,ok20441
> trap ;bbs branch not taken
0b22 : 4c220b > jmp * ;failed anyway
>
0b25 : >fail20441
> trap ;bbr branch taken
0b25 : 4c250b > jmp * ;failed anyway
>
0b28 : >ok20441
> tst_a $cc,$ff
0b28 : 08 > php ;save flags
0b29 : c9cc > cmp #$cc ;test result
> trap_ne
0b2b : d0fe > bne * ;failed not equal (non zero)
>
0b2d : 68 > pla ;load status
0b2e : 48 > pha
> cmp_flag $ff
0b2f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0b31 : d0fe > bne * ;failed not equal (non zero)
>
0b33 : 28 > plp ;restore status
>
0b34 : a50c > lda zpt
0b36 : c980 > cmp #(1<<7)
> trap_ne ;zp altered
0b38 : d0fe > bne * ;failed not equal (non zero)
>
0b3a : a97f > lda #$ff-(1<<7) ;testing 1 bit off
0b3c : 850c > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
0b3e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0b40 : 48 > pha ;use stack to load status
0b41 : a933 > lda #$33 ;precharge accu
0b43 : 28 > plp
>
0b44 : ff0c06 > bbs 7,zpt,fail30441
0b47 : 7f0c06 > bbr 7,zpt,ok30441
> trap ;bbr branch not taken
0b4a : 4c4a0b > jmp * ;failed anyway
>
0b4d : >fail30441
> trap ;bbs branch taken
0b4d : 4c4d0b > jmp * ;failed anyway
>
0b50 : >ok30441
> tst_a $33,0
0b50 : 08 > php ;save flags
0b51 : c933 > cmp #$33 ;test result
> trap_ne
0b53 : d0fe > bne * ;failed not equal (non zero)
>
0b55 : 68 > pla ;load status
0b56 : 48 > pha
> cmp_flag 0
0b57 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0b59 : d0fe > bne * ;failed not equal (non zero)
>
0b5b : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
0b5c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0b5e : 48 > pha ;use stack to load status
0b5f : a9cc > lda #$cc ;precharge accu
0b61 : 28 > plp
>
0b62 : ff0c06 > bbs 7,zpt,fail40441
0b65 : 7f0c06 > bbr 7,zpt,ok40441
> trap ;bbr branch not taken
0b68 : 4c680b > jmp * ;failed anyway
>
0b6b : >fail40441
> trap ;bbs branch taken
0b6b : 4c6b0b > jmp * ;failed anyway
>
0b6e : >ok40441
> tst_a $cc,$ff
0b6e : 08 > php ;save flags
0b6f : c9cc > cmp #$cc ;test result
> trap_ne
0b71 : d0fe > bne * ;failed not equal (non zero)
>
0b73 : 68 > pla ;load status
0b74 : 48 > pha
> cmp_flag $ff
0b75 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0b77 : d0fe > bne * ;failed not equal (non zero)
>
0b79 : 28 > plp ;restore status
>
0b7a : a50c > lda zpt
0b7c : c97f > cmp #$ff-(1<<7)
> trap_ne ;zp altered
0b7e : d0fe > bne * ;failed not equal (non zero)
>
0b80 : e011 cpx #$11
trap_ne ;x overwritten
0b82 : d0fe > bne * ;failed not equal (non zero)
0b84 : c022 cpy #$22
trap_ne ;y overwritten
0b86 : d0fe > bne * ;failed not equal (non zero)
next_test
0b88 : ad0202 > lda test_case ;previous test
0b8b : c906 > cmp #test_num
> trap_ne ;test is out of sequence
0b8d : d0fe > bne * ;failed not equal (non zero)
>
0007 = >test_num = test_num + 1
0b8f : a907 > lda #test_num ;*** next tests' number
0b91 : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
bbrc macro ;\1 = bitnum
bbr \1,zpt,skip\?
eor #(1<<\1)
skip\?
endm
bbsc macro ;\1 = bitnum
bbs \1,zpt,skip\?
eor #(1<<\1)
skip\?
endm
0b94 : a900 lda #0 ;combined bit test
0b96 : 850c sta zpt
0b98 : a900 bbcl lda #0
bbrc 0
0b9a : 0f0c02 > bbr 0,zpt,skip0480
0b9d : 4901 > eor #(1<<0)
0b9f : >skip0480
bbrc 1
0b9f : 1f0c02 > bbr 1,zpt,skip0481
0ba2 : 4902 > eor #(1<<1)
0ba4 : >skip0481
bbrc 2
0ba4 : 2f0c02 > bbr 2,zpt,skip0482
0ba7 : 4904 > eor #(1<<2)
0ba9 : >skip0482
bbrc 3
0ba9 : 3f0c02 > bbr 3,zpt,skip0483
0bac : 4908 > eor #(1<<3)
0bae : >skip0483
bbrc 4
0bae : 4f0c02 > bbr 4,zpt,skip0484
0bb1 : 4910 > eor #(1<<4)
0bb3 : >skip0484
bbrc 5
0bb3 : 5f0c02 > bbr 5,zpt,skip0485
0bb6 : 4920 > eor #(1<<5)
0bb8 : >skip0485
bbrc 6
0bb8 : 6f0c02 > bbr 6,zpt,skip0486
0bbb : 4940 > eor #(1<<6)
0bbd : >skip0486
bbrc 7
0bbd : 7f0c02 > bbr 7,zpt,skip0487
0bc0 : 4980 > eor #(1<<7)
0bc2 : >skip0487
0bc2 : 450c eor zpt
trap_ne ;failed bbr bitnum in accu
0bc4 : d0fe > bne * ;failed not equal (non zero)
0bc6 : a9ff lda #$ff
bbsc 0
0bc8 : 8f0c02 > bbs 0,zpt,skip0489
0bcb : 4901 > eor #(1<<0)
0bcd : >skip0489
bbsc 1
0bcd : 9f0c02 > bbs 1,zpt,skip0490
0bd0 : 4902 > eor #(1<<1)
0bd2 : >skip0490
bbsc 2
0bd2 : af0c02 > bbs 2,zpt,skip0491
0bd5 : 4904 > eor #(1<<2)
0bd7 : >skip0491
bbsc 3
0bd7 : bf0c02 > bbs 3,zpt,skip0492
0bda : 4908 > eor #(1<<3)
0bdc : >skip0492
bbsc 4
0bdc : cf0c02 > bbs 4,zpt,skip0493
0bdf : 4910 > eor #(1<<4)
0be1 : >skip0493
bbsc 5
0be1 : df0c02 > bbs 5,zpt,skip0494
0be4 : 4920 > eor #(1<<5)
0be6 : >skip0494
bbsc 6
0be6 : ef0c02 > bbs 6,zpt,skip0495
0be9 : 4940 > eor #(1<<6)
0beb : >skip0495
bbsc 7
0beb : ff0c02 > bbs 7,zpt,skip0496
0bee : 4980 > eor #(1<<7)
0bf0 : >skip0496
0bf0 : 450c eor zpt
trap_ne ;failed bbs bitnum in accu
0bf2 : d0fe > bne * ;failed not equal (non zero)
0bf4 : e60c inc zpt
0bf6 : d0a0 bne bbcl
next_test
0bf8 : ad0202 > lda test_case ;previous test
0bfb : c907 > cmp #test_num
> trap_ne ;test is out of sequence
0bfd : d0fe > bne * ;failed not equal (non zero)
>
0008 = >test_num = test_num + 1
0bff : a908 > lda #test_num ;*** next tests' number
0c01 : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
endif
; testing NOP
nop_test macro ;\1 = opcode, \2 = # of bytes
ldy #$42
ldx #4-\2
db \1 ;test nop length
if \2 = 1
dex
dex
endif
if \2 = 2
iny
dex
endif
if \2 = 3
iny
iny
endif
dex
trap_ne ;wrong number of bytes
set_a $ff-\1,0
db \1 ;test nop integrity - flags off
nop
nop
tst_a $ff-\1,0
set_a $aa-\1,$ff
db \1 ;test nop integrity - flags on
nop
nop
tst_a $aa-\1,$ff
cpy #$42
trap_ne ;y changed
cpx #0
trap_ne ;x changed
endm
if skip_nop = 0
nop_test $02,2
0c04 : a042 > ldy #$42
0c06 : a202 > ldx #4-2
0c08 : 02 > db $02 ;test nop length
> if 2 = 1
> dex
> dex
> endif
> if 2 = 2
0c09 : c8 > iny
0c0a : ca > dex
> endif
> if 2 = 3
> iny
> iny
> endif
0c0b : ca > dex
> trap_ne ;wrong number of bytes
0c0c : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$02,0
> load_flag 0
0c0e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0c10 : 48 > pha ;use stack to load status
0c11 : a9fd > lda #$ff-$02 ;precharge accu
0c13 : 28 > plp
>
0c14 : 02 > db $02 ;test nop integrity - flags off
0c15 : ea > nop
0c16 : ea > nop
> tst_a $ff-$02,0
0c17 : 08 > php ;save flags
0c18 : c9fd > cmp #$ff-$02 ;test result
> trap_ne
0c1a : d0fe > bne * ;failed not equal (non zero)
>
0c1c : 68 > pla ;load status
0c1d : 48 > pha
> cmp_flag 0
0c1e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0c20 : d0fe > bne * ;failed not equal (non zero)
>
0c22 : 28 > plp ;restore status
>
> set_a $aa-$02,$ff
> load_flag $ff
0c23 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0c25 : 48 > pha ;use stack to load status
0c26 : a9a8 > lda #$aa-$02 ;precharge accu
0c28 : 28 > plp
>
0c29 : 02 > db $02 ;test nop integrity - flags on
0c2a : ea > nop
0c2b : ea > nop
> tst_a $aa-$02,$ff
0c2c : 08 > php ;save flags
0c2d : c9a8 > cmp #$aa-$02 ;test result
> trap_ne
0c2f : d0fe > bne * ;failed not equal (non zero)
>
0c31 : 68 > pla ;load status
0c32 : 48 > pha
> cmp_flag $ff
0c33 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0c35 : d0fe > bne * ;failed not equal (non zero)
>
0c37 : 28 > plp ;restore status
>
0c38 : c042 > cpy #$42
> trap_ne ;y changed
0c3a : d0fe > bne * ;failed not equal (non zero)
>
0c3c : e000 > cpx #0
> trap_ne ;x changed
0c3e : d0fe > bne * ;failed not equal (non zero)
>
nop_test $22,2
0c40 : a042 > ldy #$42
0c42 : a202 > ldx #4-2
0c44 : 22 > db $22 ;test nop length
> if 2 = 1
> dex
> dex
> endif
> if 2 = 2
0c45 : c8 > iny
0c46 : ca > dex
> endif
> if 2 = 3
> iny
> iny
> endif
0c47 : ca > dex
> trap_ne ;wrong number of bytes
0c48 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$22,0
> load_flag 0
0c4a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0c4c : 48 > pha ;use stack to load status
0c4d : a9dd > lda #$ff-$22 ;precharge accu
0c4f : 28 > plp
>
0c50 : 22 > db $22 ;test nop integrity - flags off
0c51 : ea > nop
0c52 : ea > nop
> tst_a $ff-$22,0
0c53 : 08 > php ;save flags
0c54 : c9dd > cmp #$ff-$22 ;test result
> trap_ne
0c56 : d0fe > bne * ;failed not equal (non zero)
>
0c58 : 68 > pla ;load status
0c59 : 48 > pha
> cmp_flag 0
0c5a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0c5c : d0fe > bne * ;failed not equal (non zero)
>
0c5e : 28 > plp ;restore status
>
> set_a $aa-$22,$ff
> load_flag $ff
0c5f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0c61 : 48 > pha ;use stack to load status
0c62 : a988 > lda #$aa-$22 ;precharge accu
0c64 : 28 > plp
>
0c65 : 22 > db $22 ;test nop integrity - flags on
0c66 : ea > nop
0c67 : ea > nop
> tst_a $aa-$22,$ff
0c68 : 08 > php ;save flags
0c69 : c988 > cmp #$aa-$22 ;test result
> trap_ne
0c6b : d0fe > bne * ;failed not equal (non zero)
>
0c6d : 68 > pla ;load status
0c6e : 48 > pha
> cmp_flag $ff
0c6f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0c71 : d0fe > bne * ;failed not equal (non zero)
>
0c73 : 28 > plp ;restore status
>
0c74 : c042 > cpy #$42
> trap_ne ;y changed
0c76 : d0fe > bne * ;failed not equal (non zero)
>
0c78 : e000 > cpx #0
> trap_ne ;x changed
0c7a : d0fe > bne * ;failed not equal (non zero)
>
nop_test $42,2
0c7c : a042 > ldy #$42
0c7e : a202 > ldx #4-2
0c80 : 42 > db $42 ;test nop length
> if 2 = 1
> dex
> dex
> endif
> if 2 = 2
0c81 : c8 > iny
0c82 : ca > dex
> endif
> if 2 = 3
> iny
> iny
> endif
0c83 : ca > dex
> trap_ne ;wrong number of bytes
0c84 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$42,0
> load_flag 0
0c86 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0c88 : 48 > pha ;use stack to load status
0c89 : a9bd > lda #$ff-$42 ;precharge accu
0c8b : 28 > plp
>
0c8c : 42 > db $42 ;test nop integrity - flags off
0c8d : ea > nop
0c8e : ea > nop
> tst_a $ff-$42,0
0c8f : 08 > php ;save flags
0c90 : c9bd > cmp #$ff-$42 ;test result
> trap_ne
0c92 : d0fe > bne * ;failed not equal (non zero)
>
0c94 : 68 > pla ;load status
0c95 : 48 > pha
> cmp_flag 0
0c96 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0c98 : d0fe > bne * ;failed not equal (non zero)
>
0c9a : 28 > plp ;restore status
>
> set_a $aa-$42,$ff
> load_flag $ff
0c9b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0c9d : 48 > pha ;use stack to load status
0c9e : a968 > lda #$aa-$42 ;precharge accu
0ca0 : 28 > plp
>
0ca1 : 42 > db $42 ;test nop integrity - flags on
0ca2 : ea > nop
0ca3 : ea > nop
> tst_a $aa-$42,$ff
0ca4 : 08 > php ;save flags
0ca5 : c968 > cmp #$aa-$42 ;test result
> trap_ne
0ca7 : d0fe > bne * ;failed not equal (non zero)
>
0ca9 : 68 > pla ;load status
0caa : 48 > pha
> cmp_flag $ff
0cab : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0cad : d0fe > bne * ;failed not equal (non zero)
>
0caf : 28 > plp ;restore status
>
0cb0 : c042 > cpy #$42
> trap_ne ;y changed
0cb2 : d0fe > bne * ;failed not equal (non zero)
>
0cb4 : e000 > cpx #0
> trap_ne ;x changed
0cb6 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $62,2
0cb8 : a042 > ldy #$42
0cba : a202 > ldx #4-2
0cbc : 62 > db $62 ;test nop length
> if 2 = 1
> dex
> dex
> endif
> if 2 = 2
0cbd : c8 > iny
0cbe : ca > dex
> endif
> if 2 = 3
> iny
> iny
> endif
0cbf : ca > dex
> trap_ne ;wrong number of bytes
0cc0 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$62,0
> load_flag 0
0cc2 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0cc4 : 48 > pha ;use stack to load status
0cc5 : a99d > lda #$ff-$62 ;precharge accu
0cc7 : 28 > plp
>
0cc8 : 62 > db $62 ;test nop integrity - flags off
0cc9 : ea > nop
0cca : ea > nop
> tst_a $ff-$62,0
0ccb : 08 > php ;save flags
0ccc : c99d > cmp #$ff-$62 ;test result
> trap_ne
0cce : d0fe > bne * ;failed not equal (non zero)
>
0cd0 : 68 > pla ;load status
0cd1 : 48 > pha
> cmp_flag 0
0cd2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0cd4 : d0fe > bne * ;failed not equal (non zero)
>
0cd6 : 28 > plp ;restore status
>
> set_a $aa-$62,$ff
> load_flag $ff
0cd7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0cd9 : 48 > pha ;use stack to load status
0cda : a948 > lda #$aa-$62 ;precharge accu
0cdc : 28 > plp
>
0cdd : 62 > db $62 ;test nop integrity - flags on
0cde : ea > nop
0cdf : ea > nop
> tst_a $aa-$62,$ff
0ce0 : 08 > php ;save flags
0ce1 : c948 > cmp #$aa-$62 ;test result
> trap_ne
0ce3 : d0fe > bne * ;failed not equal (non zero)
>
0ce5 : 68 > pla ;load status
0ce6 : 48 > pha
> cmp_flag $ff
0ce7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0ce9 : d0fe > bne * ;failed not equal (non zero)
>
0ceb : 28 > plp ;restore status
>
0cec : c042 > cpy #$42
> trap_ne ;y changed
0cee : d0fe > bne * ;failed not equal (non zero)
>
0cf0 : e000 > cpx #0
> trap_ne ;x changed
0cf2 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $82,2
0cf4 : a042 > ldy #$42
0cf6 : a202 > ldx #4-2
0cf8 : 82 > db $82 ;test nop length
> if 2 = 1
> dex
> dex
> endif
> if 2 = 2
0cf9 : c8 > iny
0cfa : ca > dex
> endif
> if 2 = 3
> iny
> iny
> endif
0cfb : ca > dex
> trap_ne ;wrong number of bytes
0cfc : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$82,0
> load_flag 0
0cfe : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0d00 : 48 > pha ;use stack to load status
0d01 : a97d > lda #$ff-$82 ;precharge accu
0d03 : 28 > plp
>
0d04 : 82 > db $82 ;test nop integrity - flags off
0d05 : ea > nop
0d06 : ea > nop
> tst_a $ff-$82,0
0d07 : 08 > php ;save flags
0d08 : c97d > cmp #$ff-$82 ;test result
> trap_ne
0d0a : d0fe > bne * ;failed not equal (non zero)
>
0d0c : 68 > pla ;load status
0d0d : 48 > pha
> cmp_flag 0
0d0e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0d10 : d0fe > bne * ;failed not equal (non zero)
>
0d12 : 28 > plp ;restore status
>
> set_a $aa-$82,$ff
> load_flag $ff
0d13 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0d15 : 48 > pha ;use stack to load status
0d16 : a928 > lda #$aa-$82 ;precharge accu
0d18 : 28 > plp
>
0d19 : 82 > db $82 ;test nop integrity - flags on
0d1a : ea > nop
0d1b : ea > nop
> tst_a $aa-$82,$ff
0d1c : 08 > php ;save flags
0d1d : c928 > cmp #$aa-$82 ;test result
> trap_ne
0d1f : d0fe > bne * ;failed not equal (non zero)
>
0d21 : 68 > pla ;load status
0d22 : 48 > pha
> cmp_flag $ff
0d23 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0d25 : d0fe > bne * ;failed not equal (non zero)
>
0d27 : 28 > plp ;restore status
>
0d28 : c042 > cpy #$42
> trap_ne ;y changed
0d2a : d0fe > bne * ;failed not equal (non zero)
>
0d2c : e000 > cpx #0
> trap_ne ;x changed
0d2e : d0fe > bne * ;failed not equal (non zero)
>
nop_test $c2,2
0d30 : a042 > ldy #$42
0d32 : a202 > ldx #4-2
0d34 : c2 > db $c2 ;test nop length
> if 2 = 1
> dex
> dex
> endif
> if 2 = 2
0d35 : c8 > iny
0d36 : ca > dex
> endif
> if 2 = 3
> iny
> iny
> endif
0d37 : ca > dex
> trap_ne ;wrong number of bytes
0d38 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$c2,0
> load_flag 0
0d3a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0d3c : 48 > pha ;use stack to load status
0d3d : a93d > lda #$ff-$c2 ;precharge accu
0d3f : 28 > plp
>
0d40 : c2 > db $c2 ;test nop integrity - flags off
0d41 : ea > nop
0d42 : ea > nop
> tst_a $ff-$c2,0
0d43 : 08 > php ;save flags
0d44 : c93d > cmp #$ff-$c2 ;test result
> trap_ne
0d46 : d0fe > bne * ;failed not equal (non zero)
>
0d48 : 68 > pla ;load status
0d49 : 48 > pha
> cmp_flag 0
0d4a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0d4c : d0fe > bne * ;failed not equal (non zero)
>
0d4e : 28 > plp ;restore status
>
> set_a $aa-$c2,$ff
> load_flag $ff
0d4f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0d51 : 48 > pha ;use stack to load status
0d52 : a9e8 > lda #$aa-$c2 ;precharge accu
0d54 : 28 > plp
>
0d55 : c2 > db $c2 ;test nop integrity - flags on
0d56 : ea > nop
0d57 : ea > nop
> tst_a $aa-$c2,$ff
0d58 : 08 > php ;save flags
0d59 : c9e8 > cmp #$aa-$c2 ;test result
> trap_ne
0d5b : d0fe > bne * ;failed not equal (non zero)
>
0d5d : 68 > pla ;load status
0d5e : 48 > pha
> cmp_flag $ff
0d5f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0d61 : d0fe > bne * ;failed not equal (non zero)
>
0d63 : 28 > plp ;restore status
>
0d64 : c042 > cpy #$42
> trap_ne ;y changed
0d66 : d0fe > bne * ;failed not equal (non zero)
>
0d68 : e000 > cpx #0
> trap_ne ;x changed
0d6a : d0fe > bne * ;failed not equal (non zero)
>
nop_test $e2,2
0d6c : a042 > ldy #$42
0d6e : a202 > ldx #4-2
0d70 : e2 > db $e2 ;test nop length
> if 2 = 1
> dex
> dex
> endif
> if 2 = 2
0d71 : c8 > iny
0d72 : ca > dex
> endif
> if 2 = 3
> iny
> iny
> endif
0d73 : ca > dex
> trap_ne ;wrong number of bytes
0d74 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$e2,0
> load_flag 0
0d76 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0d78 : 48 > pha ;use stack to load status
0d79 : a91d > lda #$ff-$e2 ;precharge accu
0d7b : 28 > plp
>
0d7c : e2 > db $e2 ;test nop integrity - flags off
0d7d : ea > nop
0d7e : ea > nop
> tst_a $ff-$e2,0
0d7f : 08 > php ;save flags
0d80 : c91d > cmp #$ff-$e2 ;test result
> trap_ne
0d82 : d0fe > bne * ;failed not equal (non zero)
>
0d84 : 68 > pla ;load status
0d85 : 48 > pha
> cmp_flag 0
0d86 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0d88 : d0fe > bne * ;failed not equal (non zero)
>
0d8a : 28 > plp ;restore status
>
> set_a $aa-$e2,$ff
> load_flag $ff
0d8b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0d8d : 48 > pha ;use stack to load status
0d8e : a9c8 > lda #$aa-$e2 ;precharge accu
0d90 : 28 > plp
>
0d91 : e2 > db $e2 ;test nop integrity - flags on
0d92 : ea > nop
0d93 : ea > nop
> tst_a $aa-$e2,$ff
0d94 : 08 > php ;save flags
0d95 : c9c8 > cmp #$aa-$e2 ;test result
> trap_ne
0d97 : d0fe > bne * ;failed not equal (non zero)
>
0d99 : 68 > pla ;load status
0d9a : 48 > pha
> cmp_flag $ff
0d9b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0d9d : d0fe > bne * ;failed not equal (non zero)
>
0d9f : 28 > plp ;restore status
>
0da0 : c042 > cpy #$42
> trap_ne ;y changed
0da2 : d0fe > bne * ;failed not equal (non zero)
>
0da4 : e000 > cpx #0
> trap_ne ;x changed
0da6 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $44,2
0da8 : a042 > ldy #$42
0daa : a202 > ldx #4-2
0dac : 44 > db $44 ;test nop length
> if 2 = 1
> dex
> dex
> endif
> if 2 = 2
0dad : c8 > iny
0dae : ca > dex
> endif
> if 2 = 3
> iny
> iny
> endif
0daf : ca > dex
> trap_ne ;wrong number of bytes
0db0 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$44,0
> load_flag 0
0db2 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0db4 : 48 > pha ;use stack to load status
0db5 : a9bb > lda #$ff-$44 ;precharge accu
0db7 : 28 > plp
>
0db8 : 44 > db $44 ;test nop integrity - flags off
0db9 : ea > nop
0dba : ea > nop
> tst_a $ff-$44,0
0dbb : 08 > php ;save flags
0dbc : c9bb > cmp #$ff-$44 ;test result
> trap_ne
0dbe : d0fe > bne * ;failed not equal (non zero)
>
0dc0 : 68 > pla ;load status
0dc1 : 48 > pha
> cmp_flag 0
0dc2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0dc4 : d0fe > bne * ;failed not equal (non zero)
>
0dc6 : 28 > plp ;restore status
>
> set_a $aa-$44,$ff
> load_flag $ff
0dc7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0dc9 : 48 > pha ;use stack to load status
0dca : a966 > lda #$aa-$44 ;precharge accu
0dcc : 28 > plp
>
0dcd : 44 > db $44 ;test nop integrity - flags on
0dce : ea > nop
0dcf : ea > nop
> tst_a $aa-$44,$ff
0dd0 : 08 > php ;save flags
0dd1 : c966 > cmp #$aa-$44 ;test result
> trap_ne
0dd3 : d0fe > bne * ;failed not equal (non zero)
>
0dd5 : 68 > pla ;load status
0dd6 : 48 > pha
> cmp_flag $ff
0dd7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0dd9 : d0fe > bne * ;failed not equal (non zero)
>
0ddb : 28 > plp ;restore status
>
0ddc : c042 > cpy #$42
> trap_ne ;y changed
0dde : d0fe > bne * ;failed not equal (non zero)
>
0de0 : e000 > cpx #0
> trap_ne ;x changed
0de2 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $54,2
0de4 : a042 > ldy #$42
0de6 : a202 > ldx #4-2
0de8 : 54 > db $54 ;test nop length
> if 2 = 1
> dex
> dex
> endif
> if 2 = 2
0de9 : c8 > iny
0dea : ca > dex
> endif
> if 2 = 3
> iny
> iny
> endif
0deb : ca > dex
> trap_ne ;wrong number of bytes
0dec : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$54,0
> load_flag 0
0dee : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0df0 : 48 > pha ;use stack to load status
0df1 : a9ab > lda #$ff-$54 ;precharge accu
0df3 : 28 > plp
>
0df4 : 54 > db $54 ;test nop integrity - flags off
0df5 : ea > nop
0df6 : ea > nop
> tst_a $ff-$54,0
0df7 : 08 > php ;save flags
0df8 : c9ab > cmp #$ff-$54 ;test result
> trap_ne
0dfa : d0fe > bne * ;failed not equal (non zero)
>
0dfc : 68 > pla ;load status
0dfd : 48 > pha
> cmp_flag 0
0dfe : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0e00 : d0fe > bne * ;failed not equal (non zero)
>
0e02 : 28 > plp ;restore status
>
> set_a $aa-$54,$ff
> load_flag $ff
0e03 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0e05 : 48 > pha ;use stack to load status
0e06 : a956 > lda #$aa-$54 ;precharge accu
0e08 : 28 > plp
>
0e09 : 54 > db $54 ;test nop integrity - flags on
0e0a : ea > nop
0e0b : ea > nop
> tst_a $aa-$54,$ff
0e0c : 08 > php ;save flags
0e0d : c956 > cmp #$aa-$54 ;test result
> trap_ne
0e0f : d0fe > bne * ;failed not equal (non zero)
>
0e11 : 68 > pla ;load status
0e12 : 48 > pha
> cmp_flag $ff
0e13 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0e15 : d0fe > bne * ;failed not equal (non zero)
>
0e17 : 28 > plp ;restore status
>
0e18 : c042 > cpy #$42
> trap_ne ;y changed
0e1a : d0fe > bne * ;failed not equal (non zero)
>
0e1c : e000 > cpx #0
> trap_ne ;x changed
0e1e : d0fe > bne * ;failed not equal (non zero)
>
nop_test $d4,2
0e20 : a042 > ldy #$42
0e22 : a202 > ldx #4-2
0e24 : d4 > db $d4 ;test nop length
> if 2 = 1
> dex
> dex
> endif
> if 2 = 2
0e25 : c8 > iny
0e26 : ca > dex
> endif
> if 2 = 3
> iny
> iny
> endif
0e27 : ca > dex
> trap_ne ;wrong number of bytes
0e28 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$d4,0
> load_flag 0
0e2a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0e2c : 48 > pha ;use stack to load status
0e2d : a92b > lda #$ff-$d4 ;precharge accu
0e2f : 28 > plp
>
0e30 : d4 > db $d4 ;test nop integrity - flags off
0e31 : ea > nop
0e32 : ea > nop
> tst_a $ff-$d4,0
0e33 : 08 > php ;save flags
0e34 : c92b > cmp #$ff-$d4 ;test result
> trap_ne
0e36 : d0fe > bne * ;failed not equal (non zero)
>
0e38 : 68 > pla ;load status
0e39 : 48 > pha
> cmp_flag 0
0e3a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0e3c : d0fe > bne * ;failed not equal (non zero)
>
0e3e : 28 > plp ;restore status
>
> set_a $aa-$d4,$ff
> load_flag $ff
0e3f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0e41 : 48 > pha ;use stack to load status
0e42 : a9d6 > lda #$aa-$d4 ;precharge accu
0e44 : 28 > plp
>
0e45 : d4 > db $d4 ;test nop integrity - flags on
0e46 : ea > nop
0e47 : ea > nop
> tst_a $aa-$d4,$ff
0e48 : 08 > php ;save flags
0e49 : c9d6 > cmp #$aa-$d4 ;test result
> trap_ne
0e4b : d0fe > bne * ;failed not equal (non zero)
>
0e4d : 68 > pla ;load status
0e4e : 48 > pha
> cmp_flag $ff
0e4f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0e51 : d0fe > bne * ;failed not equal (non zero)
>
0e53 : 28 > plp ;restore status
>
0e54 : c042 > cpy #$42
> trap_ne ;y changed
0e56 : d0fe > bne * ;failed not equal (non zero)
>
0e58 : e000 > cpx #0
> trap_ne ;x changed
0e5a : d0fe > bne * ;failed not equal (non zero)
>
nop_test $f4,2
0e5c : a042 > ldy #$42
0e5e : a202 > ldx #4-2
0e60 : f4 > db $f4 ;test nop length
> if 2 = 1
> dex
> dex
> endif
> if 2 = 2
0e61 : c8 > iny
0e62 : ca > dex
> endif
> if 2 = 3
> iny
> iny
> endif
0e63 : ca > dex
> trap_ne ;wrong number of bytes
0e64 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$f4,0
> load_flag 0
0e66 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0e68 : 48 > pha ;use stack to load status
0e69 : a90b > lda #$ff-$f4 ;precharge accu
0e6b : 28 > plp
>
0e6c : f4 > db $f4 ;test nop integrity - flags off
0e6d : ea > nop
0e6e : ea > nop
> tst_a $ff-$f4,0
0e6f : 08 > php ;save flags
0e70 : c90b > cmp #$ff-$f4 ;test result
> trap_ne
0e72 : d0fe > bne * ;failed not equal (non zero)
>
0e74 : 68 > pla ;load status
0e75 : 48 > pha
> cmp_flag 0
0e76 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0e78 : d0fe > bne * ;failed not equal (non zero)
>
0e7a : 28 > plp ;restore status
>
> set_a $aa-$f4,$ff
> load_flag $ff
0e7b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0e7d : 48 > pha ;use stack to load status
0e7e : a9b6 > lda #$aa-$f4 ;precharge accu
0e80 : 28 > plp
>
0e81 : f4 > db $f4 ;test nop integrity - flags on
0e82 : ea > nop
0e83 : ea > nop
> tst_a $aa-$f4,$ff
0e84 : 08 > php ;save flags
0e85 : c9b6 > cmp #$aa-$f4 ;test result
> trap_ne
0e87 : d0fe > bne * ;failed not equal (non zero)
>
0e89 : 68 > pla ;load status
0e8a : 48 > pha
> cmp_flag $ff
0e8b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0e8d : d0fe > bne * ;failed not equal (non zero)
>
0e8f : 28 > plp ;restore status
>
0e90 : c042 > cpy #$42
> trap_ne ;y changed
0e92 : d0fe > bne * ;failed not equal (non zero)
>
0e94 : e000 > cpx #0
> trap_ne ;x changed
0e96 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $5c,3
0e98 : a042 > ldy #$42
0e9a : a201 > ldx #4-3
0e9c : 5c > db $5c ;test nop length
> if 3 = 1
> dex
> dex
> endif
> if 3 = 2
> iny
> dex
> endif
> if 3 = 3
0e9d : c8 > iny
0e9e : c8 > iny
> endif
0e9f : ca > dex
> trap_ne ;wrong number of bytes
0ea0 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$5c,0
> load_flag 0
0ea2 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0ea4 : 48 > pha ;use stack to load status
0ea5 : a9a3 > lda #$ff-$5c ;precharge accu
0ea7 : 28 > plp
>
0ea8 : 5c > db $5c ;test nop integrity - flags off
0ea9 : ea > nop
0eaa : ea > nop
> tst_a $ff-$5c,0
0eab : 08 > php ;save flags
0eac : c9a3 > cmp #$ff-$5c ;test result
> trap_ne
0eae : d0fe > bne * ;failed not equal (non zero)
>
0eb0 : 68 > pla ;load 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
>
> set_a $aa-$5c,$ff
> load_flag $ff
0eb7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0eb9 : 48 > pha ;use stack to load status
0eba : a94e > lda #$aa-$5c ;precharge accu
0ebc : 28 > plp
>
0ebd : 5c > db $5c ;test nop integrity - flags on
0ebe : ea > nop
0ebf : ea > nop
> tst_a $aa-$5c,$ff
0ec0 : 08 > php ;save flags
0ec1 : c94e > cmp #$aa-$5c ;test result
> trap_ne
0ec3 : d0fe > bne * ;failed not equal (non zero)
>
0ec5 : 68 > pla ;load status
0ec6 : 48 > pha
> cmp_flag $ff
0ec7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0ec9 : d0fe > bne * ;failed not equal (non zero)
>
0ecb : 28 > plp ;restore status
>
0ecc : c042 > cpy #$42
> trap_ne ;y changed
0ece : d0fe > bne * ;failed not equal (non zero)
>
0ed0 : e000 > cpx #0
> trap_ne ;x changed
0ed2 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $dc,3
0ed4 : a042 > ldy #$42
0ed6 : a201 > ldx #4-3
0ed8 : dc > db $dc ;test nop length
> if 3 = 1
> dex
> dex
> endif
> if 3 = 2
> iny
> dex
> endif
> if 3 = 3
0ed9 : c8 > iny
0eda : c8 > iny
> endif
0edb : ca > dex
> trap_ne ;wrong number of bytes
0edc : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$dc,0
> load_flag 0
0ede : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0ee0 : 48 > pha ;use stack to load status
0ee1 : a923 > lda #$ff-$dc ;precharge accu
0ee3 : 28 > plp
>
0ee4 : dc > db $dc ;test nop integrity - flags off
0ee5 : ea > nop
0ee6 : ea > nop
> tst_a $ff-$dc,0
0ee7 : 08 > php ;save flags
0ee8 : c923 > cmp #$ff-$dc ;test result
> trap_ne
0eea : d0fe > bne * ;failed not equal (non zero)
>
0eec : 68 > pla ;load status
0eed : 48 > pha
> cmp_flag 0
0eee : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0ef0 : d0fe > bne * ;failed not equal (non zero)
>
0ef2 : 28 > plp ;restore status
>
> set_a $aa-$dc,$ff
> load_flag $ff
0ef3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0ef5 : 48 > pha ;use stack to load status
0ef6 : a9ce > lda #$aa-$dc ;precharge accu
0ef8 : 28 > plp
>
0ef9 : dc > db $dc ;test nop integrity - flags on
0efa : ea > nop
0efb : ea > nop
> tst_a $aa-$dc,$ff
0efc : 08 > php ;save flags
0efd : c9ce > cmp #$aa-$dc ;test result
> trap_ne
0eff : d0fe > bne * ;failed not equal (non zero)
>
0f01 : 68 > pla ;load status
0f02 : 48 > pha
> cmp_flag $ff
0f03 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0f05 : d0fe > bne * ;failed not equal (non zero)
>
0f07 : 28 > plp ;restore status
>
0f08 : c042 > cpy #$42
> trap_ne ;y changed
0f0a : d0fe > bne * ;failed not equal (non zero)
>
0f0c : e000 > cpx #0
> trap_ne ;x changed
0f0e : d0fe > bne * ;failed not equal (non zero)
>
nop_test $fc,3
0f10 : a042 > ldy #$42
0f12 : a201 > ldx #4-3
0f14 : fc > db $fc ;test nop length
> if 3 = 1
> dex
> dex
> endif
> if 3 = 2
> iny
> dex
> endif
> if 3 = 3
0f15 : c8 > iny
0f16 : c8 > iny
> endif
0f17 : ca > dex
> trap_ne ;wrong number of bytes
0f18 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$fc,0
> load_flag 0
0f1a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0f1c : 48 > pha ;use stack to load status
0f1d : a903 > lda #$ff-$fc ;precharge accu
0f1f : 28 > plp
>
0f20 : fc > db $fc ;test nop integrity - flags off
0f21 : ea > nop
0f22 : ea > nop
> tst_a $ff-$fc,0
0f23 : 08 > php ;save flags
0f24 : c903 > cmp #$ff-$fc ;test result
> trap_ne
0f26 : d0fe > bne * ;failed not equal (non zero)
>
0f28 : 68 > pla ;load status
0f29 : 48 > pha
> cmp_flag 0
0f2a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0f2c : d0fe > bne * ;failed not equal (non zero)
>
0f2e : 28 > plp ;restore status
>
> set_a $aa-$fc,$ff
> load_flag $ff
0f2f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0f31 : 48 > pha ;use stack to load status
0f32 : a9ae > lda #$aa-$fc ;precharge accu
0f34 : 28 > plp
>
0f35 : fc > db $fc ;test nop integrity - flags on
0f36 : ea > nop
0f37 : ea > nop
> tst_a $aa-$fc,$ff
0f38 : 08 > php ;save flags
0f39 : c9ae > cmp #$aa-$fc ;test result
> trap_ne
0f3b : d0fe > bne * ;failed not equal (non zero)
>
0f3d : 68 > pla ;load status
0f3e : 48 > pha
> cmp_flag $ff
0f3f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0f41 : d0fe > bne * ;failed not equal (non zero)
>
0f43 : 28 > plp ;restore status
>
0f44 : c042 > cpy #$42
> trap_ne ;y changed
0f46 : d0fe > bne * ;failed not equal (non zero)
>
0f48 : e000 > cpx #0
> trap_ne ;x changed
0f4a : d0fe > bne * ;failed not equal (non zero)
>
nop_test $03,1
0f4c : a042 > ldy #$42
0f4e : a203 > ldx #4-1
0f50 : 03 > db $03 ;test nop length
> if 1 = 1
0f51 : ca > dex
0f52 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
0f53 : ca > dex
> trap_ne ;wrong number of bytes
0f54 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$03,0
> load_flag 0
0f56 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0f58 : 48 > pha ;use stack to load status
0f59 : a9fc > lda #$ff-$03 ;precharge accu
0f5b : 28 > plp
>
0f5c : 03 > db $03 ;test nop integrity - flags off
0f5d : ea > nop
0f5e : ea > nop
> tst_a $ff-$03,0
0f5f : 08 > php ;save flags
0f60 : c9fc > cmp #$ff-$03 ;test result
> trap_ne
0f62 : d0fe > bne * ;failed not equal (non zero)
>
0f64 : 68 > pla ;load status
0f65 : 48 > pha
> cmp_flag 0
0f66 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0f68 : d0fe > bne * ;failed not equal (non zero)
>
0f6a : 28 > plp ;restore status
>
> set_a $aa-$03,$ff
> load_flag $ff
0f6b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0f6d : 48 > pha ;use stack to load status
0f6e : a9a7 > lda #$aa-$03 ;precharge accu
0f70 : 28 > plp
>
0f71 : 03 > db $03 ;test nop integrity - flags on
0f72 : ea > nop
0f73 : ea > nop
> tst_a $aa-$03,$ff
0f74 : 08 > php ;save flags
0f75 : c9a7 > cmp #$aa-$03 ;test result
> trap_ne
0f77 : d0fe > bne * ;failed not equal (non zero)
>
0f79 : 68 > pla ;load status
0f7a : 48 > pha
> cmp_flag $ff
0f7b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0f7d : d0fe > bne * ;failed not equal (non zero)
>
0f7f : 28 > plp ;restore status
>
0f80 : c042 > cpy #$42
> trap_ne ;y changed
0f82 : d0fe > bne * ;failed not equal (non zero)
>
0f84 : e000 > cpx #0
> trap_ne ;x changed
0f86 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $13,1
0f88 : a042 > ldy #$42
0f8a : a203 > ldx #4-1
0f8c : 13 > db $13 ;test nop length
> if 1 = 1
0f8d : ca > dex
0f8e : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
0f8f : ca > dex
> trap_ne ;wrong number of bytes
0f90 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$13,0
> load_flag 0
0f92 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0f94 : 48 > pha ;use stack to load status
0f95 : a9ec > lda #$ff-$13 ;precharge accu
0f97 : 28 > plp
>
0f98 : 13 > db $13 ;test nop integrity - flags off
0f99 : ea > nop
0f9a : ea > nop
> tst_a $ff-$13,0
0f9b : 08 > php ;save flags
0f9c : c9ec > cmp #$ff-$13 ;test result
> trap_ne
0f9e : d0fe > bne * ;failed not equal (non zero)
>
0fa0 : 68 > pla ;load status
0fa1 : 48 > pha
> cmp_flag 0
0fa2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0fa4 : d0fe > bne * ;failed not equal (non zero)
>
0fa6 : 28 > plp ;restore status
>
> set_a $aa-$13,$ff
> load_flag $ff
0fa7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0fa9 : 48 > pha ;use stack to load status
0faa : a997 > lda #$aa-$13 ;precharge accu
0fac : 28 > plp
>
0fad : 13 > db $13 ;test nop integrity - flags on
0fae : ea > nop
0faf : ea > nop
> tst_a $aa-$13,$ff
0fb0 : 08 > php ;save flags
0fb1 : c997 > cmp #$aa-$13 ;test result
> trap_ne
0fb3 : d0fe > bne * ;failed not equal (non zero)
>
0fb5 : 68 > pla ;load status
0fb6 : 48 > pha
> cmp_flag $ff
0fb7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0fb9 : d0fe > bne * ;failed not equal (non zero)
>
0fbb : 28 > plp ;restore status
>
0fbc : c042 > cpy #$42
> trap_ne ;y changed
0fbe : d0fe > bne * ;failed not equal (non zero)
>
0fc0 : e000 > cpx #0
> trap_ne ;x changed
0fc2 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $23,1
0fc4 : a042 > ldy #$42
0fc6 : a203 > ldx #4-1
0fc8 : 23 > db $23 ;test nop length
> if 1 = 1
0fc9 : ca > dex
0fca : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
0fcb : ca > dex
> trap_ne ;wrong number of bytes
0fcc : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$23,0
> load_flag 0
0fce : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0fd0 : 48 > pha ;use stack to load status
0fd1 : a9dc > lda #$ff-$23 ;precharge accu
0fd3 : 28 > plp
>
0fd4 : 23 > db $23 ;test nop integrity - flags off
0fd5 : ea > nop
0fd6 : ea > nop
> tst_a $ff-$23,0
0fd7 : 08 > php ;save flags
0fd8 : c9dc > cmp #$ff-$23 ;test result
> trap_ne
0fda : d0fe > bne * ;failed not equal (non zero)
>
0fdc : 68 > pla ;load status
0fdd : 48 > pha
> cmp_flag 0
0fde : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0fe0 : d0fe > bne * ;failed not equal (non zero)
>
0fe2 : 28 > plp ;restore status
>
> set_a $aa-$23,$ff
> load_flag $ff
0fe3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0fe5 : 48 > pha ;use stack to load status
0fe6 : a987 > lda #$aa-$23 ;precharge accu
0fe8 : 28 > plp
>
0fe9 : 23 > db $23 ;test nop integrity - flags on
0fea : ea > nop
0feb : ea > nop
> tst_a $aa-$23,$ff
0fec : 08 > php ;save flags
0fed : c987 > cmp #$aa-$23 ;test result
> trap_ne
0fef : d0fe > bne * ;failed not equal (non zero)
>
0ff1 : 68 > pla ;load status
0ff2 : 48 > pha
> cmp_flag $ff
0ff3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0ff5 : d0fe > bne * ;failed not equal (non zero)
>
0ff7 : 28 > plp ;restore status
>
0ff8 : c042 > cpy #$42
> trap_ne ;y changed
0ffa : d0fe > bne * ;failed not equal (non zero)
>
0ffc : e000 > cpx #0
> trap_ne ;x changed
0ffe : d0fe > bne * ;failed not equal (non zero)
>
nop_test $33,1
1000 : a042 > ldy #$42
1002 : a203 > ldx #4-1
1004 : 33 > db $33 ;test nop length
> if 1 = 1
1005 : ca > dex
1006 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
1007 : ca > dex
> trap_ne ;wrong number of bytes
1008 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$33,0
> load_flag 0
100a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
100c : 48 > pha ;use stack to load status
100d : a9cc > lda #$ff-$33 ;precharge accu
100f : 28 > plp
>
1010 : 33 > db $33 ;test nop integrity - flags off
1011 : ea > nop
1012 : ea > nop
> tst_a $ff-$33,0
1013 : 08 > php ;save flags
1014 : c9cc > cmp #$ff-$33 ;test result
> trap_ne
1016 : d0fe > bne * ;failed not equal (non zero)
>
1018 : 68 > pla ;load status
1019 : 48 > pha
> cmp_flag 0
101a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
101c : d0fe > bne * ;failed not equal (non zero)
>
101e : 28 > plp ;restore status
>
> set_a $aa-$33,$ff
> load_flag $ff
101f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1021 : 48 > pha ;use stack to load status
1022 : a977 > lda #$aa-$33 ;precharge accu
1024 : 28 > plp
>
1025 : 33 > db $33 ;test nop integrity - flags on
1026 : ea > nop
1027 : ea > nop
> tst_a $aa-$33,$ff
1028 : 08 > php ;save flags
1029 : c977 > cmp #$aa-$33 ;test result
> trap_ne
102b : d0fe > bne * ;failed not equal (non zero)
>
102d : 68 > pla ;load status
102e : 48 > pha
> cmp_flag $ff
102f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1031 : d0fe > bne * ;failed not equal (non zero)
>
1033 : 28 > plp ;restore status
>
1034 : c042 > cpy #$42
> trap_ne ;y changed
1036 : d0fe > bne * ;failed not equal (non zero)
>
1038 : e000 > cpx #0
> trap_ne ;x changed
103a : d0fe > bne * ;failed not equal (non zero)
>
nop_test $43,1
103c : a042 > ldy #$42
103e : a203 > ldx #4-1
1040 : 43 > db $43 ;test nop length
> if 1 = 1
1041 : ca > dex
1042 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
1043 : ca > dex
> trap_ne ;wrong number of bytes
1044 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$43,0
> load_flag 0
1046 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1048 : 48 > pha ;use stack to load status
1049 : a9bc > lda #$ff-$43 ;precharge accu
104b : 28 > plp
>
104c : 43 > db $43 ;test nop integrity - flags off
104d : ea > nop
104e : ea > nop
> tst_a $ff-$43,0
104f : 08 > php ;save flags
1050 : c9bc > cmp #$ff-$43 ;test result
> trap_ne
1052 : d0fe > bne * ;failed not equal (non zero)
>
1054 : 68 > pla ;load status
1055 : 48 > pha
> cmp_flag 0
1056 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1058 : d0fe > bne * ;failed not equal (non zero)
>
105a : 28 > plp ;restore status
>
> set_a $aa-$43,$ff
> load_flag $ff
105b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
105d : 48 > pha ;use stack to load status
105e : a967 > lda #$aa-$43 ;precharge accu
1060 : 28 > plp
>
1061 : 43 > db $43 ;test nop integrity - flags on
1062 : ea > nop
1063 : ea > nop
> tst_a $aa-$43,$ff
1064 : 08 > php ;save flags
1065 : c967 > cmp #$aa-$43 ;test result
> trap_ne
1067 : d0fe > bne * ;failed not equal (non zero)
>
1069 : 68 > pla ;load status
106a : 48 > pha
> cmp_flag $ff
106b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
106d : d0fe > bne * ;failed not equal (non zero)
>
106f : 28 > plp ;restore status
>
1070 : c042 > cpy #$42
> trap_ne ;y changed
1072 : d0fe > bne * ;failed not equal (non zero)
>
1074 : e000 > cpx #0
> trap_ne ;x changed
1076 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $53,1
1078 : a042 > ldy #$42
107a : a203 > ldx #4-1
107c : 53 > db $53 ;test nop length
> if 1 = 1
107d : ca > dex
107e : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
107f : ca > dex
> trap_ne ;wrong number of bytes
1080 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$53,0
> load_flag 0
1082 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1084 : 48 > pha ;use stack to load status
1085 : a9ac > lda #$ff-$53 ;precharge accu
1087 : 28 > plp
>
1088 : 53 > db $53 ;test nop integrity - flags off
1089 : ea > nop
108a : ea > nop
> tst_a $ff-$53,0
108b : 08 > php ;save flags
108c : c9ac > cmp #$ff-$53 ;test result
> trap_ne
108e : d0fe > bne * ;failed not equal (non zero)
>
1090 : 68 > pla ;load status
1091 : 48 > pha
> cmp_flag 0
1092 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1094 : d0fe > bne * ;failed not equal (non zero)
>
1096 : 28 > plp ;restore status
>
> set_a $aa-$53,$ff
> load_flag $ff
1097 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1099 : 48 > pha ;use stack to load status
109a : a957 > lda #$aa-$53 ;precharge accu
109c : 28 > plp
>
109d : 53 > db $53 ;test nop integrity - flags on
109e : ea > nop
109f : ea > nop
> tst_a $aa-$53,$ff
10a0 : 08 > php ;save flags
10a1 : c957 > cmp #$aa-$53 ;test result
> trap_ne
10a3 : d0fe > bne * ;failed not equal (non zero)
>
10a5 : 68 > pla ;load status
10a6 : 48 > pha
> cmp_flag $ff
10a7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
10a9 : d0fe > bne * ;failed not equal (non zero)
>
10ab : 28 > plp ;restore status
>
10ac : c042 > cpy #$42
> trap_ne ;y changed
10ae : d0fe > bne * ;failed not equal (non zero)
>
10b0 : e000 > cpx #0
> trap_ne ;x changed
10b2 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $63,1
10b4 : a042 > ldy #$42
10b6 : a203 > ldx #4-1
10b8 : 63 > db $63 ;test nop length
> if 1 = 1
10b9 : ca > dex
10ba : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
10bb : ca > dex
> trap_ne ;wrong number of bytes
10bc : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$63,0
> load_flag 0
10be : a900 > lda #0 ;allow test to change I-flag (no mask)
>
10c0 : 48 > pha ;use stack to load status
10c1 : a99c > lda #$ff-$63 ;precharge accu
10c3 : 28 > plp
>
10c4 : 63 > db $63 ;test nop integrity - flags off
10c5 : ea > nop
10c6 : ea > nop
> tst_a $ff-$63,0
10c7 : 08 > php ;save flags
10c8 : c99c > cmp #$ff-$63 ;test result
> trap_ne
10ca : d0fe > bne * ;failed not equal (non zero)
>
10cc : 68 > pla ;load status
10cd : 48 > pha
> cmp_flag 0
10ce : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
10d0 : d0fe > bne * ;failed not equal (non zero)
>
10d2 : 28 > plp ;restore status
>
> set_a $aa-$63,$ff
> load_flag $ff
10d3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
10d5 : 48 > pha ;use stack to load status
10d6 : a947 > lda #$aa-$63 ;precharge accu
10d8 : 28 > plp
>
10d9 : 63 > db $63 ;test nop integrity - flags on
10da : ea > nop
10db : ea > nop
> tst_a $aa-$63,$ff
10dc : 08 > php ;save flags
10dd : c947 > cmp #$aa-$63 ;test result
> trap_ne
10df : d0fe > bne * ;failed not equal (non zero)
>
10e1 : 68 > pla ;load status
10e2 : 48 > pha
> cmp_flag $ff
10e3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
10e5 : d0fe > bne * ;failed not equal (non zero)
>
10e7 : 28 > plp ;restore status
>
10e8 : c042 > cpy #$42
> trap_ne ;y changed
10ea : d0fe > bne * ;failed not equal (non zero)
>
10ec : e000 > cpx #0
> trap_ne ;x changed
10ee : d0fe > bne * ;failed not equal (non zero)
>
nop_test $73,1
10f0 : a042 > ldy #$42
10f2 : a203 > ldx #4-1
10f4 : 73 > db $73 ;test nop length
> if 1 = 1
10f5 : ca > dex
10f6 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
10f7 : ca > dex
> trap_ne ;wrong number of bytes
10f8 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$73,0
> load_flag 0
10fa : a900 > lda #0 ;allow test to change I-flag (no mask)
>
10fc : 48 > pha ;use stack to load status
10fd : a98c > lda #$ff-$73 ;precharge accu
10ff : 28 > plp
>
1100 : 73 > db $73 ;test nop integrity - flags off
1101 : ea > nop
1102 : ea > nop
> tst_a $ff-$73,0
1103 : 08 > php ;save flags
1104 : c98c > cmp #$ff-$73 ;test result
> trap_ne
1106 : d0fe > bne * ;failed not equal (non zero)
>
1108 : 68 > pla ;load status
1109 : 48 > pha
> cmp_flag 0
110a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
110c : d0fe > bne * ;failed not equal (non zero)
>
110e : 28 > plp ;restore status
>
> set_a $aa-$73,$ff
> load_flag $ff
110f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1111 : 48 > pha ;use stack to load status
1112 : a937 > lda #$aa-$73 ;precharge accu
1114 : 28 > plp
>
1115 : 73 > db $73 ;test nop integrity - flags on
1116 : ea > nop
1117 : ea > nop
> tst_a $aa-$73,$ff
1118 : 08 > php ;save flags
1119 : c937 > cmp #$aa-$73 ;test result
> trap_ne
111b : d0fe > bne * ;failed not equal (non zero)
>
111d : 68 > pla ;load status
111e : 48 > pha
> cmp_flag $ff
111f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1121 : d0fe > bne * ;failed not equal (non zero)
>
1123 : 28 > plp ;restore status
>
1124 : c042 > cpy #$42
> trap_ne ;y changed
1126 : d0fe > bne * ;failed not equal (non zero)
>
1128 : e000 > cpx #0
> trap_ne ;x changed
112a : d0fe > bne * ;failed not equal (non zero)
>
nop_test $83,1
112c : a042 > ldy #$42
112e : a203 > ldx #4-1
1130 : 83 > db $83 ;test nop length
> if 1 = 1
1131 : ca > dex
1132 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
1133 : ca > dex
> trap_ne ;wrong number of bytes
1134 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$83,0
> load_flag 0
1136 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1138 : 48 > pha ;use stack to load status
1139 : a97c > lda #$ff-$83 ;precharge accu
113b : 28 > plp
>
113c : 83 > db $83 ;test nop integrity - flags off
113d : ea > nop
113e : ea > nop
> tst_a $ff-$83,0
113f : 08 > php ;save flags
1140 : c97c > cmp #$ff-$83 ;test result
> trap_ne
1142 : d0fe > bne * ;failed not equal (non zero)
>
1144 : 68 > pla ;load status
1145 : 48 > pha
> cmp_flag 0
1146 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1148 : d0fe > bne * ;failed not equal (non zero)
>
114a : 28 > plp ;restore status
>
> set_a $aa-$83,$ff
> load_flag $ff
114b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
114d : 48 > pha ;use stack to load status
114e : a927 > lda #$aa-$83 ;precharge accu
1150 : 28 > plp
>
1151 : 83 > db $83 ;test nop integrity - flags on
1152 : ea > nop
1153 : ea > nop
> tst_a $aa-$83,$ff
1154 : 08 > php ;save flags
1155 : c927 > cmp #$aa-$83 ;test result
> trap_ne
1157 : d0fe > bne * ;failed not equal (non zero)
>
1159 : 68 > pla ;load status
115a : 48 > pha
> cmp_flag $ff
115b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
115d : d0fe > bne * ;failed not equal (non zero)
>
115f : 28 > plp ;restore status
>
1160 : c042 > cpy #$42
> trap_ne ;y changed
1162 : d0fe > bne * ;failed not equal (non zero)
>
1164 : e000 > cpx #0
> trap_ne ;x changed
1166 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $93,1
1168 : a042 > ldy #$42
116a : a203 > ldx #4-1
116c : 93 > db $93 ;test nop length
> if 1 = 1
116d : ca > dex
116e : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
116f : ca > dex
> trap_ne ;wrong number of bytes
1170 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$93,0
> load_flag 0
1172 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1174 : 48 > pha ;use stack to load status
1175 : a96c > lda #$ff-$93 ;precharge accu
1177 : 28 > plp
>
1178 : 93 > db $93 ;test nop integrity - flags off
1179 : ea > nop
117a : ea > nop
> tst_a $ff-$93,0
117b : 08 > php ;save flags
117c : c96c > cmp #$ff-$93 ;test result
> trap_ne
117e : d0fe > bne * ;failed not equal (non zero)
>
1180 : 68 > pla ;load status
1181 : 48 > pha
> cmp_flag 0
1182 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1184 : d0fe > bne * ;failed not equal (non zero)
>
1186 : 28 > plp ;restore status
>
> set_a $aa-$93,$ff
> load_flag $ff
1187 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1189 : 48 > pha ;use stack to load status
118a : a917 > lda #$aa-$93 ;precharge accu
118c : 28 > plp
>
118d : 93 > db $93 ;test nop integrity - flags on
118e : ea > nop
118f : ea > nop
> tst_a $aa-$93,$ff
1190 : 08 > php ;save flags
1191 : c917 > cmp #$aa-$93 ;test result
> trap_ne
1193 : d0fe > bne * ;failed not equal (non zero)
>
1195 : 68 > pla ;load status
1196 : 48 > pha
> cmp_flag $ff
1197 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1199 : d0fe > bne * ;failed not equal (non zero)
>
119b : 28 > plp ;restore status
>
119c : c042 > cpy #$42
> trap_ne ;y changed
119e : d0fe > bne * ;failed not equal (non zero)
>
11a0 : e000 > cpx #0
> trap_ne ;x changed
11a2 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $a3,1
11a4 : a042 > ldy #$42
11a6 : a203 > ldx #4-1
11a8 : a3 > db $a3 ;test nop length
> if 1 = 1
11a9 : ca > dex
11aa : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
11ab : ca > dex
> trap_ne ;wrong number of bytes
11ac : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$a3,0
> load_flag 0
11ae : a900 > lda #0 ;allow test to change I-flag (no mask)
>
11b0 : 48 > pha ;use stack to load status
11b1 : a95c > lda #$ff-$a3 ;precharge accu
11b3 : 28 > plp
>
11b4 : a3 > db $a3 ;test nop integrity - flags off
11b5 : ea > nop
11b6 : ea > nop
> tst_a $ff-$a3,0
11b7 : 08 > php ;save flags
11b8 : c95c > cmp #$ff-$a3 ;test result
> trap_ne
11ba : d0fe > bne * ;failed not equal (non zero)
>
11bc : 68 > pla ;load status
11bd : 48 > pha
> cmp_flag 0
11be : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
11c0 : d0fe > bne * ;failed not equal (non zero)
>
11c2 : 28 > plp ;restore status
>
> set_a $aa-$a3,$ff
> load_flag $ff
11c3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
11c5 : 48 > pha ;use stack to load status
11c6 : a907 > lda #$aa-$a3 ;precharge accu
11c8 : 28 > plp
>
11c9 : a3 > db $a3 ;test nop integrity - flags on
11ca : ea > nop
11cb : ea > nop
> tst_a $aa-$a3,$ff
11cc : 08 > php ;save flags
11cd : c907 > cmp #$aa-$a3 ;test result
> trap_ne
11cf : d0fe > bne * ;failed not equal (non zero)
>
11d1 : 68 > pla ;load status
11d2 : 48 > pha
> cmp_flag $ff
11d3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
11d5 : d0fe > bne * ;failed not equal (non zero)
>
11d7 : 28 > plp ;restore status
>
11d8 : c042 > cpy #$42
> trap_ne ;y changed
11da : d0fe > bne * ;failed not equal (non zero)
>
11dc : e000 > cpx #0
> trap_ne ;x changed
11de : d0fe > bne * ;failed not equal (non zero)
>
nop_test $b3,1
11e0 : a042 > ldy #$42
11e2 : a203 > ldx #4-1
11e4 : b3 > db $b3 ;test nop length
> if 1 = 1
11e5 : ca > dex
11e6 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
11e7 : ca > dex
> trap_ne ;wrong number of bytes
11e8 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$b3,0
> load_flag 0
11ea : a900 > lda #0 ;allow test to change I-flag (no mask)
>
11ec : 48 > pha ;use stack to load status
11ed : a94c > lda #$ff-$b3 ;precharge accu
11ef : 28 > plp
>
11f0 : b3 > db $b3 ;test nop integrity - flags off
11f1 : ea > nop
11f2 : ea > nop
> tst_a $ff-$b3,0
11f3 : 08 > php ;save flags
11f4 : c94c > cmp #$ff-$b3 ;test result
> trap_ne
11f6 : d0fe > bne * ;failed not equal (non zero)
>
11f8 : 68 > pla ;load status
11f9 : 48 > pha
> cmp_flag 0
11fa : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
11fc : d0fe > bne * ;failed not equal (non zero)
>
11fe : 28 > plp ;restore status
>
> set_a $aa-$b3,$ff
> load_flag $ff
11ff : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1201 : 48 > pha ;use stack to load status
1202 : a9f7 > lda #$aa-$b3 ;precharge accu
1204 : 28 > plp
>
1205 : b3 > db $b3 ;test nop integrity - flags on
1206 : ea > nop
1207 : ea > nop
> tst_a $aa-$b3,$ff
1208 : 08 > php ;save flags
1209 : c9f7 > cmp #$aa-$b3 ;test result
> trap_ne
120b : d0fe > bne * ;failed not equal (non zero)
>
120d : 68 > pla ;load status
120e : 48 > pha
> cmp_flag $ff
120f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1211 : d0fe > bne * ;failed not equal (non zero)
>
1213 : 28 > plp ;restore status
>
1214 : c042 > cpy #$42
> trap_ne ;y changed
1216 : d0fe > bne * ;failed not equal (non zero)
>
1218 : e000 > cpx #0
> trap_ne ;x changed
121a : d0fe > bne * ;failed not equal (non zero)
>
nop_test $c3,1
121c : a042 > ldy #$42
121e : a203 > ldx #4-1
1220 : c3 > db $c3 ;test nop length
> if 1 = 1
1221 : ca > dex
1222 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
1223 : ca > dex
> trap_ne ;wrong number of bytes
1224 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$c3,0
> load_flag 0
1226 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1228 : 48 > pha ;use stack to load status
1229 : a93c > lda #$ff-$c3 ;precharge accu
122b : 28 > plp
>
122c : c3 > db $c3 ;test nop integrity - flags off
122d : ea > nop
122e : ea > nop
> tst_a $ff-$c3,0
122f : 08 > php ;save flags
1230 : c93c > cmp #$ff-$c3 ;test result
> trap_ne
1232 : d0fe > bne * ;failed not equal (non zero)
>
1234 : 68 > pla ;load status
1235 : 48 > pha
> cmp_flag 0
1236 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1238 : d0fe > bne * ;failed not equal (non zero)
>
123a : 28 > plp ;restore status
>
> set_a $aa-$c3,$ff
> load_flag $ff
123b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
123d : 48 > pha ;use stack to load status
123e : a9e7 > lda #$aa-$c3 ;precharge accu
1240 : 28 > plp
>
1241 : c3 > db $c3 ;test nop integrity - flags on
1242 : ea > nop
1243 : ea > nop
> tst_a $aa-$c3,$ff
1244 : 08 > php ;save flags
1245 : c9e7 > cmp #$aa-$c3 ;test result
> trap_ne
1247 : d0fe > bne * ;failed not equal (non zero)
>
1249 : 68 > pla ;load status
124a : 48 > pha
> cmp_flag $ff
124b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
124d : d0fe > bne * ;failed not equal (non zero)
>
124f : 28 > plp ;restore status
>
1250 : c042 > cpy #$42
> trap_ne ;y changed
1252 : d0fe > bne * ;failed not equal (non zero)
>
1254 : e000 > cpx #0
> trap_ne ;x changed
1256 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $d3,1
1258 : a042 > ldy #$42
125a : a203 > ldx #4-1
125c : d3 > db $d3 ;test nop length
> if 1 = 1
125d : ca > dex
125e : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
125f : ca > dex
> trap_ne ;wrong number of bytes
1260 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$d3,0
> load_flag 0
1262 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1264 : 48 > pha ;use stack to load status
1265 : a92c > lda #$ff-$d3 ;precharge accu
1267 : 28 > plp
>
1268 : d3 > db $d3 ;test nop integrity - flags off
1269 : ea > nop
126a : ea > nop
> tst_a $ff-$d3,0
126b : 08 > php ;save flags
126c : c92c > cmp #$ff-$d3 ;test result
> trap_ne
126e : d0fe > bne * ;failed not equal (non zero)
>
1270 : 68 > pla ;load status
1271 : 48 > pha
> cmp_flag 0
1272 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1274 : d0fe > bne * ;failed not equal (non zero)
>
1276 : 28 > plp ;restore status
>
> set_a $aa-$d3,$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 : a9d7 > lda #$aa-$d3 ;precharge accu
127c : 28 > plp
>
127d : d3 > db $d3 ;test nop integrity - flags on
127e : ea > nop
127f : ea > nop
> tst_a $aa-$d3,$ff
1280 : 08 > php ;save flags
1281 : c9d7 > cmp #$aa-$d3 ;test result
> trap_ne
1283 : d0fe > bne * ;failed not equal (non zero)
>
1285 : 68 > pla ;load status
1286 : 48 > pha
> cmp_flag $ff
1287 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1289 : d0fe > bne * ;failed not equal (non zero)
>
128b : 28 > plp ;restore status
>
128c : c042 > cpy #$42
> trap_ne ;y changed
128e : d0fe > bne * ;failed not equal (non zero)
>
1290 : e000 > cpx #0
> trap_ne ;x changed
1292 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $e3,1
1294 : a042 > ldy #$42
1296 : a203 > ldx #4-1
1298 : e3 > db $e3 ;test nop length
> if 1 = 1
1299 : ca > dex
129a : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
129b : ca > dex
> trap_ne ;wrong number of bytes
129c : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$e3,0
> load_flag 0
129e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
12a0 : 48 > pha ;use stack to load status
12a1 : a91c > lda #$ff-$e3 ;precharge accu
12a3 : 28 > plp
>
12a4 : e3 > db $e3 ;test nop integrity - flags off
12a5 : ea > nop
12a6 : ea > nop
> tst_a $ff-$e3,0
12a7 : 08 > php ;save flags
12a8 : c91c > cmp #$ff-$e3 ;test result
> trap_ne
12aa : d0fe > bne * ;failed not equal (non zero)
>
12ac : 68 > pla ;load status
12ad : 48 > pha
> cmp_flag 0
12ae : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
12b0 : d0fe > bne * ;failed not equal (non zero)
>
12b2 : 28 > plp ;restore status
>
> set_a $aa-$e3,$ff
> load_flag $ff
12b3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
12b5 : 48 > pha ;use stack to load status
12b6 : a9c7 > lda #$aa-$e3 ;precharge accu
12b8 : 28 > plp
>
12b9 : e3 > db $e3 ;test nop integrity - flags on
12ba : ea > nop
12bb : ea > nop
> tst_a $aa-$e3,$ff
12bc : 08 > php ;save flags
12bd : c9c7 > cmp #$aa-$e3 ;test result
> trap_ne
12bf : d0fe > bne * ;failed not equal (non zero)
>
12c1 : 68 > pla ;load status
12c2 : 48 > pha
> cmp_flag $ff
12c3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
12c5 : d0fe > bne * ;failed not equal (non zero)
>
12c7 : 28 > plp ;restore status
>
12c8 : c042 > cpy #$42
> trap_ne ;y changed
12ca : d0fe > bne * ;failed not equal (non zero)
>
12cc : e000 > cpx #0
> trap_ne ;x changed
12ce : d0fe > bne * ;failed not equal (non zero)
>
nop_test $f3,1
12d0 : a042 > ldy #$42
12d2 : a203 > ldx #4-1
12d4 : f3 > db $f3 ;test nop length
> if 1 = 1
12d5 : ca > dex
12d6 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
12d7 : ca > dex
> trap_ne ;wrong number of bytes
12d8 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$f3,0
> load_flag 0
12da : a900 > lda #0 ;allow test to change I-flag (no mask)
>
12dc : 48 > pha ;use stack to load status
12dd : a90c > lda #$ff-$f3 ;precharge accu
12df : 28 > plp
>
12e0 : f3 > db $f3 ;test nop integrity - flags off
12e1 : ea > nop
12e2 : ea > nop
> tst_a $ff-$f3,0
12e3 : 08 > php ;save flags
12e4 : c90c > cmp #$ff-$f3 ;test result
> trap_ne
12e6 : d0fe > bne * ;failed not equal (non zero)
>
12e8 : 68 > pla ;load status
12e9 : 48 > pha
> cmp_flag 0
12ea : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
12ec : d0fe > bne * ;failed not equal (non zero)
>
12ee : 28 > plp ;restore status
>
> set_a $aa-$f3,$ff
> load_flag $ff
12ef : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
12f1 : 48 > pha ;use stack to load status
12f2 : a9b7 > lda #$aa-$f3 ;precharge accu
12f4 : 28 > plp
>
12f5 : f3 > db $f3 ;test nop integrity - flags on
12f6 : ea > nop
12f7 : ea > nop
> tst_a $aa-$f3,$ff
12f8 : 08 > php ;save flags
12f9 : c9b7 > cmp #$aa-$f3 ;test result
> trap_ne
12fb : d0fe > bne * ;failed not equal (non zero)
>
12fd : 68 > pla ;load status
12fe : 48 > pha
> cmp_flag $ff
12ff : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1301 : d0fe > bne * ;failed not equal (non zero)
>
1303 : 28 > plp ;restore status
>
1304 : c042 > cpy #$42
> trap_ne ;y changed
1306 : d0fe > bne * ;failed not equal (non zero)
>
1308 : e000 > cpx #0
> trap_ne ;x changed
130a : d0fe > bne * ;failed not equal (non zero)
>
nop_test $0b,1
130c : a042 > ldy #$42
130e : a203 > ldx #4-1
1310 : 0b > db $0b ;test nop length
> if 1 = 1
1311 : ca > dex
1312 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
1313 : ca > dex
> trap_ne ;wrong number of bytes
1314 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$0b,0
> load_flag 0
1316 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1318 : 48 > pha ;use stack to load status
1319 : a9f4 > lda #$ff-$0b ;precharge accu
131b : 28 > plp
>
131c : 0b > db $0b ;test nop integrity - flags off
131d : ea > nop
131e : ea > nop
> tst_a $ff-$0b,0
131f : 08 > php ;save flags
1320 : c9f4 > cmp #$ff-$0b ;test result
> trap_ne
1322 : d0fe > bne * ;failed not equal (non zero)
>
1324 : 68 > pla ;load status
1325 : 48 > pha
> cmp_flag 0
1326 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1328 : d0fe > bne * ;failed not equal (non zero)
>
132a : 28 > plp ;restore status
>
> set_a $aa-$0b,$ff
> load_flag $ff
132b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
132d : 48 > pha ;use stack to load status
132e : a99f > lda #$aa-$0b ;precharge accu
1330 : 28 > plp
>
1331 : 0b > db $0b ;test nop integrity - flags on
1332 : ea > nop
1333 : ea > nop
> tst_a $aa-$0b,$ff
1334 : 08 > php ;save flags
1335 : c99f > cmp #$aa-$0b ;test result
> trap_ne
1337 : d0fe > bne * ;failed not equal (non zero)
>
1339 : 68 > pla ;load status
133a : 48 > pha
> cmp_flag $ff
133b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
133d : d0fe > bne * ;failed not equal (non zero)
>
133f : 28 > plp ;restore status
>
1340 : c042 > cpy #$42
> trap_ne ;y changed
1342 : d0fe > bne * ;failed not equal (non zero)
>
1344 : e000 > cpx #0
> trap_ne ;x changed
1346 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $1b,1
1348 : a042 > ldy #$42
134a : a203 > ldx #4-1
134c : 1b > db $1b ;test nop length
> if 1 = 1
134d : ca > dex
134e : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
134f : ca > dex
> trap_ne ;wrong number of bytes
1350 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$1b,0
> load_flag 0
1352 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1354 : 48 > pha ;use stack to load status
1355 : a9e4 > lda #$ff-$1b ;precharge accu
1357 : 28 > plp
>
1358 : 1b > db $1b ;test nop integrity - flags off
1359 : ea > nop
135a : ea > nop
> tst_a $ff-$1b,0
135b : 08 > php ;save flags
135c : c9e4 > cmp #$ff-$1b ;test result
> trap_ne
135e : d0fe > bne * ;failed not equal (non zero)
>
1360 : 68 > pla ;load status
1361 : 48 > pha
> cmp_flag 0
1362 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1364 : d0fe > bne * ;failed not equal (non zero)
>
1366 : 28 > plp ;restore status
>
> set_a $aa-$1b,$ff
> load_flag $ff
1367 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1369 : 48 > pha ;use stack to load status
136a : a98f > lda #$aa-$1b ;precharge accu
136c : 28 > plp
>
136d : 1b > db $1b ;test nop integrity - flags on
136e : ea > nop
136f : ea > nop
> tst_a $aa-$1b,$ff
1370 : 08 > php ;save flags
1371 : c98f > cmp #$aa-$1b ;test result
> trap_ne
1373 : d0fe > bne * ;failed not equal (non zero)
>
1375 : 68 > pla ;load status
1376 : 48 > pha
> cmp_flag $ff
1377 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1379 : d0fe > bne * ;failed not equal (non zero)
>
137b : 28 > plp ;restore status
>
137c : c042 > cpy #$42
> trap_ne ;y changed
137e : d0fe > bne * ;failed not equal (non zero)
>
1380 : e000 > cpx #0
> trap_ne ;x changed
1382 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $2b,1
1384 : a042 > ldy #$42
1386 : a203 > ldx #4-1
1388 : 2b > db $2b ;test nop length
> if 1 = 1
1389 : ca > dex
138a : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
138b : ca > dex
> trap_ne ;wrong number of bytes
138c : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$2b,0
> load_flag 0
138e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1390 : 48 > pha ;use stack to load status
1391 : a9d4 > lda #$ff-$2b ;precharge accu
1393 : 28 > plp
>
1394 : 2b > db $2b ;test nop integrity - flags off
1395 : ea > nop
1396 : ea > nop
> tst_a $ff-$2b,0
1397 : 08 > php ;save flags
1398 : c9d4 > cmp #$ff-$2b ;test result
> trap_ne
139a : d0fe > bne * ;failed not equal (non zero)
>
139c : 68 > pla ;load status
139d : 48 > pha
> cmp_flag 0
139e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
13a0 : d0fe > bne * ;failed not equal (non zero)
>
13a2 : 28 > plp ;restore status
>
> set_a $aa-$2b,$ff
> load_flag $ff
13a3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
13a5 : 48 > pha ;use stack to load status
13a6 : a97f > lda #$aa-$2b ;precharge accu
13a8 : 28 > plp
>
13a9 : 2b > db $2b ;test nop integrity - flags on
13aa : ea > nop
13ab : ea > nop
> tst_a $aa-$2b,$ff
13ac : 08 > php ;save flags
13ad : c97f > cmp #$aa-$2b ;test result
> trap_ne
13af : d0fe > bne * ;failed not equal (non zero)
>
13b1 : 68 > pla ;load status
13b2 : 48 > pha
> cmp_flag $ff
13b3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
13b5 : d0fe > bne * ;failed not equal (non zero)
>
13b7 : 28 > plp ;restore status
>
13b8 : c042 > cpy #$42
> trap_ne ;y changed
13ba : d0fe > bne * ;failed not equal (non zero)
>
13bc : e000 > cpx #0
> trap_ne ;x changed
13be : d0fe > bne * ;failed not equal (non zero)
>
nop_test $3b,1
13c0 : a042 > ldy #$42
13c2 : a203 > ldx #4-1
13c4 : 3b > db $3b ;test nop length
> if 1 = 1
13c5 : ca > dex
13c6 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
13c7 : ca > dex
> trap_ne ;wrong number of bytes
13c8 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$3b,0
> load_flag 0
13ca : a900 > lda #0 ;allow test to change I-flag (no mask)
>
13cc : 48 > pha ;use stack to load status
13cd : a9c4 > lda #$ff-$3b ;precharge accu
13cf : 28 > plp
>
13d0 : 3b > db $3b ;test nop integrity - flags off
13d1 : ea > nop
13d2 : ea > nop
> tst_a $ff-$3b,0
13d3 : 08 > php ;save flags
13d4 : c9c4 > cmp #$ff-$3b ;test result
> trap_ne
13d6 : d0fe > bne * ;failed not equal (non zero)
>
13d8 : 68 > pla ;load status
13d9 : 48 > pha
> cmp_flag 0
13da : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
13dc : d0fe > bne * ;failed not equal (non zero)
>
13de : 28 > plp ;restore status
>
> set_a $aa-$3b,$ff
> load_flag $ff
13df : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
13e1 : 48 > pha ;use stack to load status
13e2 : a96f > lda #$aa-$3b ;precharge accu
13e4 : 28 > plp
>
13e5 : 3b > db $3b ;test nop integrity - flags on
13e6 : ea > nop
13e7 : ea > nop
> tst_a $aa-$3b,$ff
13e8 : 08 > php ;save flags
13e9 : c96f > cmp #$aa-$3b ;test result
> trap_ne
13eb : d0fe > bne * ;failed not equal (non zero)
>
13ed : 68 > pla ;load status
13ee : 48 > pha
> cmp_flag $ff
13ef : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
13f1 : d0fe > bne * ;failed not equal (non zero)
>
13f3 : 28 > plp ;restore status
>
13f4 : c042 > cpy #$42
> trap_ne ;y changed
13f6 : d0fe > bne * ;failed not equal (non zero)
>
13f8 : e000 > cpx #0
> trap_ne ;x changed
13fa : d0fe > bne * ;failed not equal (non zero)
>
nop_test $4b,1
13fc : a042 > ldy #$42
13fe : a203 > ldx #4-1
1400 : 4b > db $4b ;test nop length
> if 1 = 1
1401 : ca > dex
1402 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
1403 : ca > dex
> trap_ne ;wrong number of bytes
1404 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$4b,0
> load_flag 0
1406 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1408 : 48 > pha ;use stack to load status
1409 : a9b4 > lda #$ff-$4b ;precharge accu
140b : 28 > plp
>
140c : 4b > db $4b ;test nop integrity - flags off
140d : ea > nop
140e : ea > nop
> tst_a $ff-$4b,0
140f : 08 > php ;save flags
1410 : c9b4 > cmp #$ff-$4b ;test result
> trap_ne
1412 : d0fe > bne * ;failed not equal (non zero)
>
1414 : 68 > pla ;load status
1415 : 48 > pha
> cmp_flag 0
1416 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1418 : d0fe > bne * ;failed not equal (non zero)
>
141a : 28 > plp ;restore status
>
> set_a $aa-$4b,$ff
> load_flag $ff
141b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
141d : 48 > pha ;use stack to load status
141e : a95f > lda #$aa-$4b ;precharge accu
1420 : 28 > plp
>
1421 : 4b > db $4b ;test nop integrity - flags on
1422 : ea > nop
1423 : ea > nop
> tst_a $aa-$4b,$ff
1424 : 08 > php ;save flags
1425 : c95f > cmp #$aa-$4b ;test result
> trap_ne
1427 : d0fe > bne * ;failed not equal (non zero)
>
1429 : 68 > pla ;load status
142a : 48 > pha
> cmp_flag $ff
142b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
142d : d0fe > bne * ;failed not equal (non zero)
>
142f : 28 > plp ;restore status
>
1430 : c042 > cpy #$42
> trap_ne ;y changed
1432 : d0fe > bne * ;failed not equal (non zero)
>
1434 : e000 > cpx #0
> trap_ne ;x changed
1436 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $5b,1
1438 : a042 > ldy #$42
143a : a203 > ldx #4-1
143c : 5b > db $5b ;test nop length
> if 1 = 1
143d : ca > dex
143e : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
143f : ca > dex
> trap_ne ;wrong number of bytes
1440 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$5b,0
> load_flag 0
1442 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1444 : 48 > pha ;use stack to load status
1445 : a9a4 > lda #$ff-$5b ;precharge accu
1447 : 28 > plp
>
1448 : 5b > db $5b ;test nop integrity - flags off
1449 : ea > nop
144a : ea > nop
> tst_a $ff-$5b,0
144b : 08 > php ;save flags
144c : c9a4 > cmp #$ff-$5b ;test result
> trap_ne
144e : d0fe > bne * ;failed not equal (non zero)
>
1450 : 68 > pla ;load status
1451 : 48 > pha
> cmp_flag 0
1452 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1454 : d0fe > bne * ;failed not equal (non zero)
>
1456 : 28 > plp ;restore status
>
> set_a $aa-$5b,$ff
> load_flag $ff
1457 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1459 : 48 > pha ;use stack to load status
145a : a94f > lda #$aa-$5b ;precharge accu
145c : 28 > plp
>
145d : 5b > db $5b ;test nop integrity - flags on
145e : ea > nop
145f : ea > nop
> tst_a $aa-$5b,$ff
1460 : 08 > php ;save flags
1461 : c94f > cmp #$aa-$5b ;test result
> trap_ne
1463 : d0fe > bne * ;failed not equal (non zero)
>
1465 : 68 > pla ;load status
1466 : 48 > pha
> cmp_flag $ff
1467 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1469 : d0fe > bne * ;failed not equal (non zero)
>
146b : 28 > plp ;restore status
>
146c : c042 > cpy #$42
> trap_ne ;y changed
146e : d0fe > bne * ;failed not equal (non zero)
>
1470 : e000 > cpx #0
> trap_ne ;x changed
1472 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $6b,1
1474 : a042 > ldy #$42
1476 : a203 > ldx #4-1
1478 : 6b > db $6b ;test nop length
> if 1 = 1
1479 : ca > dex
147a : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
147b : ca > dex
> trap_ne ;wrong number of bytes
147c : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$6b,0
> load_flag 0
147e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1480 : 48 > pha ;use stack to load status
1481 : a994 > lda #$ff-$6b ;precharge accu
1483 : 28 > plp
>
1484 : 6b > db $6b ;test nop integrity - flags off
1485 : ea > nop
1486 : ea > nop
> tst_a $ff-$6b,0
1487 : 08 > php ;save flags
1488 : c994 > cmp #$ff-$6b ;test result
> trap_ne
148a : d0fe > bne * ;failed not equal (non zero)
>
148c : 68 > pla ;load status
148d : 48 > pha
> cmp_flag 0
148e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1490 : d0fe > bne * ;failed not equal (non zero)
>
1492 : 28 > plp ;restore status
>
> set_a $aa-$6b,$ff
> load_flag $ff
1493 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1495 : 48 > pha ;use stack to load status
1496 : a93f > lda #$aa-$6b ;precharge accu
1498 : 28 > plp
>
1499 : 6b > db $6b ;test nop integrity - flags on
149a : ea > nop
149b : ea > nop
> tst_a $aa-$6b,$ff
149c : 08 > php ;save flags
149d : c93f > cmp #$aa-$6b ;test result
> trap_ne
149f : d0fe > bne * ;failed not equal (non zero)
>
14a1 : 68 > pla ;load status
14a2 : 48 > pha
> cmp_flag $ff
14a3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
14a5 : d0fe > bne * ;failed not equal (non zero)
>
14a7 : 28 > plp ;restore status
>
14a8 : c042 > cpy #$42
> trap_ne ;y changed
14aa : d0fe > bne * ;failed not equal (non zero)
>
14ac : e000 > cpx #0
> trap_ne ;x changed
14ae : d0fe > bne * ;failed not equal (non zero)
>
nop_test $7b,1
14b0 : a042 > ldy #$42
14b2 : a203 > ldx #4-1
14b4 : 7b > db $7b ;test nop length
> if 1 = 1
14b5 : ca > dex
14b6 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
14b7 : ca > dex
> trap_ne ;wrong number of bytes
14b8 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$7b,0
> load_flag 0
14ba : a900 > lda #0 ;allow test to change I-flag (no mask)
>
14bc : 48 > pha ;use stack to load status
14bd : a984 > lda #$ff-$7b ;precharge accu
14bf : 28 > plp
>
14c0 : 7b > db $7b ;test nop integrity - flags off
14c1 : ea > nop
14c2 : ea > nop
> tst_a $ff-$7b,0
14c3 : 08 > php ;save flags
14c4 : c984 > cmp #$ff-$7b ;test result
> trap_ne
14c6 : d0fe > bne * ;failed not equal (non zero)
>
14c8 : 68 > pla ;load status
14c9 : 48 > pha
> cmp_flag 0
14ca : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
14cc : d0fe > bne * ;failed not equal (non zero)
>
14ce : 28 > plp ;restore status
>
> set_a $aa-$7b,$ff
> load_flag $ff
14cf : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
14d1 : 48 > pha ;use stack to load status
14d2 : a92f > lda #$aa-$7b ;precharge accu
14d4 : 28 > plp
>
14d5 : 7b > db $7b ;test nop integrity - flags on
14d6 : ea > nop
14d7 : ea > nop
> tst_a $aa-$7b,$ff
14d8 : 08 > php ;save flags
14d9 : c92f > cmp #$aa-$7b ;test result
> trap_ne
14db : d0fe > bne * ;failed not equal (non zero)
>
14dd : 68 > pla ;load status
14de : 48 > pha
> cmp_flag $ff
14df : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
14e1 : d0fe > bne * ;failed not equal (non zero)
>
14e3 : 28 > plp ;restore status
>
14e4 : c042 > cpy #$42
> trap_ne ;y changed
14e6 : d0fe > bne * ;failed not equal (non zero)
>
14e8 : e000 > cpx #0
> trap_ne ;x changed
14ea : d0fe > bne * ;failed not equal (non zero)
>
nop_test $8b,1
14ec : a042 > ldy #$42
14ee : a203 > ldx #4-1
14f0 : 8b > db $8b ;test nop length
> if 1 = 1
14f1 : ca > dex
14f2 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
14f3 : ca > dex
> trap_ne ;wrong number of bytes
14f4 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$8b,0
> load_flag 0
14f6 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
14f8 : 48 > pha ;use stack to load status
14f9 : a974 > lda #$ff-$8b ;precharge accu
14fb : 28 > plp
>
14fc : 8b > db $8b ;test nop integrity - flags off
14fd : ea > nop
14fe : ea > nop
> tst_a $ff-$8b,0
14ff : 08 > php ;save flags
1500 : c974 > cmp #$ff-$8b ;test result
> trap_ne
1502 : d0fe > bne * ;failed not equal (non zero)
>
1504 : 68 > pla ;load status
1505 : 48 > pha
> cmp_flag 0
1506 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1508 : d0fe > bne * ;failed not equal (non zero)
>
150a : 28 > plp ;restore status
>
> set_a $aa-$8b,$ff
> load_flag $ff
150b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
150d : 48 > pha ;use stack to load status
150e : a91f > lda #$aa-$8b ;precharge accu
1510 : 28 > plp
>
1511 : 8b > db $8b ;test nop integrity - flags on
1512 : ea > nop
1513 : ea > nop
> tst_a $aa-$8b,$ff
1514 : 08 > php ;save flags
1515 : c91f > cmp #$aa-$8b ;test result
> trap_ne
1517 : d0fe > bne * ;failed not equal (non zero)
>
1519 : 68 > pla ;load status
151a : 48 > pha
> cmp_flag $ff
151b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
151d : d0fe > bne * ;failed not equal (non zero)
>
151f : 28 > plp ;restore status
>
1520 : c042 > cpy #$42
> trap_ne ;y changed
1522 : d0fe > bne * ;failed not equal (non zero)
>
1524 : e000 > cpx #0
> trap_ne ;x changed
1526 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $9b,1
1528 : a042 > ldy #$42
152a : a203 > ldx #4-1
152c : 9b > db $9b ;test nop length
> if 1 = 1
152d : ca > dex
152e : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
152f : ca > dex
> trap_ne ;wrong number of bytes
1530 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$9b,0
> load_flag 0
1532 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1534 : 48 > pha ;use stack to load status
1535 : a964 > lda #$ff-$9b ;precharge accu
1537 : 28 > plp
>
1538 : 9b > db $9b ;test nop integrity - flags off
1539 : ea > nop
153a : ea > nop
> tst_a $ff-$9b,0
153b : 08 > php ;save flags
153c : c964 > cmp #$ff-$9b ;test result
> trap_ne
153e : d0fe > bne * ;failed not equal (non zero)
>
1540 : 68 > pla ;load status
1541 : 48 > pha
> cmp_flag 0
1542 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1544 : d0fe > bne * ;failed not equal (non zero)
>
1546 : 28 > plp ;restore status
>
> set_a $aa-$9b,$ff
> load_flag $ff
1547 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1549 : 48 > pha ;use stack to load status
154a : a90f > lda #$aa-$9b ;precharge accu
154c : 28 > plp
>
154d : 9b > db $9b ;test nop integrity - flags on
154e : ea > nop
154f : ea > nop
> tst_a $aa-$9b,$ff
1550 : 08 > php ;save flags
1551 : c90f > cmp #$aa-$9b ;test result
> trap_ne
1553 : d0fe > bne * ;failed not equal (non zero)
>
1555 : 68 > pla ;load status
1556 : 48 > pha
> cmp_flag $ff
1557 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1559 : d0fe > bne * ;failed not equal (non zero)
>
155b : 28 > plp ;restore status
>
155c : c042 > cpy #$42
> trap_ne ;y changed
155e : d0fe > bne * ;failed not equal (non zero)
>
1560 : e000 > cpx #0
> trap_ne ;x changed
1562 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $ab,1
1564 : a042 > ldy #$42
1566 : a203 > ldx #4-1
1568 : ab > db $ab ;test nop length
> if 1 = 1
1569 : ca > dex
156a : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
156b : ca > dex
> trap_ne ;wrong number of bytes
156c : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$ab,0
> load_flag 0
156e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1570 : 48 > pha ;use stack to load status
1571 : a954 > lda #$ff-$ab ;precharge accu
1573 : 28 > plp
>
1574 : ab > db $ab ;test nop integrity - flags off
1575 : ea > nop
1576 : ea > nop
> tst_a $ff-$ab,0
1577 : 08 > php ;save flags
1578 : c954 > cmp #$ff-$ab ;test result
> trap_ne
157a : d0fe > bne * ;failed not equal (non zero)
>
157c : 68 > pla ;load status
157d : 48 > pha
> cmp_flag 0
157e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1580 : d0fe > bne * ;failed not equal (non zero)
>
1582 : 28 > plp ;restore status
>
> set_a $aa-$ab,$ff
> load_flag $ff
1583 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1585 : 48 > pha ;use stack to load status
1586 : a9ff > lda #$aa-$ab ;precharge accu
1588 : 28 > plp
>
1589 : ab > db $ab ;test nop integrity - flags on
158a : ea > nop
158b : ea > nop
> tst_a $aa-$ab,$ff
158c : 08 > php ;save flags
158d : c9ff > cmp #$aa-$ab ;test result
> trap_ne
158f : d0fe > bne * ;failed not equal (non zero)
>
1591 : 68 > pla ;load status
1592 : 48 > pha
> cmp_flag $ff
1593 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1595 : d0fe > bne * ;failed not equal (non zero)
>
1597 : 28 > plp ;restore status
>
1598 : c042 > cpy #$42
> trap_ne ;y changed
159a : d0fe > bne * ;failed not equal (non zero)
>
159c : e000 > cpx #0
> trap_ne ;x changed
159e : d0fe > bne * ;failed not equal (non zero)
>
nop_test $bb,1
15a0 : a042 > ldy #$42
15a2 : a203 > ldx #4-1
15a4 : bb > db $bb ;test nop length
> if 1 = 1
15a5 : ca > dex
15a6 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
15a7 : ca > dex
> trap_ne ;wrong number of bytes
15a8 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$bb,0
> load_flag 0
15aa : a900 > lda #0 ;allow test to change I-flag (no mask)
>
15ac : 48 > pha ;use stack to load status
15ad : a944 > lda #$ff-$bb ;precharge accu
15af : 28 > plp
>
15b0 : bb > db $bb ;test nop integrity - flags off
15b1 : ea > nop
15b2 : ea > nop
> tst_a $ff-$bb,0
15b3 : 08 > php ;save flags
15b4 : c944 > cmp #$ff-$bb ;test result
> trap_ne
15b6 : d0fe > bne * ;failed not equal (non zero)
>
15b8 : 68 > pla ;load status
15b9 : 48 > pha
> cmp_flag 0
15ba : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
15bc : d0fe > bne * ;failed not equal (non zero)
>
15be : 28 > plp ;restore status
>
> set_a $aa-$bb,$ff
> load_flag $ff
15bf : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
15c1 : 48 > pha ;use stack to load status
15c2 : a9ef > lda #$aa-$bb ;precharge accu
15c4 : 28 > plp
>
15c5 : bb > db $bb ;test nop integrity - flags on
15c6 : ea > nop
15c7 : ea > nop
> tst_a $aa-$bb,$ff
15c8 : 08 > php ;save flags
15c9 : c9ef > cmp #$aa-$bb ;test result
> trap_ne
15cb : d0fe > bne * ;failed not equal (non zero)
>
15cd : 68 > pla ;load status
15ce : 48 > pha
> cmp_flag $ff
15cf : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
15d1 : d0fe > bne * ;failed not equal (non zero)
>
15d3 : 28 > plp ;restore status
>
15d4 : c042 > cpy #$42
> trap_ne ;y changed
15d6 : d0fe > bne * ;failed not equal (non zero)
>
15d8 : e000 > cpx #0
> trap_ne ;x changed
15da : d0fe > bne * ;failed not equal (non zero)
>
nop_test $eb,1
15dc : a042 > ldy #$42
15de : a203 > ldx #4-1
15e0 : eb > db $eb ;test nop length
> if 1 = 1
15e1 : ca > dex
15e2 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
15e3 : ca > dex
> trap_ne ;wrong number of bytes
15e4 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$eb,0
> load_flag 0
15e6 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
15e8 : 48 > pha ;use stack to load status
15e9 : a914 > lda #$ff-$eb ;precharge accu
15eb : 28 > plp
>
15ec : eb > db $eb ;test nop integrity - flags off
15ed : ea > nop
15ee : ea > nop
> tst_a $ff-$eb,0
15ef : 08 > php ;save flags
15f0 : c914 > cmp #$ff-$eb ;test result
> trap_ne
15f2 : d0fe > bne * ;failed not equal (non zero)
>
15f4 : 68 > pla ;load status
15f5 : 48 > pha
> cmp_flag 0
15f6 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
15f8 : d0fe > bne * ;failed not equal (non zero)
>
15fa : 28 > plp ;restore status
>
> set_a $aa-$eb,$ff
> load_flag $ff
15fb : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
15fd : 48 > pha ;use stack to load status
15fe : a9bf > lda #$aa-$eb ;precharge accu
1600 : 28 > plp
>
1601 : eb > db $eb ;test nop integrity - flags on
1602 : ea > nop
1603 : ea > nop
> tst_a $aa-$eb,$ff
1604 : 08 > php ;save flags
1605 : c9bf > cmp #$aa-$eb ;test result
> trap_ne
1607 : d0fe > bne * ;failed not equal (non zero)
>
1609 : 68 > pla ;load status
160a : 48 > pha
> cmp_flag $ff
160b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
160d : d0fe > bne * ;failed not equal (non zero)
>
160f : 28 > plp ;restore status
>
1610 : c042 > cpy #$42
> trap_ne ;y changed
1612 : d0fe > bne * ;failed not equal (non zero)
>
1614 : e000 > cpx #0
> trap_ne ;x changed
1616 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $fb,1
1618 : a042 > ldy #$42
161a : a203 > ldx #4-1
161c : fb > db $fb ;test nop length
> if 1 = 1
161d : ca > dex
161e : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
161f : ca > dex
> trap_ne ;wrong number of bytes
1620 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$fb,0
> load_flag 0
1622 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1624 : 48 > pha ;use stack to load status
1625 : a904 > lda #$ff-$fb ;precharge accu
1627 : 28 > plp
>
1628 : fb > db $fb ;test nop integrity - flags off
1629 : ea > nop
162a : ea > nop
> tst_a $ff-$fb,0
162b : 08 > php ;save flags
162c : c904 > cmp #$ff-$fb ;test result
> trap_ne
162e : d0fe > bne * ;failed not equal (non zero)
>
1630 : 68 > pla ;load status
1631 : 48 > pha
> cmp_flag 0
1632 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1634 : d0fe > bne * ;failed not equal (non zero)
>
1636 : 28 > plp ;restore status
>
> set_a $aa-$fb,$ff
> load_flag $ff
1637 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1639 : 48 > pha ;use stack to load status
163a : a9af > lda #$aa-$fb ;precharge accu
163c : 28 > plp
>
163d : fb > db $fb ;test nop integrity - flags on
163e : ea > nop
163f : ea > nop
> tst_a $aa-$fb,$ff
1640 : 08 > php ;save flags
1641 : c9af > cmp #$aa-$fb ;test result
> trap_ne
1643 : d0fe > bne * ;failed not equal (non zero)
>
1645 : 68 > pla ;load status
1646 : 48 > pha
> cmp_flag $ff
1647 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1649 : d0fe > bne * ;failed not equal (non zero)
>
164b : 28 > plp ;restore status
>
164c : c042 > cpy #$42
> trap_ne ;y changed
164e : d0fe > bne * ;failed not equal (non zero)
>
1650 : e000 > cpx #0
> trap_ne ;x changed
1652 : d0fe > bne * ;failed not equal (non zero)
>
if rkwl_wdc_op = 0 ;NOPs not available on Rockwell & WDC 65C02
nop_test $07,1
nop_test $17,1
nop_test $27,1
nop_test $37,1
nop_test $47,1
nop_test $57,1
nop_test $67,1
nop_test $77,1
nop_test $87,1
nop_test $97,1
nop_test $a7,1
nop_test $b7,1
nop_test $c7,1
nop_test $d7,1
nop_test $e7,1
nop_test $f7,1
nop_test $0f,1
nop_test $1f,1
nop_test $2f,1
nop_test $3f,1
nop_test $4f,1
nop_test $5f,1
nop_test $6f,1
nop_test $7f,1
nop_test $8f,1
nop_test $9f,1
nop_test $af,1
nop_test $bf,1
nop_test $cf,1
nop_test $df,1
nop_test $ef,1
nop_test $ff,1
endif
if wdc_op = 0 ;NOPs not available on WDC 65C02 (WAI, STP)
nop_test $cb,1
nop_test $db,1
endif
next_test
1654 : ad0202 > lda test_case ;previous test
1657 : c908 > cmp #test_num
> trap_ne ;test is out of sequence
1659 : d0fe > bne * ;failed not equal (non zero)
>
0009 = >test_num = test_num + 1
165b : a909 > lda #test_num ;*** next tests' number
165d : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
endif
; jump indirect (test page cross bug is fixed)
1660 : a203 ldx #3 ;prepare table
1662 : bd8b26 ji1 lda ji_adr,x
1665 : 9dfd02 sta ji_tab,x
1668 : ca dex
1669 : 10f7 bpl ji1
166b : a928 lda #hi(ji_px) ;high address if page cross bug
166d : 8d0002 sta pg_x
set_stat 0
> load_flag 0
1670 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1672 : 48 > pha ;use stack to load status
1673 : 28 > plp
1674 : a949 lda #'I'
1676 : a24e ldx #'N'
1678 : a044 ldy #'D' ;N=0, V=0, Z=0, C=0
167a : 6cfd02 jmp (ji_tab)
167d : ea nop
trap_ne ;runover protection
167e : d0fe > bne * ;failed not equal (non zero)
1680 : 88 dey
1681 : 88 dey
1682 : 08 ji_ret php ;either SP or Y count will fail, if we do not hit
1683 : 88 dey
1684 : 88 dey
1685 : 88 dey
1686 : 28 plp
trap_eq ;returned flags OK?
1687 : f0fe > beq * ;failed equal (zero)
trap_pl
1689 : 10fe > bpl * ;failed plus (bit 7 clear)
trap_cc
168b : 90fe > bcc * ;failed carry clear
trap_vc
168d : 50fe > bvc * ;failed overflow clear
168f : c9e3 cmp #('I'^$aa) ;returned registers OK?
trap_ne
1691 : d0fe > bne * ;failed not equal (non zero)
1693 : e04f cpx #('N'+1)
trap_ne
1695 : d0fe > bne * ;failed not equal (non zero)
1697 : c03e cpy #('D'-6)
trap_ne
1699 : d0fe > bne * ;failed not equal (non zero)
169b : ba tsx ;SP check
169c : e0ff cpx #$ff
trap_ne
169e : d0fe > bne * ;failed not equal (non zero)
next_test
16a0 : ad0202 > lda test_case ;previous test
16a3 : c909 > cmp #test_num
> trap_ne ;test is out of sequence
16a5 : d0fe > bne * ;failed not equal (non zero)
>
000a = >test_num = test_num + 1
16a7 : a90a > lda #test_num ;*** next tests' number
16a9 : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; jump indexed indirect
16ac : a20b ldx #11 ;prepare table
16ae : bdc726 jxi1 lda jxi_adr,x
16b1 : 9df902 sta jxi_tab,x
16b4 : ca dex
16b5 : 10f7 bpl jxi1
16b7 : a927 lda #hi(jxi_px) ;high address if page cross bug
16b9 : 8d0002 sta pg_x
set_stat 0
> load_flag 0
16bc : a900 > lda #0 ;allow test to change I-flag (no mask)
>
16be : 48 > pha ;use stack to load status
16bf : 28 > plp
16c0 : a958 lda #'X'
16c2 : a204 ldx #4
16c4 : a049 ldy #'I' ;N=0, V=0, Z=0, C=0
16c6 : 7cf902 jmp (jxi_tab,x)
16c9 : ea nop
trap_ne ;runover protection
16ca : d0fe > bne * ;failed not equal (non zero)
16cc : 88 dey
16cd : 88 dey
16ce : 08 jxi_ret php ;either SP or Y count will fail, if we do not hit
16cf : 88 dey
16d0 : 88 dey
16d1 : 88 dey
16d2 : 28 plp
trap_eq ;returned flags OK?
16d3 : f0fe > beq * ;failed equal (zero)
trap_pl
16d5 : 10fe > bpl * ;failed plus (bit 7 clear)
trap_cc
16d7 : 90fe > bcc * ;failed carry clear
trap_vc
16d9 : 50fe > bvc * ;failed overflow clear
16db : c9f2 cmp #('X'^$aa) ;returned registers OK?
trap_ne
16dd : d0fe > bne * ;failed not equal (non zero)
16df : e006 cpx #6
trap_ne
16e1 : d0fe > bne * ;failed not equal (non zero)
16e3 : c043 cpy #('I'-6)
trap_ne
16e5 : d0fe > bne * ;failed not equal (non zero)
16e7 : ba tsx ;SP check
16e8 : e0ff cpx #$ff
trap_ne
16ea : d0fe > bne * ;failed not equal (non zero)
16ec : a908 lda #lo(jxp_ok) ;test with index causing a page cross
16ee : 8d0003 sta jxp_tab
16f1 : a917 lda #hi(jxp_ok)
16f3 : 8d0103 sta jxp_tab+1
16f6 : a905 lda #lo(jxp_px)
16f8 : 8d0002 sta pg_x
16fb : a917 lda #hi(jxp_px)
16fd : 8d0102 sta pg_x+1
1700 : a2ff ldx #$ff
1702 : 7c0102 jmp (jxp_tab-$ff,x)
1705 : jxp_px
trap ;page cross by index to wrong page
1705 : 4c0517 > jmp * ;failed anyway
1708 : jxp_ok
next_test
1708 : ad0202 > lda test_case ;previous test
170b : c90a > cmp #test_num
> trap_ne ;test is out of sequence
170d : d0fe > bne * ;failed not equal (non zero)
>
000b = >test_num = test_num + 1
170f : a90b > lda #test_num ;*** next tests' number
1711 : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
if ROM_vectors = 1
; test BRK clears decimal mode
load_flag 0 ;with interrupts enabled if allowed!
1714 : a900 > lda #0 ;allow test to change I-flag (no mask)
1716 : 48 pha
1717 : a942 lda #'B'
1719 : a252 ldx #'R'
171b : a04b ldy #'K'
171d : 28 plp ;N=0, V=0, Z=0, C=0
171e : 00 brk
171f : 88 dey ;should not be executed
1720 : brk_ret0 ;address of break return
1720 : 08 php ;either SP or Y count will fail, if we do not hit
1721 : 88 dey
1722 : 88 dey
1723 : 88 dey
1724 : c9e8 cmp #'B'^$aa ;returned registers OK?
;the IRQ vector was never executed if A & X stay unmodified
trap_ne
1726 : d0fe > bne * ;failed not equal (non zero)
1728 : e053 cpx #'R'+1
trap_ne
172a : d0fe > bne * ;failed not equal (non zero)
172c : c045 cpy #'K'-6
trap_ne
172e : d0fe > bne * ;failed not equal (non zero)
1730 : 68 pla ;returned flags OK (unchanged)?
cmp_flag 0
1731 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
trap_ne
1733 : d0fe > bne * ;failed not equal (non zero)
1735 : ba tsx ;sp?
1736 : e0ff cpx #$ff
trap_ne
1738 : d0fe > bne * ;failed not equal (non zero)
;pass 2
load_flag $ff ;with interrupts disabled if allowed!
173a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
173c : 48 pha
173d : a9bd lda #$ff-'B'
173f : a2ad ldx #$ff-'R'
1741 : a0b4 ldy #$ff-'K'
1743 : 28 plp ;N=1, V=1, Z=1, C=1
1744 : 00 brk
1745 : 88 dey ;should not be executed
1746 : brk_ret1 ;address of break return
1746 : 08 php ;either SP or Y count will fail, if we do not hit
1747 : 88 dey
1748 : 88 dey
1749 : 88 dey
174a : c917 cmp #($ff-'B')^$aa ;returned registers OK?
;the IRQ vector was never executed if A & X stay unmodified
trap_ne
174c : d0fe > bne * ;failed not equal (non zero)
174e : e0ae cpx #$ff-'R'+1
trap_ne
1750 : d0fe > bne * ;failed not equal (non zero)
1752 : c0ae cpy #$ff-'K'-6
trap_ne
1754 : d0fe > bne * ;failed not equal (non zero)
1756 : 68 pla ;returned flags OK (unchanged)?
cmp_flag $ff
1757 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
trap_ne
1759 : d0fe > bne * ;failed not equal (non zero)
175b : ba tsx ;sp?
175c : e0ff cpx #$ff
trap_ne
175e : d0fe > bne * ;failed not equal (non zero)
next_test
1760 : ad0202 > lda test_case ;previous test
1763 : c90b > cmp #test_num
> trap_ne ;test is out of sequence
1765 : d0fe > bne * ;failed not equal (non zero)
>
000c = >test_num = test_num + 1
1767 : a90c > lda #test_num ;*** next tests' number
1769 : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
endif
; testing accumulator increment/decrement INC A & DEC A
176c : a2ac ldx #$ac ;protect x & y
176e : a0dc ldy #$dc
set_a $fe,$ff
> load_flag $ff
1770 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1772 : 48 > pha ;use stack to load status
1773 : a9fe > lda #$fe ;precharge accu
1775 : 28 > plp
1776 : 1a inc a ;ff
tst_as $ff,$ff-zero
1777 : 48 > pha
1778 : 08 > php ;save flags
1779 : c9ff > cmp #$ff ;test result
> trap_ne
177b : d0fe > bne * ;failed not equal (non zero)
>
177d : 68 > pla ;load status
177e : 48 > pha
> cmp_flag $ff-zero
177f : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1781 : d0fe > bne * ;failed not equal (non zero)
>
1783 : 28 > plp ;restore status
1784 : 68 > pla
1785 : 1a inc a ;00
tst_as 0,$ff-minus
1786 : 48 > pha
1787 : 08 > php ;save flags
1788 : c900 > cmp #0 ;test result
> trap_ne
178a : d0fe > bne * ;failed not equal (non zero)
>
178c : 68 > pla ;load status
178d : 48 > pha
> cmp_flag $ff-minus
178e : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1790 : d0fe > bne * ;failed not equal (non zero)
>
1792 : 28 > plp ;restore status
1793 : 68 > pla
1794 : 1a inc a ;01
tst_as 1,$ff-minus-zero
1795 : 48 > pha
1796 : 08 > php ;save flags
1797 : c901 > cmp #1 ;test result
> trap_ne
1799 : d0fe > bne * ;failed not equal (non zero)
>
179b : 68 > pla ;load status
179c : 48 > pha
> cmp_flag $ff-minus-zero
179d : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
179f : d0fe > bne * ;failed not equal (non zero)
>
17a1 : 28 > plp ;restore status
17a2 : 68 > pla
17a3 : 3a dec a ;00
tst_as 0,$ff-minus
17a4 : 48 > pha
17a5 : 08 > php ;save flags
17a6 : c900 > cmp #0 ;test result
> trap_ne
17a8 : d0fe > bne * ;failed not equal (non zero)
>
17aa : 68 > pla ;load status
17ab : 48 > pha
> cmp_flag $ff-minus
17ac : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
17ae : d0fe > bne * ;failed not equal (non zero)
>
17b0 : 28 > plp ;restore status
17b1 : 68 > pla
17b2 : 3a dec a ;ff
tst_as $ff,$ff-zero
17b3 : 48 > pha
17b4 : 08 > php ;save flags
17b5 : c9ff > cmp #$ff ;test result
> trap_ne
17b7 : d0fe > bne * ;failed not equal (non zero)
>
17b9 : 68 > pla ;load status
17ba : 48 > pha
> cmp_flag $ff-zero
17bb : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
17bd : d0fe > bne * ;failed not equal (non zero)
>
17bf : 28 > plp ;restore status
17c0 : 68 > pla
17c1 : 3a dec a ;fe
set_a $fe,0
> load_flag 0
17c2 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
17c4 : 48 > pha ;use stack to load status
17c5 : a9fe > lda #$fe ;precharge accu
17c7 : 28 > plp
17c8 : 1a inc a ;ff
tst_as $ff,minus
17c9 : 48 > pha
17ca : 08 > php ;save flags
17cb : c9ff > cmp #$ff ;test result
> trap_ne
17cd : d0fe > bne * ;failed not equal (non zero)
>
17cf : 68 > pla ;load status
17d0 : 48 > pha
> cmp_flag minus
17d1 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
17d3 : d0fe > bne * ;failed not equal (non zero)
>
17d5 : 28 > plp ;restore status
17d6 : 68 > pla
17d7 : 1a inc a ;00
tst_as 0,zero
17d8 : 48 > pha
17d9 : 08 > php ;save flags
17da : c900 > cmp #0 ;test result
> trap_ne
17dc : d0fe > bne * ;failed not equal (non zero)
>
17de : 68 > pla ;load status
17df : 48 > pha
> cmp_flag zero
17e0 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
17e2 : d0fe > bne * ;failed not equal (non zero)
>
17e4 : 28 > plp ;restore status
17e5 : 68 > pla
17e6 : 1a inc a ;01
tst_as 1,0
17e7 : 48 > pha
17e8 : 08 > php ;save flags
17e9 : c901 > cmp #1 ;test result
> trap_ne
17eb : d0fe > bne * ;failed not equal (non zero)
>
17ed : 68 > pla ;load status
17ee : 48 > pha
> cmp_flag 0
17ef : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
17f1 : d0fe > bne * ;failed not equal (non zero)
>
17f3 : 28 > plp ;restore status
17f4 : 68 > pla
17f5 : 3a dec a ;00
tst_as 0,zero
17f6 : 48 > pha
17f7 : 08 > php ;save flags
17f8 : c900 > cmp #0 ;test result
> trap_ne
17fa : d0fe > bne * ;failed not equal (non zero)
>
17fc : 68 > pla ;load status
17fd : 48 > pha
> cmp_flag zero
17fe : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1800 : d0fe > bne * ;failed not equal (non zero)
>
1802 : 28 > plp ;restore status
1803 : 68 > pla
1804 : 3a dec a ;ff
tst_as $ff,minus
1805 : 48 > pha
1806 : 08 > php ;save flags
1807 : c9ff > cmp #$ff ;test result
> trap_ne
1809 : d0fe > bne * ;failed not equal (non zero)
>
180b : 68 > pla ;load status
180c : 48 > pha
> cmp_flag minus
180d : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
180f : d0fe > bne * ;failed not equal (non zero)
>
1811 : 28 > plp ;restore status
1812 : 68 > pla
1813 : e0ac cpx #$ac
trap_ne ;x altered during test
1815 : d0fe > bne * ;failed not equal (non zero)
1817 : c0dc cpy #$dc
trap_ne ;y altered during test
1819 : d0fe > bne * ;failed not equal (non zero)
181b : ba tsx
181c : e0ff cpx #$ff
trap_ne ;sp push/pop mismatch
181e : d0fe > bne * ;failed not equal (non zero)
next_test
1820 : ad0202 > lda test_case ;previous test
1823 : c90c > cmp #test_num
> trap_ne ;test is out of sequence
1825 : d0fe > bne * ;failed not equal (non zero)
>
000d = >test_num = test_num + 1
1827 : a90d > lda #test_num ;*** next tests' number
1829 : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; testing load / store accumulator LDA / STA (zp)
182c : a299 ldx #$99 ;protect x & y
182e : a066 ldy #$66
set_stat 0
> load_flag 0
1830 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1832 : 48 > pha ;use stack to load status
1833 : 28 > plp
1834 : b224 lda (ind1)
1836 : 08 php ;test stores do not alter flags
1837 : 49c3 eor #$c3
1839 : 28 plp
183a : 9230 sta (indt)
183c : 08 php ;flags after load/store sequence
183d : 49c3 eor #$c3
183f : c9c3 cmp #$c3 ;test result
trap_ne
1841 : d0fe > bne * ;failed not equal (non zero)
1843 : 68 pla ;load status
eor_flag 0
1844 : 4930 > eor #0|fao ;invert expected flags + always on bits
1846 : cd1502 cmp fLDx ;test flags
trap_ne
1849 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
184b : a900 > lda #0 ;allow test to change I-flag (no mask)
>
184d : 48 > pha ;use stack to load status
184e : 28 > plp
184f : b226 lda (ind1+2)
1851 : 08 php ;test stores do not alter flags
1852 : 49c3 eor #$c3
1854 : 28 plp
1855 : 9232 sta (indt+2)
1857 : 08 php ;flags after load/store sequence
1858 : 49c3 eor #$c3
185a : c982 cmp #$82 ;test result
trap_ne
185c : d0fe > bne * ;failed not equal (non zero)
185e : 68 pla ;load status
eor_flag 0
185f : 4930 > eor #0|fao ;invert expected flags + always on bits
1861 : cd1602 cmp fLDx+1 ;test flags
trap_ne
1864 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1866 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1868 : 48 > pha ;use stack to load status
1869 : 28 > plp
186a : b228 lda (ind1+4)
186c : 08 php ;test stores do not alter flags
186d : 49c3 eor #$c3
186f : 28 plp
1870 : 9234 sta (indt+4)
1872 : 08 php ;flags after load/store sequence
1873 : 49c3 eor #$c3
1875 : c941 cmp #$41 ;test result
trap_ne
1877 : d0fe > bne * ;failed not equal (non zero)
1879 : 68 pla ;load status
eor_flag 0
187a : 4930 > eor #0|fao ;invert expected flags + always on bits
187c : cd1702 cmp fLDx+2 ;test flags
trap_ne
187f : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1881 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1883 : 48 > pha ;use stack to load status
1884 : 28 > plp
1885 : b22a lda (ind1+6)
1887 : 08 php ;test stores do not alter flags
1888 : 49c3 eor #$c3
188a : 28 plp
188b : 9236 sta (indt+6)
188d : 08 php ;flags after load/store sequence
188e : 49c3 eor #$c3
1890 : c900 cmp #0 ;test result
trap_ne
1892 : d0fe > bne * ;failed not equal (non zero)
1894 : 68 pla ;load status
eor_flag 0
1895 : 4930 > eor #0|fao ;invert expected flags + always on bits
1897 : cd1802 cmp fLDx+3 ;test flags
trap_ne
189a : d0fe > bne * ;failed not equal (non zero)
189c : e099 cpx #$99
trap_ne ;x altered during test
189e : d0fe > bne * ;failed not equal (non zero)
18a0 : c066 cpy #$66
trap_ne ;y altered during test
18a2 : d0fe > bne * ;failed not equal (non zero)
18a4 : a003 ldy #3 ;testing store result
18a6 : a200 ldx #0
18a8 : b90502 tstai1 lda abst,y
18ab : 49c3 eor #$c3
18ad : d91002 cmp abs1,y
trap_ne ;store to indirect data
18b0 : d0fe > bne * ;failed not equal (non zero)
18b2 : 8a txa
18b3 : 990502 sta abst,y ;clear
18b6 : 88 dey
18b7 : 10ef bpl tstai1
18b9 : a299 ldx #$99 ;protect x & y
18bb : a066 ldy #$66
set_stat $ff
> load_flag $ff
18bd : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
18bf : 48 > pha ;use stack to load status
18c0 : 28 > plp
18c1 : b224 lda (ind1)
18c3 : 08 php ;test stores do not alter flags
18c4 : 49c3 eor #$c3
18c6 : 28 plp
18c7 : 9230 sta (indt)
18c9 : 08 php ;flags after load/store sequence
18ca : 49c3 eor #$c3
18cc : c9c3 cmp #$c3 ;test result
trap_ne
18ce : d0fe > bne * ;failed not equal (non zero)
18d0 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
18d1 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
18d3 : cd1502 cmp fLDx ;test flags
trap_ne
18d6 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
18d8 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
18da : 48 > pha ;use stack to load status
18db : 28 > plp
18dc : b226 lda (ind1+2)
18de : 08 php ;test stores do not alter flags
18df : 49c3 eor #$c3
18e1 : 28 plp
18e2 : 9232 sta (indt+2)
18e4 : 08 php ;flags after load/store sequence
18e5 : 49c3 eor #$c3
18e7 : c982 cmp #$82 ;test result
trap_ne
18e9 : d0fe > bne * ;failed not equal (non zero)
18eb : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
18ec : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
18ee : cd1602 cmp fLDx+1 ;test flags
trap_ne
18f1 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
18f3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
18f5 : 48 > pha ;use stack to load status
18f6 : 28 > plp
18f7 : b228 lda (ind1+4)
18f9 : 08 php ;test stores do not alter flags
18fa : 49c3 eor #$c3
18fc : 28 plp
18fd : 9234 sta (indt+4)
18ff : 08 php ;flags after load/store sequence
1900 : 49c3 eor #$c3
1902 : c941 cmp #$41 ;test result
trap_ne
1904 : d0fe > bne * ;failed not equal (non zero)
1906 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1907 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1909 : cd1702 cmp fLDx+2 ;test flags
trap_ne
190c : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
190e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1910 : 48 > pha ;use stack to load status
1911 : 28 > plp
1912 : b22a lda (ind1+6)
1914 : 08 php ;test stores do not alter flags
1915 : 49c3 eor #$c3
1917 : 28 plp
1918 : 9236 sta (indt+6)
191a : 08 php ;flags after load/store sequence
191b : 49c3 eor #$c3
191d : c900 cmp #0 ;test result
trap_ne
191f : d0fe > bne * ;failed not equal (non zero)
1921 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1922 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1924 : cd1802 cmp fLDx+3 ;test flags
trap_ne
1927 : d0fe > bne * ;failed not equal (non zero)
1929 : e099 cpx #$99
trap_ne ;x altered during test
192b : d0fe > bne * ;failed not equal (non zero)
192d : c066 cpy #$66
trap_ne ;y altered during test
192f : d0fe > bne * ;failed not equal (non zero)
1931 : a003 ldy #3 ;testing store result
1933 : a200 ldx #0
1935 : b90502 tstai2 lda abst,y
1938 : 49c3 eor #$c3
193a : d91002 cmp abs1,y
trap_ne ;store to indirect data
193d : d0fe > bne * ;failed not equal (non zero)
193f : 8a txa
1940 : 990502 sta abst,y ;clear
1943 : 88 dey
1944 : 10ef bpl tstai2
1946 : ba tsx
1947 : e0ff cpx #$ff
trap_ne ;sp push/pop mismatch
1949 : d0fe > bne * ;failed not equal (non zero)
next_test
194b : ad0202 > lda test_case ;previous test
194e : c90d > cmp #test_num
> trap_ne ;test is out of sequence
1950 : d0fe > bne * ;failed not equal (non zero)
>
000e = >test_num = test_num + 1
1952 : a90e > lda #test_num ;*** next tests' number
1954 : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; testing STZ - zp / abs / zp,x / abs,x
1957 : a07b ldy #123 ;protect y
1959 : a204 ldx #4 ;precharge test area
195b : a907 lda #7
195d : 950c tstz1 sta zpt,x
195f : 0a asl a
1960 : ca dex
1961 : 10fa bpl tstz1
1963 : a204 ldx #4
set_a $55,$ff
> load_flag $ff
1965 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1967 : 48 > pha ;use stack to load status
1968 : a955 > lda #$55 ;precharge accu
196a : 28 > plp
196b : 640c stz zpt
196d : 640d stz zpt+1
196f : 640e stz zpt+2
1971 : 640f stz zpt+3
1973 : 6410 stz zpt+4
tst_a $55,$ff
1975 : 08 > php ;save flags
1976 : c955 > cmp #$55 ;test result
> trap_ne
1978 : d0fe > bne * ;failed not equal (non zero)
>
197a : 68 > pla ;load status
197b : 48 > pha
> cmp_flag $ff
197c : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
197e : d0fe > bne * ;failed not equal (non zero)
>
1980 : 28 > plp ;restore status
1981 : b50c tstz2 lda zpt,x ;verify zeros stored
trap_ne ;non zero after STZ zp
1983 : d0fe > bne * ;failed not equal (non zero)
1985 : ca dex
1986 : 10f9 bpl tstz2
1988 : a204 ldx #4 ;precharge test area
198a : a907 lda #7
198c : 950c tstz3 sta zpt,x
198e : 0a asl a
198f : ca dex
1990 : 10fa bpl tstz3
1992 : a204 ldx #4
set_a $aa,0
> load_flag 0
1994 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1996 : 48 > pha ;use stack to load status
1997 : a9aa > lda #$aa ;precharge accu
1999 : 28 > plp
199a : 640c stz zpt
199c : 640d stz zpt+1
199e : 640e stz zpt+2
19a0 : 640f stz zpt+3
19a2 : 6410 stz zpt+4
tst_a $aa,0
19a4 : 08 > php ;save flags
19a5 : c9aa > cmp #$aa ;test result
> trap_ne
19a7 : d0fe > bne * ;failed not equal (non zero)
>
19a9 : 68 > pla ;load status
19aa : 48 > pha
> cmp_flag 0
19ab : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
19ad : d0fe > bne * ;failed not equal (non zero)
>
19af : 28 > plp ;restore status
19b0 : b50c tstz4 lda zpt,x ;verify zeros stored
trap_ne ;non zero after STZ zp
19b2 : d0fe > bne * ;failed not equal (non zero)
19b4 : ca dex
19b5 : 10f9 bpl tstz4
19b7 : a204 ldx #4 ;precharge test area
19b9 : a907 lda #7
19bb : 9d0502 tstz5 sta abst,x
19be : 0a asl a
19bf : ca dex
19c0 : 10f9 bpl tstz5
19c2 : a204 ldx #4
set_a $55,$ff
> load_flag $ff
19c4 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
19c6 : 48 > pha ;use stack to load status
19c7 : a955 > lda #$55 ;precharge accu
19c9 : 28 > plp
19ca : 9c0502 stz abst
19cd : 9c0602 stz abst+1
19d0 : 9c0702 stz abst+2
19d3 : 9c0802 stz abst+3
19d6 : 9c0902 stz abst+4
tst_a $55,$ff
19d9 : 08 > php ;save flags
19da : c955 > cmp #$55 ;test result
> trap_ne
19dc : d0fe > bne * ;failed not equal (non zero)
>
19de : 68 > pla ;load status
19df : 48 > pha
> cmp_flag $ff
19e0 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
19e2 : d0fe > bne * ;failed not equal (non zero)
>
19e4 : 28 > plp ;restore status
19e5 : bd0502 tstz6 lda abst,x ;verify zeros stored
trap_ne ;non zero after STZ abs
19e8 : d0fe > bne * ;failed not equal (non zero)
19ea : ca dex
19eb : 10f8 bpl tstz6
19ed : a204 ldx #4 ;precharge test area
19ef : a907 lda #7
19f1 : 9d0502 tstz7 sta abst,x
19f4 : 0a asl a
19f5 : ca dex
19f6 : 10f9 bpl tstz7
19f8 : a204 ldx #4
set_a $aa,0
> load_flag 0
19fa : a900 > lda #0 ;allow test to change I-flag (no mask)
>
19fc : 48 > pha ;use stack to load status
19fd : a9aa > lda #$aa ;precharge accu
19ff : 28 > plp
1a00 : 9c0502 stz abst
1a03 : 9c0602 stz abst+1
1a06 : 9c0702 stz abst+2
1a09 : 9c0802 stz abst+3
1a0c : 9c0902 stz abst+4
tst_a $aa,0
1a0f : 08 > php ;save flags
1a10 : c9aa > cmp #$aa ;test result
> trap_ne
1a12 : d0fe > bne * ;failed not equal (non zero)
>
1a14 : 68 > pla ;load status
1a15 : 48 > pha
> cmp_flag 0
1a16 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1a18 : d0fe > bne * ;failed not equal (non zero)
>
1a1a : 28 > plp ;restore status
1a1b : bd0502 tstz8 lda abst,x ;verify zeros stored
trap_ne ;non zero after STZ abs
1a1e : d0fe > bne * ;failed not equal (non zero)
1a20 : ca dex
1a21 : 10f8 bpl tstz8
1a23 : a204 ldx #4 ;precharge test area
1a25 : a907 lda #7
1a27 : 950c tstz11 sta zpt,x
1a29 : 0a asl a
1a2a : ca dex
1a2b : 10fa bpl tstz11
1a2d : a204 ldx #4
1a2f : tstz15
set_a $55,$ff
> load_flag $ff
1a2f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1a31 : 48 > pha ;use stack to load status
1a32 : a955 > lda #$55 ;precharge accu
1a34 : 28 > plp
1a35 : 740c stz zpt,x
tst_a $55,$ff
1a37 : 08 > php ;save flags
1a38 : c955 > cmp #$55 ;test result
> trap_ne
1a3a : d0fe > bne * ;failed not equal (non zero)
>
1a3c : 68 > pla ;load status
1a3d : 48 > pha
> cmp_flag $ff
1a3e : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1a40 : d0fe > bne * ;failed not equal (non zero)
>
1a42 : 28 > plp ;restore status
1a43 : ca dex
1a44 : 10e9 bpl tstz15
1a46 : a204 ldx #4
1a48 : b50c tstz12 lda zpt,x ;verify zeros stored
trap_ne ;non zero after STZ zp
1a4a : d0fe > bne * ;failed not equal (non zero)
1a4c : ca dex
1a4d : 10f9 bpl tstz12
1a4f : a204 ldx #4 ;precharge test area
1a51 : a907 lda #7
1a53 : 950c tstz13 sta zpt,x
1a55 : 0a asl a
1a56 : ca dex
1a57 : 10fa bpl tstz13
1a59 : a204 ldx #4
1a5b : tstz16
set_a $aa,0
> load_flag 0
1a5b : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1a5d : 48 > pha ;use stack to load status
1a5e : a9aa > lda #$aa ;precharge accu
1a60 : 28 > plp
1a61 : 740c stz zpt,x
tst_a $aa,0
1a63 : 08 > php ;save flags
1a64 : c9aa > cmp #$aa ;test result
> trap_ne
1a66 : d0fe > bne * ;failed not equal (non zero)
>
1a68 : 68 > pla ;load status
1a69 : 48 > pha
> cmp_flag 0
1a6a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1a6c : d0fe > bne * ;failed not equal (non zero)
>
1a6e : 28 > plp ;restore status
1a6f : ca dex
1a70 : 10e9 bpl tstz16
1a72 : a204 ldx #4
1a74 : b50c tstz14 lda zpt,x ;verify zeros stored
trap_ne ;non zero after STZ zp
1a76 : d0fe > bne * ;failed not equal (non zero)
1a78 : ca dex
1a79 : 10f9 bpl tstz14
1a7b : a204 ldx #4 ;precharge test area
1a7d : a907 lda #7
1a7f : 9d0502 tstz21 sta abst,x
1a82 : 0a asl a
1a83 : ca dex
1a84 : 10f9 bpl tstz21
1a86 : a204 ldx #4
1a88 : tstz25
set_a $55,$ff
> load_flag $ff
1a88 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1a8a : 48 > pha ;use stack to load status
1a8b : a955 > lda #$55 ;precharge accu
1a8d : 28 > plp
1a8e : 9e0502 stz abst,x
tst_a $55,$ff
1a91 : 08 > php ;save flags
1a92 : c955 > cmp #$55 ;test result
> trap_ne
1a94 : d0fe > bne * ;failed not equal (non zero)
>
1a96 : 68 > pla ;load status
1a97 : 48 > pha
> cmp_flag $ff
1a98 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1a9a : d0fe > bne * ;failed not equal (non zero)
>
1a9c : 28 > plp ;restore status
1a9d : ca dex
1a9e : 10e8 bpl tstz25
1aa0 : a204 ldx #4
1aa2 : bd0502 tstz22 lda abst,x ;verify zeros stored
trap_ne ;non zero after STZ zp
1aa5 : d0fe > bne * ;failed not equal (non zero)
1aa7 : ca dex
1aa8 : 10f8 bpl tstz22
1aaa : a204 ldx #4 ;precharge test area
1aac : a907 lda #7
1aae : 9d0502 tstz23 sta abst,x
1ab1 : 0a asl a
1ab2 : ca dex
1ab3 : 10f9 bpl tstz23
1ab5 : a204 ldx #4
1ab7 : tstz26
set_a $aa,0
> load_flag 0
1ab7 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1ab9 : 48 > pha ;use stack to load status
1aba : a9aa > lda #$aa ;precharge accu
1abc : 28 > plp
1abd : 9e0502 stz abst,x
tst_a $aa,0
1ac0 : 08 > php ;save flags
1ac1 : c9aa > cmp #$aa ;test result
> trap_ne
1ac3 : d0fe > bne * ;failed not equal (non zero)
>
1ac5 : 68 > pla ;load status
1ac6 : 48 > pha
> cmp_flag 0
1ac7 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1ac9 : d0fe > bne * ;failed not equal (non zero)
>
1acb : 28 > plp ;restore status
1acc : ca dex
1acd : 10e8 bpl tstz26
1acf : a204 ldx #4
1ad1 : bd0502 tstz24 lda abst,x ;verify zeros stored
trap_ne ;non zero after STZ zp
1ad4 : d0fe > bne * ;failed not equal (non zero)
1ad6 : ca dex
1ad7 : 10f8 bpl tstz24
1ad9 : c07b cpy #123
trap_ne ;y altered during test
1adb : d0fe > bne * ;failed not equal (non zero)
1add : ba tsx
1ade : e0ff cpx #$ff
trap_ne ;sp push/pop mismatch
1ae0 : d0fe > bne * ;failed not equal (non zero)
next_test
1ae2 : ad0202 > lda test_case ;previous test
1ae5 : c90e > cmp #test_num
> trap_ne ;test is out of sequence
1ae7 : d0fe > bne * ;failed not equal (non zero)
>
000f = >test_num = test_num + 1
1ae9 : a90f > lda #test_num ;*** next tests' number
1aeb : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; testing BIT - zp,x / abs,x / #
1aee : a042 ldy #$42
1af0 : a203 ldx #3
set_a $ff,0
> load_flag 0
1af2 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1af4 : 48 > pha ;use stack to load status
1af5 : a9ff > lda #$ff ;precharge accu
1af7 : 28 > plp
1af8 : 3413 bit zp1,x ;00 - should set Z / clear NV
tst_a $ff,fz
1afa : 08 > php ;save flags
1afb : c9ff > cmp #$ff ;test result
> trap_ne
1afd : d0fe > bne * ;failed not equal (non zero)
>
1aff : 68 > pla ;load status
1b00 : 48 > pha
> cmp_flag fz
1b01 : c932 > cmp #(fz |fao)&m8 ;expected flags + always on bits
>
> trap_ne
1b03 : d0fe > bne * ;failed not equal (non zero)
>
1b05 : 28 > plp ;restore status
1b06 : ca dex
set_a 1,0
> load_flag 0
1b07 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1b09 : 48 > pha ;use stack to load status
1b0a : a901 > lda #1 ;precharge accu
1b0c : 28 > plp
1b0d : 3413 bit zp1,x ;41 - should set V (M6) / clear NZ
tst_a 1,fv
1b0f : 08 > php ;save flags
1b10 : c901 > cmp #1 ;test result
> trap_ne
1b12 : d0fe > bne * ;failed not equal (non zero)
>
1b14 : 68 > pla ;load status
1b15 : 48 > pha
> cmp_flag fv
1b16 : c970 > cmp #(fv|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1b18 : d0fe > bne * ;failed not equal (non zero)
>
1b1a : 28 > plp ;restore status
1b1b : ca dex
set_a 1,0
> load_flag 0
1b1c : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1b1e : 48 > pha ;use stack to load status
1b1f : a901 > lda #1 ;precharge accu
1b21 : 28 > plp
1b22 : 3413 bit zp1,x ;82 - should set N (M7) & Z / clear V
tst_a 1,fnz
1b24 : 08 > php ;save flags
1b25 : c901 > cmp #1 ;test result
> trap_ne
1b27 : d0fe > bne * ;failed not equal (non zero)
>
1b29 : 68 > pla ;load status
1b2a : 48 > pha
> cmp_flag fnz
1b2b : c9b2 > cmp #(fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1b2d : d0fe > bne * ;failed not equal (non zero)
>
1b2f : 28 > plp ;restore status
1b30 : ca dex
set_a 1,0
> load_flag 0
1b31 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1b33 : 48 > pha ;use stack to load status
1b34 : a901 > lda #1 ;precharge accu
1b36 : 28 > plp
1b37 : 3413 bit zp1,x ;c3 - should set N (M7) & V (M6) / clear Z
tst_a 1,fnv
1b39 : 08 > php ;save flags
1b3a : c901 > cmp #1 ;test result
> trap_ne
1b3c : d0fe > bne * ;failed not equal (non zero)
>
1b3e : 68 > pla ;load status
1b3f : 48 > pha
> cmp_flag fnv
1b40 : c9f0 > cmp #(fnv|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1b42 : d0fe > bne * ;failed not equal (non zero)
>
1b44 : 28 > plp ;restore status
set_a 1,$ff
> load_flag $ff
1b45 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1b47 : 48 > pha ;use stack to load status
1b48 : a901 > lda #1 ;precharge accu
1b4a : 28 > plp
1b4b : 3413 bit zp1,x ;c3 - should set N (M7) & V (M6) / clear Z
tst_a 1,~fz
1b4d : 08 > php ;save flags
1b4e : c901 > cmp #1 ;test result
> trap_ne
1b50 : d0fe > bne * ;failed not equal (non zero)
>
1b52 : 68 > pla ;load status
1b53 : 48 > pha
> cmp_flag ~fz
1b54 : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1b56 : d0fe > bne * ;failed not equal (non zero)
>
1b58 : 28 > plp ;restore status
1b59 : e8 inx
set_a 1,$ff
> load_flag $ff
1b5a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1b5c : 48 > pha ;use stack to load status
1b5d : a901 > lda #1 ;precharge accu
1b5f : 28 > plp
1b60 : 3413 bit zp1,x ;82 - should set N (M7) & Z / clear V
tst_a 1,~fv
1b62 : 08 > php ;save flags
1b63 : c901 > cmp #1 ;test result
> trap_ne
1b65 : d0fe > bne * ;failed not equal (non zero)
>
1b67 : 68 > pla ;load status
1b68 : 48 > pha
> cmp_flag ~fv
1b69 : c9bf > cmp #(~fv|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1b6b : d0fe > bne * ;failed not equal (non zero)
>
1b6d : 28 > plp ;restore status
1b6e : e8 inx
set_a 1,$ff
> load_flag $ff
1b6f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1b71 : 48 > pha ;use stack to load status
1b72 : a901 > lda #1 ;precharge accu
1b74 : 28 > plp
1b75 : 3413 bit zp1,x ;41 - should set V (M6) / clear NZ
tst_a 1,~fnz
1b77 : 08 > php ;save flags
1b78 : c901 > cmp #1 ;test result
> trap_ne
1b7a : d0fe > bne * ;failed not equal (non zero)
>
1b7c : 68 > pla ;load status
1b7d : 48 > pha
> cmp_flag ~fnz
1b7e : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1b80 : d0fe > bne * ;failed not equal (non zero)
>
1b82 : 28 > plp ;restore status
1b83 : e8 inx
set_a $ff,$ff
> load_flag $ff
1b84 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1b86 : 48 > pha ;use stack to load status
1b87 : a9ff > lda #$ff ;precharge accu
1b89 : 28 > plp
1b8a : 3413 bit zp1,x ;00 - should set Z / clear NV
tst_a $ff,~fnv
1b8c : 08 > php ;save flags
1b8d : c9ff > cmp #$ff ;test result
> trap_ne
1b8f : d0fe > bne * ;failed not equal (non zero)
>
1b91 : 68 > pla ;load status
1b92 : 48 > pha
> cmp_flag ~fnv
1b93 : c93f > cmp #(~fnv |fao)&m8 ;expected flags + always on bits
>
> trap_ne
1b95 : d0fe > bne * ;failed not equal (non zero)
>
1b97 : 28 > plp ;restore status
set_a $ff,0
> load_flag 0
1b98 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1b9a : 48 > pha ;use stack to load status
1b9b : a9ff > lda #$ff ;precharge accu
1b9d : 28 > plp
1b9e : 3c1002 bit abs1,x ;00 - should set Z / clear NV
tst_a $ff,fz
1ba1 : 08 > php ;save flags
1ba2 : c9ff > cmp #$ff ;test result
> trap_ne
1ba4 : d0fe > bne * ;failed not equal (non zero)
>
1ba6 : 68 > pla ;load status
1ba7 : 48 > pha
> cmp_flag fz
1ba8 : c932 > cmp #(fz |fao)&m8 ;expected flags + always on bits
>
> trap_ne
1baa : d0fe > bne * ;failed not equal (non zero)
>
1bac : 28 > plp ;restore status
1bad : ca dex
set_a 1,0
> load_flag 0
1bae : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1bb0 : 48 > pha ;use stack to load status
1bb1 : a901 > lda #1 ;precharge accu
1bb3 : 28 > plp
1bb4 : 3c1002 bit abs1,x ;41 - should set V (M6) / clear NZ
tst_a 1,fv
1bb7 : 08 > php ;save flags
1bb8 : c901 > cmp #1 ;test result
> trap_ne
1bba : d0fe > bne * ;failed not equal (non zero)
>
1bbc : 68 > pla ;load status
1bbd : 48 > pha
> cmp_flag fv
1bbe : c970 > cmp #(fv|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1bc0 : d0fe > bne * ;failed not equal (non zero)
>
1bc2 : 28 > plp ;restore status
1bc3 : ca dex
set_a 1,0
> load_flag 0
1bc4 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1bc6 : 48 > pha ;use stack to load status
1bc7 : a901 > lda #1 ;precharge accu
1bc9 : 28 > plp
1bca : 3c1002 bit abs1,x ;82 - should set N (M7) & Z / clear V
tst_a 1,fnz
1bcd : 08 > php ;save flags
1bce : c901 > cmp #1 ;test result
> trap_ne
1bd0 : d0fe > bne * ;failed not equal (non zero)
>
1bd2 : 68 > pla ;load status
1bd3 : 48 > pha
> cmp_flag fnz
1bd4 : c9b2 > cmp #(fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1bd6 : d0fe > bne * ;failed not equal (non zero)
>
1bd8 : 28 > plp ;restore status
1bd9 : ca dex
set_a 1,0
> load_flag 0
1bda : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1bdc : 48 > pha ;use stack to load status
1bdd : a901 > lda #1 ;precharge accu
1bdf : 28 > plp
1be0 : 3c1002 bit abs1,x ;c3 - should set N (M7) & V (M6) / clear Z
tst_a 1,fnv
1be3 : 08 > php ;save flags
1be4 : c901 > cmp #1 ;test result
> trap_ne
1be6 : d0fe > bne * ;failed not equal (non zero)
>
1be8 : 68 > pla ;load status
1be9 : 48 > pha
> cmp_flag fnv
1bea : c9f0 > cmp #(fnv|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1bec : d0fe > bne * ;failed not equal (non zero)
>
1bee : 28 > plp ;restore status
set_a 1,$ff
> load_flag $ff
1bef : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1bf1 : 48 > pha ;use stack to load status
1bf2 : a901 > lda #1 ;precharge accu
1bf4 : 28 > plp
1bf5 : 3c1002 bit abs1,x ;c3 - should set N (M7) & V (M6) / clear Z
tst_a 1,~fz
1bf8 : 08 > php ;save flags
1bf9 : c901 > cmp #1 ;test result
> trap_ne
1bfb : d0fe > bne * ;failed not equal (non zero)
>
1bfd : 68 > pla ;load status
1bfe : 48 > pha
> cmp_flag ~fz
1bff : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1c01 : d0fe > bne * ;failed not equal (non zero)
>
1c03 : 28 > plp ;restore status
1c04 : e8 inx
set_a 1,$ff
> load_flag $ff
1c05 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1c07 : 48 > pha ;use stack to load status
1c08 : a901 > lda #1 ;precharge accu
1c0a : 28 > plp
1c0b : 3c1002 bit abs1,x ;82 - should set N (M7) & Z / clear V
tst_a 1,~fv
1c0e : 08 > php ;save flags
1c0f : c901 > cmp #1 ;test result
> trap_ne
1c11 : d0fe > bne * ;failed not equal (non zero)
>
1c13 : 68 > pla ;load status
1c14 : 48 > pha
> cmp_flag ~fv
1c15 : c9bf > cmp #(~fv|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1c17 : d0fe > bne * ;failed not equal (non zero)
>
1c19 : 28 > plp ;restore status
1c1a : e8 inx
set_a 1,$ff
> load_flag $ff
1c1b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1c1d : 48 > pha ;use stack to load status
1c1e : a901 > lda #1 ;precharge accu
1c20 : 28 > plp
1c21 : 3c1002 bit abs1,x ;41 - should set V (M6) / clear NZ
tst_a 1,~fnz
1c24 : 08 > php ;save flags
1c25 : c901 > cmp #1 ;test result
> trap_ne
1c27 : d0fe > bne * ;failed not equal (non zero)
>
1c29 : 68 > pla ;load status
1c2a : 48 > pha
> cmp_flag ~fnz
1c2b : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1c2d : d0fe > bne * ;failed not equal (non zero)
>
1c2f : 28 > plp ;restore status
1c30 : e8 inx
set_a $ff,$ff
> load_flag $ff
1c31 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1c33 : 48 > pha ;use stack to load status
1c34 : a9ff > lda #$ff ;precharge accu
1c36 : 28 > plp
1c37 : 3c1002 bit abs1,x ;00 - should set Z / clear NV
tst_a $ff,~fnv
1c3a : 08 > php ;save flags
1c3b : c9ff > cmp #$ff ;test result
> trap_ne
1c3d : d0fe > bne * ;failed not equal (non zero)
>
1c3f : 68 > pla ;load status
1c40 : 48 > pha
> cmp_flag ~fnv
1c41 : c93f > cmp #(~fnv |fao)&m8 ;expected flags + always on bits
>
> trap_ne
1c43 : d0fe > bne * ;failed not equal (non zero)
>
1c45 : 28 > plp ;restore status
set_a $ff,0
> load_flag 0
1c46 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1c48 : 48 > pha ;use stack to load status
1c49 : a9ff > lda #$ff ;precharge accu
1c4b : 28 > plp
1c4c : 8900 bit #$00 ;00 - should set Z
tst_a $ff,fz
1c4e : 08 > php ;save flags
1c4f : c9ff > cmp #$ff ;test result
> trap_ne
1c51 : d0fe > bne * ;failed not equal (non zero)
>
1c53 : 68 > pla ;load status
1c54 : 48 > pha
> cmp_flag fz
1c55 : c932 > cmp #(fz |fao)&m8 ;expected flags + always on bits
>
> trap_ne
1c57 : d0fe > bne * ;failed not equal (non zero)
>
1c59 : 28 > plp ;restore status
1c5a : ca dex
set_a 1,0
> load_flag 0
1c5b : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1c5d : 48 > pha ;use stack to load status
1c5e : a901 > lda #1 ;precharge accu
1c60 : 28 > plp
1c61 : 8941 bit #$41 ;41 - should clear Z
tst_a 1,0
1c63 : 08 > php ;save flags
1c64 : c901 > cmp #1 ;test result
> trap_ne
1c66 : d0fe > bne * ;failed not equal (non zero)
>
1c68 : 68 > pla ;load status
1c69 : 48 > pha
> cmp_flag 0
1c6a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1c6c : d0fe > bne * ;failed not equal (non zero)
>
1c6e : 28 > plp ;restore status
; *** DEBUG INFO ***
; if it fails the previous test and your BIT # has set the V flag
; see http://forum.6502.org/viewtopic.php?f=2&t=2241&p=27243#p27239
; why it shouldn't alter N or V flags on a BIT #
1c6f : ca dex
set_a 1,0
> load_flag 0
1c70 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1c72 : 48 > pha ;use stack to load status
1c73 : a901 > lda #1 ;precharge accu
1c75 : 28 > plp
1c76 : 8982 bit #$82 ;82 - should set Z
tst_a 1,fz
1c78 : 08 > php ;save flags
1c79 : c901 > cmp #1 ;test result
> trap_ne
1c7b : d0fe > bne * ;failed not equal (non zero)
>
1c7d : 68 > pla ;load status
1c7e : 48 > pha
> cmp_flag fz
1c7f : c932 > cmp #(fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1c81 : d0fe > bne * ;failed not equal (non zero)
>
1c83 : 28 > plp ;restore status
1c84 : ca dex
set_a 1,0
> load_flag 0
1c85 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1c87 : 48 > pha ;use stack to load status
1c88 : a901 > lda #1 ;precharge accu
1c8a : 28 > plp
1c8b : 89c3 bit #$c3 ;c3 - should clear Z
tst_a 1,0
1c8d : 08 > php ;save flags
1c8e : c901 > cmp #1 ;test result
> trap_ne
1c90 : d0fe > bne * ;failed not equal (non zero)
>
1c92 : 68 > pla ;load status
1c93 : 48 > pha
> cmp_flag 0
1c94 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1c96 : d0fe > bne * ;failed not equal (non zero)
>
1c98 : 28 > plp ;restore status
set_a 1,$ff
> load_flag $ff
1c99 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1c9b : 48 > pha ;use stack to load status
1c9c : a901 > lda #1 ;precharge accu
1c9e : 28 > plp
1c9f : 89c3 bit #$c3 ;c3 - clear Z
tst_a 1,~fz
1ca1 : 08 > php ;save flags
1ca2 : c901 > cmp #1 ;test result
> trap_ne
1ca4 : d0fe > bne * ;failed not equal (non zero)
>
1ca6 : 68 > pla ;load status
1ca7 : 48 > pha
> cmp_flag ~fz
1ca8 : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1caa : d0fe > bne * ;failed not equal (non zero)
>
1cac : 28 > plp ;restore status
1cad : e8 inx
set_a 1,$ff
> load_flag $ff
1cae : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1cb0 : 48 > pha ;use stack to load status
1cb1 : a901 > lda #1 ;precharge accu
1cb3 : 28 > plp
1cb4 : 8982 bit #$82 ;82 - should set Z
tst_a 1,$ff
1cb6 : 08 > php ;save flags
1cb7 : c901 > cmp #1 ;test result
> trap_ne
1cb9 : d0fe > bne * ;failed not equal (non zero)
>
1cbb : 68 > pla ;load status
1cbc : 48 > pha
> cmp_flag $ff
1cbd : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1cbf : d0fe > bne * ;failed not equal (non zero)
>
1cc1 : 28 > plp ;restore status
1cc2 : e8 inx
set_a 1,$ff
> load_flag $ff
1cc3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1cc5 : 48 > pha ;use stack to load status
1cc6 : a901 > lda #1 ;precharge accu
1cc8 : 28 > plp
1cc9 : 8941 bit #$41 ;41 - should clear Z
tst_a 1,~fz
1ccb : 08 > php ;save flags
1ccc : c901 > cmp #1 ;test result
> trap_ne
1cce : d0fe > bne * ;failed not equal (non zero)
>
1cd0 : 68 > pla ;load status
1cd1 : 48 > pha
> cmp_flag ~fz
1cd2 : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1cd4 : d0fe > bne * ;failed not equal (non zero)
>
1cd6 : 28 > plp ;restore status
1cd7 : e8 inx
set_a $ff,$ff
> load_flag $ff
1cd8 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1cda : 48 > pha ;use stack to load status
1cdb : a9ff > lda #$ff ;precharge accu
1cdd : 28 > plp
1cde : 8900 bit #$00 ;00 - should set Z
tst_a $ff,$ff
1ce0 : 08 > php ;save flags
1ce1 : c9ff > cmp #$ff ;test result
> trap_ne
1ce3 : d0fe > bne * ;failed not equal (non zero)
>
1ce5 : 68 > pla ;load status
1ce6 : 48 > pha
> cmp_flag $ff
1ce7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1ce9 : d0fe > bne * ;failed not equal (non zero)
>
1ceb : 28 > plp ;restore status
1cec : e003 cpx #3
trap_ne ;x altered during test
1cee : d0fe > bne * ;failed not equal (non zero)
1cf0 : c042 cpy #$42
trap_ne ;y altered during test
1cf2 : d0fe > bne * ;failed not equal (non zero)
1cf4 : ba tsx
1cf5 : e0ff cpx #$ff
trap_ne ;sp push/pop mismatch
1cf7 : d0fe > bne * ;failed not equal (non zero)
next_test
1cf9 : ad0202 > lda test_case ;previous test
1cfc : c90f > cmp #test_num
> trap_ne ;test is out of sequence
1cfe : d0fe > bne * ;failed not equal (non zero)
>
0010 = >test_num = test_num + 1
1d00 : a910 > lda #test_num ;*** next tests' number
1d02 : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; testing TRB, TSB - zp / abs
trbt macro ;\1 = memory, \2 = flags
sty \1
load_flag \2
pha
lda zpt+1
plp
trb \1
php
cmp zpt+1
trap_ne ;accu was changed
pla
pha
ora #fz ;mask Z
cmp_flag \2|fz
trap_ne ;flags changed except Z
pla
and #fz
cmp zpt+2
trap_ne ;Z flag invalid
lda zpt+3
cmp zpt
trap_ne ;altered bits in memory wrong
endm
tsbt macro ;\1 = memory, \2 = flags
sty \1
load_flag \2
pha
lda zpt+1
plp
tsb \1
php
cmp zpt+1
trap_ne ;accu was changed
pla
pha
ora #fz ;mask Z
cmp_flag \2|fz
trap_ne ;flags changed except Z
pla
and #fz
cmp zpt+2
trap_ne ;Z flag invalid
lda zpt+4
cmp zpt
trap_ne ;altered bits in memory wrong
endm
1d05 : a2c0 ldx #$c0
1d07 : a000 ldy #0 ;op1 - memory save
; zpt ;op1 - memory modifiable
1d09 : 640d stz zpt+1 ;op2 - accu
; zpt+2 ;and flags
; zpt+3 ;memory after reset
; zpt+4 ;memory after set
1d0b : 98 tbt1 tya
1d0c : 250d and zpt+1 ;set Z by anding the 2 operands
1d0e : 08 php
1d0f : 68 pla
1d10 : 2902 and #fz ;mask Z
1d12 : 850e sta zpt+2
1d14 : 98 tya ;reset op1 bits by op2
1d15 : 49ff eor #$ff
1d17 : 050d ora zpt+1
1d19 : 49ff eor #$ff
1d1b : 850f sta zpt+3
1d1d : 98 tya ;set op1 bits by op2
1d1e : 050d ora zpt+1
1d20 : 8510 sta zpt+4
trbt zpt,$ff
1d22 : 840c > sty zpt
> load_flag $ff
1d24 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1d26 : 48 > pha
1d27 : a50d > lda zpt+1
1d29 : 28 > plp
1d2a : 140c > trb zpt
1d2c : 08 > php
1d2d : c50d > cmp zpt+1
> trap_ne ;accu was changed
1d2f : d0fe > bne * ;failed not equal (non zero)
>
1d31 : 68 > pla
1d32 : 48 > pha
1d33 : 0902 > ora #fz ;mask Z
> cmp_flag $ff|fz
1d35 : c9ff > cmp #($ff|fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne ;flags changed except Z
1d37 : d0fe > bne * ;failed not equal (non zero)
>
1d39 : 68 > pla
1d3a : 2902 > and #fz
1d3c : c50e > cmp zpt+2
> trap_ne ;Z flag invalid
1d3e : d0fe > bne * ;failed not equal (non zero)
>
1d40 : a50f > lda zpt+3
1d42 : c50c > cmp zpt
> trap_ne ;altered bits in memory wrong
1d44 : d0fe > bne * ;failed not equal (non zero)
>
trbt abst,$ff
1d46 : 8c0502 > sty abst
> load_flag $ff
1d49 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1d4b : 48 > pha
1d4c : a50d > lda zpt+1
1d4e : 28 > plp
1d4f : 1c0502 > trb abst
1d52 : 08 > php
1d53 : c50d > cmp zpt+1
> trap_ne ;accu was changed
1d55 : d0fe > bne * ;failed not equal (non zero)
>
1d57 : 68 > pla
1d58 : 48 > pha
1d59 : 0902 > ora #fz ;mask Z
> cmp_flag $ff|fz
1d5b : c9ff > cmp #($ff|fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne ;flags changed except Z
1d5d : d0fe > bne * ;failed not equal (non zero)
>
1d5f : 68 > pla
1d60 : 2902 > and #fz
1d62 : c50e > cmp zpt+2
> trap_ne ;Z flag invalid
1d64 : d0fe > bne * ;failed not equal (non zero)
>
1d66 : a50f > lda zpt+3
1d68 : c50c > cmp zpt
> trap_ne ;altered bits in memory wrong
1d6a : d0fe > bne * ;failed not equal (non zero)
>
trbt zpt,0
1d6c : 840c > sty zpt
> load_flag 0
1d6e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1d70 : 48 > pha
1d71 : a50d > lda zpt+1
1d73 : 28 > plp
1d74 : 140c > trb zpt
1d76 : 08 > php
1d77 : c50d > cmp zpt+1
> trap_ne ;accu was changed
1d79 : d0fe > bne * ;failed not equal (non zero)
>
1d7b : 68 > pla
1d7c : 48 > pha
1d7d : 0902 > ora #fz ;mask Z
> cmp_flag 0|fz
1d7f : c932 > cmp #(0|fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne ;flags changed except Z
1d81 : d0fe > bne * ;failed not equal (non zero)
>
1d83 : 68 > pla
1d84 : 2902 > and #fz
1d86 : c50e > cmp zpt+2
> trap_ne ;Z flag invalid
1d88 : d0fe > bne * ;failed not equal (non zero)
>
1d8a : a50f > lda zpt+3
1d8c : c50c > cmp zpt
> trap_ne ;altered bits in memory wrong
1d8e : d0fe > bne * ;failed not equal (non zero)
>
trbt abst,0
1d90 : 8c0502 > sty abst
> load_flag 0
1d93 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1d95 : 48 > pha
1d96 : a50d > lda zpt+1
1d98 : 28 > plp
1d99 : 1c0502 > trb abst
1d9c : 08 > php
1d9d : c50d > cmp zpt+1
> trap_ne ;accu was changed
1d9f : d0fe > bne * ;failed not equal (non zero)
>
1da1 : 68 > pla
1da2 : 48 > pha
1da3 : 0902 > ora #fz ;mask Z
> cmp_flag 0|fz
1da5 : c932 > cmp #(0|fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne ;flags changed except Z
1da7 : d0fe > bne * ;failed not equal (non zero)
>
1da9 : 68 > pla
1daa : 2902 > and #fz
1dac : c50e > cmp zpt+2
> trap_ne ;Z flag invalid
1dae : d0fe > bne * ;failed not equal (non zero)
>
1db0 : a50f > lda zpt+3
1db2 : c50c > cmp zpt
> trap_ne ;altered bits in memory wrong
1db4 : d0fe > bne * ;failed not equal (non zero)
>
tsbt zpt,$ff
1db6 : 840c > sty zpt
> load_flag $ff
1db8 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1dba : 48 > pha
1dbb : a50d > lda zpt+1
1dbd : 28 > plp
1dbe : 040c > tsb zpt
1dc0 : 08 > php
1dc1 : c50d > cmp zpt+1
> trap_ne ;accu was changed
1dc3 : d0fe > bne * ;failed not equal (non zero)
>
1dc5 : 68 > pla
1dc6 : 48 > pha
1dc7 : 0902 > ora #fz ;mask Z
> cmp_flag $ff|fz
1dc9 : c9ff > cmp #($ff|fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne ;flags changed except Z
1dcb : d0fe > bne * ;failed not equal (non zero)
>
1dcd : 68 > pla
1dce : 2902 > and #fz
1dd0 : c50e > cmp zpt+2
> trap_ne ;Z flag invalid
1dd2 : d0fe > bne * ;failed not equal (non zero)
>
1dd4 : a510 > lda zpt+4
1dd6 : c50c > cmp zpt
> trap_ne ;altered bits in memory wrong
1dd8 : d0fe > bne * ;failed not equal (non zero)
>
tsbt abst,$ff
1dda : 8c0502 > sty abst
> load_flag $ff
1ddd : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1ddf : 48 > pha
1de0 : a50d > lda zpt+1
1de2 : 28 > plp
1de3 : 0c0502 > tsb abst
1de6 : 08 > php
1de7 : c50d > cmp zpt+1
> trap_ne ;accu was changed
1de9 : d0fe > bne * ;failed not equal (non zero)
>
1deb : 68 > pla
1dec : 48 > pha
1ded : 0902 > ora #fz ;mask Z
> cmp_flag $ff|fz
1def : c9ff > cmp #($ff|fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne ;flags changed except Z
1df1 : d0fe > bne * ;failed not equal (non zero)
>
1df3 : 68 > pla
1df4 : 2902 > and #fz
1df6 : c50e > cmp zpt+2
> trap_ne ;Z flag invalid
1df8 : d0fe > bne * ;failed not equal (non zero)
>
1dfa : a510 > lda zpt+4
1dfc : c50c > cmp zpt
> trap_ne ;altered bits in memory wrong
1dfe : d0fe > bne * ;failed not equal (non zero)
>
tsbt zpt,0
1e00 : 840c > sty zpt
> load_flag 0
1e02 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1e04 : 48 > pha
1e05 : a50d > lda zpt+1
1e07 : 28 > plp
1e08 : 040c > tsb zpt
1e0a : 08 > php
1e0b : c50d > cmp zpt+1
> trap_ne ;accu was changed
1e0d : d0fe > bne * ;failed not equal (non zero)
>
1e0f : 68 > pla
1e10 : 48 > pha
1e11 : 0902 > ora #fz ;mask Z
> cmp_flag 0|fz
1e13 : c932 > cmp #(0|fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne ;flags changed except Z
1e15 : d0fe > bne * ;failed not equal (non zero)
>
1e17 : 68 > pla
1e18 : 2902 > and #fz
1e1a : c50e > cmp zpt+2
> trap_ne ;Z flag invalid
1e1c : d0fe > bne * ;failed not equal (non zero)
>
1e1e : a510 > lda zpt+4
1e20 : c50c > cmp zpt
> trap_ne ;altered bits in memory wrong
1e22 : d0fe > bne * ;failed not equal (non zero)
>
tsbt abst,0
1e24 : 8c0502 > sty abst
> load_flag 0
1e27 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1e29 : 48 > pha
1e2a : a50d > lda zpt+1
1e2c : 28 > plp
1e2d : 0c0502 > tsb abst
1e30 : 08 > php
1e31 : c50d > cmp zpt+1
> trap_ne ;accu was changed
1e33 : d0fe > bne * ;failed not equal (non zero)
>
1e35 : 68 > pla
1e36 : 48 > pha
1e37 : 0902 > ora #fz ;mask Z
> cmp_flag 0|fz
1e39 : c932 > cmp #(0|fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne ;flags changed except Z
1e3b : d0fe > bne * ;failed not equal (non zero)
>
1e3d : 68 > pla
1e3e : 2902 > and #fz
1e40 : c50e > cmp zpt+2
> trap_ne ;Z flag invalid
1e42 : d0fe > bne * ;failed not equal (non zero)
>
1e44 : a510 > lda zpt+4
1e46 : c50c > cmp zpt
> trap_ne ;altered bits in memory wrong
1e48 : d0fe > bne * ;failed not equal (non zero)
>
1e4a : c8 iny ;iterate op1
1e4b : d004 bne tbt3
1e4d : e60d inc zpt+1 ;iterate op2
1e4f : f003 beq tbt2
1e51 : 4c0b1d tbt3 jmp tbt1
1e54 : tbt2
1e54 : e0c0 cpx #$c0
trap_ne ;x altered during test
1e56 : d0fe > bne * ;failed not equal (non zero)
1e58 : ba tsx
1e59 : e0ff cpx #$ff
trap_ne ;sp push/pop mismatch
1e5b : d0fe > bne * ;failed not equal (non zero)
next_test
1e5d : ad0202 > lda test_case ;previous test
1e60 : c910 > cmp #test_num
> trap_ne ;test is out of sequence
1e62 : d0fe > bne * ;failed not equal (non zero)
>
0011 = >test_num = test_num + 1
1e64 : a911 > lda #test_num ;*** next tests' number
1e66 : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
if rkwl_wdc_op = 1
; testing RMB, SMB - zp
rmbt macro ;\1 = bitnum
lda #$ff
sta zpt
set_a $a5,0
rmb \1,zpt
tst_a $a5,0
lda zpt
cmp #$ff-(1<<\1)
trap_ne ;wrong bits set or cleared
lda #1<<\1
sta zpt
set_a $5a,$ff
rmb \1,zpt
tst_a $5a,$ff
lda zpt
trap_ne ;wrong bits set or cleared
endm
smbt macro ;\1 = bitnum
lda #$ff-(1<<\1)
sta zpt
set_a $a5,0
smb \1,zpt
tst_a $a5,0
lda zpt
cmp #$ff
trap_ne ;wrong bits set or cleared
lda #0
sta zpt
set_a $5a,$ff
smb \1,zpt
tst_a $5a,$ff
lda zpt
cmp #1<<\1
trap_ne ;wrong bits set or cleared
endm
1e69 : a2ba ldx #$ba ;protect x & y
1e6b : a0d0 ldy #$d0
rmbt 0
1e6d : a9ff > lda #$ff
1e6f : 850c > sta zpt
> set_a $a5,0
> load_flag 0
1e71 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1e73 : 48 > pha ;use stack to load status
1e74 : a9a5 > lda #$a5 ;precharge accu
1e76 : 28 > plp
>
1e77 : 070c > rmb 0,zpt
> tst_a $a5,0
1e79 : 08 > php ;save flags
1e7a : c9a5 > cmp #$a5 ;test result
> trap_ne
1e7c : d0fe > bne * ;failed not equal (non zero)
>
1e7e : 68 > pla ;load status
1e7f : 48 > pha
> cmp_flag 0
1e80 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1e82 : d0fe > bne * ;failed not equal (non zero)
>
1e84 : 28 > plp ;restore status
>
1e85 : a50c > lda zpt
1e87 : c9fe > cmp #$ff-(1<<0)
> trap_ne ;wrong bits set or cleared
1e89 : d0fe > bne * ;failed not equal (non zero)
>
1e8b : a901 > lda #1<<0
1e8d : 850c > sta zpt
> set_a $5a,$ff
> load_flag $ff
1e8f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1e91 : 48 > pha ;use stack to load status
1e92 : a95a > lda #$5a ;precharge accu
1e94 : 28 > plp
>
1e95 : 070c > rmb 0,zpt
> tst_a $5a,$ff
1e97 : 08 > php ;save flags
1e98 : c95a > cmp #$5a ;test result
> trap_ne
1e9a : d0fe > bne * ;failed not equal (non zero)
>
1e9c : 68 > pla ;load status
1e9d : 48 > pha
> cmp_flag $ff
1e9e : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1ea0 : d0fe > bne * ;failed not equal (non zero)
>
1ea2 : 28 > plp ;restore status
>
1ea3 : a50c > lda zpt
> trap_ne ;wrong bits set or cleared
1ea5 : d0fe > bne * ;failed not equal (non zero)
>
rmbt 1
1ea7 : a9ff > lda #$ff
1ea9 : 850c > sta zpt
> set_a $a5,0
> load_flag 0
1eab : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1ead : 48 > pha ;use stack to load status
1eae : a9a5 > lda #$a5 ;precharge accu
1eb0 : 28 > plp
>
1eb1 : 170c > rmb 1,zpt
> tst_a $a5,0
1eb3 : 08 > php ;save flags
1eb4 : c9a5 > cmp #$a5 ;test result
> trap_ne
1eb6 : d0fe > bne * ;failed not equal (non zero)
>
1eb8 : 68 > pla ;load status
1eb9 : 48 > pha
> cmp_flag 0
1eba : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1ebc : d0fe > bne * ;failed not equal (non zero)
>
1ebe : 28 > plp ;restore status
>
1ebf : a50c > lda zpt
1ec1 : c9fd > cmp #$ff-(1<<1)
> trap_ne ;wrong bits set or cleared
1ec3 : d0fe > bne * ;failed not equal (non zero)
>
1ec5 : a902 > lda #1<<1
1ec7 : 850c > sta zpt
> set_a $5a,$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 : a95a > lda #$5a ;precharge accu
1ece : 28 > plp
>
1ecf : 170c > rmb 1,zpt
> tst_a $5a,$ff
1ed1 : 08 > php ;save flags
1ed2 : c95a > cmp #$5a ;test result
> trap_ne
1ed4 : d0fe > bne * ;failed not equal (non zero)
>
1ed6 : 68 > pla ;load status
1ed7 : 48 > pha
> cmp_flag $ff
1ed8 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1eda : d0fe > bne * ;failed not equal (non zero)
>
1edc : 28 > plp ;restore status
>
1edd : a50c > lda zpt
> trap_ne ;wrong bits set or cleared
1edf : d0fe > bne * ;failed not equal (non zero)
>
rmbt 2
1ee1 : a9ff > lda #$ff
1ee3 : 850c > sta zpt
> set_a $a5,0
> load_flag 0
1ee5 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1ee7 : 48 > pha ;use stack to load status
1ee8 : a9a5 > lda #$a5 ;precharge accu
1eea : 28 > plp
>
1eeb : 270c > rmb 2,zpt
> tst_a $a5,0
1eed : 08 > php ;save flags
1eee : c9a5 > cmp #$a5 ;test result
> trap_ne
1ef0 : d0fe > bne * ;failed not equal (non zero)
>
1ef2 : 68 > pla ;load status
1ef3 : 48 > pha
> cmp_flag 0
1ef4 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1ef6 : d0fe > bne * ;failed not equal (non zero)
>
1ef8 : 28 > plp ;restore status
>
1ef9 : a50c > lda zpt
1efb : c9fb > cmp #$ff-(1<<2)
> trap_ne ;wrong bits set or cleared
1efd : d0fe > bne * ;failed not equal (non zero)
>
1eff : a904 > lda #1<<2
1f01 : 850c > sta zpt
> set_a $5a,$ff
> load_flag $ff
1f03 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1f05 : 48 > pha ;use stack to load status
1f06 : a95a > lda #$5a ;precharge accu
1f08 : 28 > plp
>
1f09 : 270c > rmb 2,zpt
> tst_a $5a,$ff
1f0b : 08 > php ;save flags
1f0c : c95a > cmp #$5a ;test result
> trap_ne
1f0e : d0fe > bne * ;failed not equal (non zero)
>
1f10 : 68 > pla ;load status
1f11 : 48 > pha
> cmp_flag $ff
1f12 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1f14 : d0fe > bne * ;failed not equal (non zero)
>
1f16 : 28 > plp ;restore status
>
1f17 : a50c > lda zpt
> trap_ne ;wrong bits set or cleared
1f19 : d0fe > bne * ;failed not equal (non zero)
>
rmbt 3
1f1b : a9ff > lda #$ff
1f1d : 850c > sta zpt
> set_a $a5,0
> load_flag 0
1f1f : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1f21 : 48 > pha ;use stack to load status
1f22 : a9a5 > lda #$a5 ;precharge accu
1f24 : 28 > plp
>
1f25 : 370c > rmb 3,zpt
> tst_a $a5,0
1f27 : 08 > php ;save flags
1f28 : c9a5 > cmp #$a5 ;test result
> trap_ne
1f2a : d0fe > bne * ;failed not equal (non zero)
>
1f2c : 68 > pla ;load status
1f2d : 48 > pha
> cmp_flag 0
1f2e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1f30 : d0fe > bne * ;failed not equal (non zero)
>
1f32 : 28 > plp ;restore status
>
1f33 : a50c > lda zpt
1f35 : c9f7 > cmp #$ff-(1<<3)
> trap_ne ;wrong bits set or cleared
1f37 : d0fe > bne * ;failed not equal (non zero)
>
1f39 : a908 > lda #1<<3
1f3b : 850c > sta zpt
> set_a $5a,$ff
> load_flag $ff
1f3d : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1f3f : 48 > pha ;use stack to load status
1f40 : a95a > lda #$5a ;precharge accu
1f42 : 28 > plp
>
1f43 : 370c > rmb 3,zpt
> tst_a $5a,$ff
1f45 : 08 > php ;save flags
1f46 : c95a > cmp #$5a ;test result
> trap_ne
1f48 : d0fe > bne * ;failed not equal (non zero)
>
1f4a : 68 > pla ;load status
1f4b : 48 > pha
> cmp_flag $ff
1f4c : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1f4e : d0fe > bne * ;failed not equal (non zero)
>
1f50 : 28 > plp ;restore status
>
1f51 : a50c > lda zpt
> trap_ne ;wrong bits set or cleared
1f53 : d0fe > bne * ;failed not equal (non zero)
>
rmbt 4
1f55 : a9ff > lda #$ff
1f57 : 850c > sta zpt
> set_a $a5,0
> load_flag 0
1f59 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1f5b : 48 > pha ;use stack to load status
1f5c : a9a5 > lda #$a5 ;precharge accu
1f5e : 28 > plp
>
1f5f : 470c > rmb 4,zpt
> tst_a $a5,0
1f61 : 08 > php ;save flags
1f62 : c9a5 > cmp #$a5 ;test result
> trap_ne
1f64 : d0fe > bne * ;failed not equal (non zero)
>
1f66 : 68 > pla ;load status
1f67 : 48 > pha
> cmp_flag 0
1f68 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1f6a : d0fe > bne * ;failed not equal (non zero)
>
1f6c : 28 > plp ;restore status
>
1f6d : a50c > lda zpt
1f6f : c9ef > cmp #$ff-(1<<4)
> trap_ne ;wrong bits set or cleared
1f71 : d0fe > bne * ;failed not equal (non zero)
>
1f73 : a910 > lda #1<<4
1f75 : 850c > sta zpt
> set_a $5a,$ff
> load_flag $ff
1f77 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1f79 : 48 > pha ;use stack to load status
1f7a : a95a > lda #$5a ;precharge accu
1f7c : 28 > plp
>
1f7d : 470c > rmb 4,zpt
> tst_a $5a,$ff
1f7f : 08 > php ;save flags
1f80 : c95a > cmp #$5a ;test result
> trap_ne
1f82 : d0fe > bne * ;failed not equal (non zero)
>
1f84 : 68 > pla ;load status
1f85 : 48 > pha
> cmp_flag $ff
1f86 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1f88 : d0fe > bne * ;failed not equal (non zero)
>
1f8a : 28 > plp ;restore status
>
1f8b : a50c > lda zpt
> trap_ne ;wrong bits set or cleared
1f8d : d0fe > bne * ;failed not equal (non zero)
>
rmbt 5
1f8f : a9ff > lda #$ff
1f91 : 850c > sta zpt
> set_a $a5,0
> load_flag 0
1f93 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1f95 : 48 > pha ;use stack to load status
1f96 : a9a5 > lda #$a5 ;precharge accu
1f98 : 28 > plp
>
1f99 : 570c > rmb 5,zpt
> tst_a $a5,0
1f9b : 08 > php ;save flags
1f9c : c9a5 > cmp #$a5 ;test result
> trap_ne
1f9e : d0fe > bne * ;failed not equal (non zero)
>
1fa0 : 68 > pla ;load status
1fa1 : 48 > pha
> cmp_flag 0
1fa2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1fa4 : d0fe > bne * ;failed not equal (non zero)
>
1fa6 : 28 > plp ;restore status
>
1fa7 : a50c > lda zpt
1fa9 : c9df > cmp #$ff-(1<<5)
> trap_ne ;wrong bits set or cleared
1fab : d0fe > bne * ;failed not equal (non zero)
>
1fad : a920 > lda #1<<5
1faf : 850c > sta zpt
> set_a $5a,$ff
> load_flag $ff
1fb1 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1fb3 : 48 > pha ;use stack to load status
1fb4 : a95a > lda #$5a ;precharge accu
1fb6 : 28 > plp
>
1fb7 : 570c > rmb 5,zpt
> tst_a $5a,$ff
1fb9 : 08 > php ;save flags
1fba : c95a > cmp #$5a ;test result
> trap_ne
1fbc : d0fe > bne * ;failed not equal (non zero)
>
1fbe : 68 > pla ;load status
1fbf : 48 > pha
> cmp_flag $ff
1fc0 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1fc2 : d0fe > bne * ;failed not equal (non zero)
>
1fc4 : 28 > plp ;restore status
>
1fc5 : a50c > lda zpt
> trap_ne ;wrong bits set or cleared
1fc7 : d0fe > bne * ;failed not equal (non zero)
>
rmbt 6
1fc9 : a9ff > lda #$ff
1fcb : 850c > sta zpt
> set_a $a5,0
> load_flag 0
1fcd : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1fcf : 48 > pha ;use stack to load status
1fd0 : a9a5 > lda #$a5 ;precharge accu
1fd2 : 28 > plp
>
1fd3 : 670c > rmb 6,zpt
> tst_a $a5,0
1fd5 : 08 > php ;save flags
1fd6 : c9a5 > cmp #$a5 ;test result
> trap_ne
1fd8 : d0fe > bne * ;failed not equal (non zero)
>
1fda : 68 > pla ;load status
1fdb : 48 > pha
> cmp_flag 0
1fdc : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1fde : d0fe > bne * ;failed not equal (non zero)
>
1fe0 : 28 > plp ;restore status
>
1fe1 : a50c > lda zpt
1fe3 : c9bf > cmp #$ff-(1<<6)
> trap_ne ;wrong bits set or cleared
1fe5 : d0fe > bne * ;failed not equal (non zero)
>
1fe7 : a940 > lda #1<<6
1fe9 : 850c > sta zpt
> set_a $5a,$ff
> load_flag $ff
1feb : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1fed : 48 > pha ;use stack to load status
1fee : a95a > lda #$5a ;precharge accu
1ff0 : 28 > plp
>
1ff1 : 670c > rmb 6,zpt
> tst_a $5a,$ff
1ff3 : 08 > php ;save flags
1ff4 : c95a > cmp #$5a ;test result
> trap_ne
1ff6 : d0fe > bne * ;failed not equal (non zero)
>
1ff8 : 68 > pla ;load status
1ff9 : 48 > pha
> cmp_flag $ff
1ffa : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1ffc : d0fe > bne * ;failed not equal (non zero)
>
1ffe : 28 > plp ;restore status
>
1fff : a50c > lda zpt
> trap_ne ;wrong bits set or cleared
2001 : d0fe > bne * ;failed not equal (non zero)
>
rmbt 7
2003 : a9ff > lda #$ff
2005 : 850c > sta zpt
> set_a $a5,0
> load_flag 0
2007 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2009 : 48 > pha ;use stack to load status
200a : a9a5 > lda #$a5 ;precharge accu
200c : 28 > plp
>
200d : 770c > rmb 7,zpt
> tst_a $a5,0
200f : 08 > php ;save flags
2010 : c9a5 > cmp #$a5 ;test result
> trap_ne
2012 : d0fe > bne * ;failed not equal (non zero)
>
2014 : 68 > pla ;load status
2015 : 48 > pha
> cmp_flag 0
2016 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2018 : d0fe > bne * ;failed not equal (non zero)
>
201a : 28 > plp ;restore status
>
201b : a50c > lda zpt
201d : c97f > cmp #$ff-(1<<7)
> trap_ne ;wrong bits set or cleared
201f : d0fe > bne * ;failed not equal (non zero)
>
2021 : a980 > lda #1<<7
2023 : 850c > sta zpt
> set_a $5a,$ff
> load_flag $ff
2025 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2027 : 48 > pha ;use stack to load status
2028 : a95a > lda #$5a ;precharge accu
202a : 28 > plp
>
202b : 770c > rmb 7,zpt
> tst_a $5a,$ff
202d : 08 > php ;save flags
202e : c95a > cmp #$5a ;test result
> trap_ne
2030 : d0fe > bne * ;failed not equal (non zero)
>
2032 : 68 > pla ;load status
2033 : 48 > pha
> cmp_flag $ff
2034 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2036 : d0fe > bne * ;failed not equal (non zero)
>
2038 : 28 > plp ;restore status
>
2039 : a50c > lda zpt
> trap_ne ;wrong bits set or cleared
203b : d0fe > bne * ;failed not equal (non zero)
>
smbt 0
203d : a9fe > lda #$ff-(1<<0)
203f : 850c > sta zpt
> set_a $a5,0
> load_flag 0
2041 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2043 : 48 > pha ;use stack to load status
2044 : a9a5 > lda #$a5 ;precharge accu
2046 : 28 > plp
>
2047 : 870c > smb 0,zpt
> tst_a $a5,0
2049 : 08 > php ;save flags
204a : c9a5 > cmp #$a5 ;test result
> trap_ne
204c : d0fe > bne * ;failed not equal (non zero)
>
204e : 68 > pla ;load status
204f : 48 > pha
> cmp_flag 0
2050 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2052 : d0fe > bne * ;failed not equal (non zero)
>
2054 : 28 > plp ;restore status
>
2055 : a50c > lda zpt
2057 : c9ff > cmp #$ff
> trap_ne ;wrong bits set or cleared
2059 : d0fe > bne * ;failed not equal (non zero)
>
205b : a900 > lda #0
205d : 850c > sta zpt
> set_a $5a,$ff
> load_flag $ff
205f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2061 : 48 > pha ;use stack to load status
2062 : a95a > lda #$5a ;precharge accu
2064 : 28 > plp
>
2065 : 870c > smb 0,zpt
> tst_a $5a,$ff
2067 : 08 > php ;save flags
2068 : c95a > cmp #$5a ;test result
> trap_ne
206a : d0fe > bne * ;failed not equal (non zero)
>
206c : 68 > pla ;load status
206d : 48 > pha
> cmp_flag $ff
206e : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2070 : d0fe > bne * ;failed not equal (non zero)
>
2072 : 28 > plp ;restore status
>
2073 : a50c > lda zpt
2075 : c901 > cmp #1<<0
> trap_ne ;wrong bits set or cleared
2077 : d0fe > bne * ;failed not equal (non zero)
>
smbt 1
2079 : a9fd > lda #$ff-(1<<1)
207b : 850c > sta zpt
> set_a $a5,0
> load_flag 0
207d : a900 > lda #0 ;allow test to change I-flag (no mask)
>
207f : 48 > pha ;use stack to load status
2080 : a9a5 > lda #$a5 ;precharge accu
2082 : 28 > plp
>
2083 : 970c > smb 1,zpt
> tst_a $a5,0
2085 : 08 > php ;save flags
2086 : c9a5 > cmp #$a5 ;test result
> trap_ne
2088 : d0fe > bne * ;failed not equal (non zero)
>
208a : 68 > pla ;load status
208b : 48 > pha
> cmp_flag 0
208c : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
208e : d0fe > bne * ;failed not equal (non zero)
>
2090 : 28 > plp ;restore status
>
2091 : a50c > lda zpt
2093 : c9ff > cmp #$ff
> trap_ne ;wrong bits set or cleared
2095 : d0fe > bne * ;failed not equal (non zero)
>
2097 : a900 > lda #0
2099 : 850c > sta zpt
> set_a $5a,$ff
> load_flag $ff
209b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
209d : 48 > pha ;use stack to load status
209e : a95a > lda #$5a ;precharge accu
20a0 : 28 > plp
>
20a1 : 970c > smb 1,zpt
> tst_a $5a,$ff
20a3 : 08 > php ;save flags
20a4 : c95a > cmp #$5a ;test result
> trap_ne
20a6 : d0fe > bne * ;failed not equal (non zero)
>
20a8 : 68 > pla ;load status
20a9 : 48 > pha
> cmp_flag $ff
20aa : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
20ac : d0fe > bne * ;failed not equal (non zero)
>
20ae : 28 > plp ;restore status
>
20af : a50c > lda zpt
20b1 : c902 > cmp #1<<1
> trap_ne ;wrong bits set or cleared
20b3 : d0fe > bne * ;failed not equal (non zero)
>
smbt 2
20b5 : a9fb > lda #$ff-(1<<2)
20b7 : 850c > sta zpt
> set_a $a5,0
> load_flag 0
20b9 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
20bb : 48 > pha ;use stack to load status
20bc : a9a5 > lda #$a5 ;precharge accu
20be : 28 > plp
>
20bf : a70c > smb 2,zpt
> tst_a $a5,0
20c1 : 08 > php ;save flags
20c2 : c9a5 > cmp #$a5 ;test result
> trap_ne
20c4 : d0fe > bne * ;failed not equal (non zero)
>
20c6 : 68 > pla ;load status
20c7 : 48 > pha
> cmp_flag 0
20c8 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
20ca : d0fe > bne * ;failed not equal (non zero)
>
20cc : 28 > plp ;restore status
>
20cd : a50c > lda zpt
20cf : c9ff > cmp #$ff
> trap_ne ;wrong bits set or cleared
20d1 : d0fe > bne * ;failed not equal (non zero)
>
20d3 : a900 > lda #0
20d5 : 850c > sta zpt
> set_a $5a,$ff
> load_flag $ff
20d7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
20d9 : 48 > pha ;use stack to load status
20da : a95a > lda #$5a ;precharge accu
20dc : 28 > plp
>
20dd : a70c > smb 2,zpt
> tst_a $5a,$ff
20df : 08 > php ;save flags
20e0 : c95a > cmp #$5a ;test result
> trap_ne
20e2 : d0fe > bne * ;failed not equal (non zero)
>
20e4 : 68 > pla ;load status
20e5 : 48 > pha
> cmp_flag $ff
20e6 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
20e8 : d0fe > bne * ;failed not equal (non zero)
>
20ea : 28 > plp ;restore status
>
20eb : a50c > lda zpt
20ed : c904 > cmp #1<<2
> trap_ne ;wrong bits set or cleared
20ef : d0fe > bne * ;failed not equal (non zero)
>
smbt 3
20f1 : a9f7 > lda #$ff-(1<<3)
20f3 : 850c > sta zpt
> set_a $a5,0
> load_flag 0
20f5 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
20f7 : 48 > pha ;use stack to load status
20f8 : a9a5 > lda #$a5 ;precharge accu
20fa : 28 > plp
>
20fb : b70c > smb 3,zpt
> tst_a $a5,0
20fd : 08 > php ;save flags
20fe : c9a5 > cmp #$a5 ;test result
> trap_ne
2100 : d0fe > bne * ;failed not equal (non zero)
>
2102 : 68 > pla ;load status
2103 : 48 > pha
> cmp_flag 0
2104 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2106 : d0fe > bne * ;failed not equal (non zero)
>
2108 : 28 > plp ;restore status
>
2109 : a50c > lda zpt
210b : c9ff > cmp #$ff
> trap_ne ;wrong bits set or cleared
210d : d0fe > bne * ;failed not equal (non zero)
>
210f : a900 > lda #0
2111 : 850c > sta zpt
> set_a $5a,$ff
> load_flag $ff
2113 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2115 : 48 > pha ;use stack to load status
2116 : a95a > lda #$5a ;precharge accu
2118 : 28 > plp
>
2119 : b70c > smb 3,zpt
> tst_a $5a,$ff
211b : 08 > php ;save flags
211c : c95a > cmp #$5a ;test result
> trap_ne
211e : d0fe > bne * ;failed not equal (non zero)
>
2120 : 68 > pla ;load status
2121 : 48 > pha
> cmp_flag $ff
2122 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2124 : d0fe > bne * ;failed not equal (non zero)
>
2126 : 28 > plp ;restore status
>
2127 : a50c > lda zpt
2129 : c908 > cmp #1<<3
> trap_ne ;wrong bits set or cleared
212b : d0fe > bne * ;failed not equal (non zero)
>
smbt 4
212d : a9ef > lda #$ff-(1<<4)
212f : 850c > sta zpt
> set_a $a5,0
> load_flag 0
2131 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2133 : 48 > pha ;use stack to load status
2134 : a9a5 > lda #$a5 ;precharge accu
2136 : 28 > plp
>
2137 : c70c > smb 4,zpt
> tst_a $a5,0
2139 : 08 > php ;save flags
213a : c9a5 > cmp #$a5 ;test result
> trap_ne
213c : d0fe > bne * ;failed not equal (non zero)
>
213e : 68 > pla ;load status
213f : 48 > pha
> cmp_flag 0
2140 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2142 : d0fe > bne * ;failed not equal (non zero)
>
2144 : 28 > plp ;restore status
>
2145 : a50c > lda zpt
2147 : c9ff > cmp #$ff
> trap_ne ;wrong bits set or cleared
2149 : d0fe > bne * ;failed not equal (non zero)
>
214b : a900 > lda #0
214d : 850c > sta zpt
> set_a $5a,$ff
> load_flag $ff
214f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2151 : 48 > pha ;use stack to load status
2152 : a95a > lda #$5a ;precharge accu
2154 : 28 > plp
>
2155 : c70c > smb 4,zpt
> tst_a $5a,$ff
2157 : 08 > php ;save flags
2158 : c95a > cmp #$5a ;test result
> trap_ne
215a : d0fe > bne * ;failed not equal (non zero)
>
215c : 68 > pla ;load status
215d : 48 > pha
> cmp_flag $ff
215e : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2160 : d0fe > bne * ;failed not equal (non zero)
>
2162 : 28 > plp ;restore status
>
2163 : a50c > lda zpt
2165 : c910 > cmp #1<<4
> trap_ne ;wrong bits set or cleared
2167 : d0fe > bne * ;failed not equal (non zero)
>
smbt 5
2169 : a9df > lda #$ff-(1<<5)
216b : 850c > sta zpt
> set_a $a5,0
> load_flag 0
216d : a900 > lda #0 ;allow test to change I-flag (no mask)
>
216f : 48 > pha ;use stack to load status
2170 : a9a5 > lda #$a5 ;precharge accu
2172 : 28 > plp
>
2173 : d70c > smb 5,zpt
> tst_a $a5,0
2175 : 08 > php ;save flags
2176 : c9a5 > cmp #$a5 ;test result
> trap_ne
2178 : d0fe > bne * ;failed not equal (non zero)
>
217a : 68 > pla ;load status
217b : 48 > pha
> cmp_flag 0
217c : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
217e : d0fe > bne * ;failed not equal (non zero)
>
2180 : 28 > plp ;restore status
>
2181 : a50c > lda zpt
2183 : c9ff > cmp #$ff
> trap_ne ;wrong bits set or cleared
2185 : d0fe > bne * ;failed not equal (non zero)
>
2187 : a900 > lda #0
2189 : 850c > sta zpt
> set_a $5a,$ff
> load_flag $ff
218b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
218d : 48 > pha ;use stack to load status
218e : a95a > lda #$5a ;precharge accu
2190 : 28 > plp
>
2191 : d70c > smb 5,zpt
> tst_a $5a,$ff
2193 : 08 > php ;save flags
2194 : c95a > cmp #$5a ;test result
> trap_ne
2196 : d0fe > bne * ;failed not equal (non zero)
>
2198 : 68 > pla ;load status
2199 : 48 > pha
> cmp_flag $ff
219a : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
219c : d0fe > bne * ;failed not equal (non zero)
>
219e : 28 > plp ;restore status
>
219f : a50c > lda zpt
21a1 : c920 > cmp #1<<5
> trap_ne ;wrong bits set or cleared
21a3 : d0fe > bne * ;failed not equal (non zero)
>
smbt 6
21a5 : a9bf > lda #$ff-(1<<6)
21a7 : 850c > sta zpt
> set_a $a5,0
> load_flag 0
21a9 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
21ab : 48 > pha ;use stack to load status
21ac : a9a5 > lda #$a5 ;precharge accu
21ae : 28 > plp
>
21af : e70c > smb 6,zpt
> tst_a $a5,0
21b1 : 08 > php ;save flags
21b2 : c9a5 > cmp #$a5 ;test result
> trap_ne
21b4 : d0fe > bne * ;failed not equal (non zero)
>
21b6 : 68 > pla ;load status
21b7 : 48 > pha
> cmp_flag 0
21b8 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
21ba : d0fe > bne * ;failed not equal (non zero)
>
21bc : 28 > plp ;restore status
>
21bd : a50c > lda zpt
21bf : c9ff > cmp #$ff
> trap_ne ;wrong bits set or cleared
21c1 : d0fe > bne * ;failed not equal (non zero)
>
21c3 : a900 > lda #0
21c5 : 850c > sta zpt
> set_a $5a,$ff
> load_flag $ff
21c7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
21c9 : 48 > pha ;use stack to load status
21ca : a95a > lda #$5a ;precharge accu
21cc : 28 > plp
>
21cd : e70c > smb 6,zpt
> tst_a $5a,$ff
21cf : 08 > php ;save flags
21d0 : c95a > cmp #$5a ;test result
> trap_ne
21d2 : d0fe > bne * ;failed not equal (non zero)
>
21d4 : 68 > pla ;load status
21d5 : 48 > pha
> cmp_flag $ff
21d6 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
21d8 : d0fe > bne * ;failed not equal (non zero)
>
21da : 28 > plp ;restore status
>
21db : a50c > lda zpt
21dd : c940 > cmp #1<<6
> trap_ne ;wrong bits set or cleared
21df : d0fe > bne * ;failed not equal (non zero)
>
smbt 7
21e1 : a97f > lda #$ff-(1<<7)
21e3 : 850c > sta zpt
> set_a $a5,0
> load_flag 0
21e5 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
21e7 : 48 > pha ;use stack to load status
21e8 : a9a5 > lda #$a5 ;precharge accu
21ea : 28 > plp
>
21eb : f70c > smb 7,zpt
> tst_a $a5,0
21ed : 08 > php ;save flags
21ee : c9a5 > cmp #$a5 ;test result
> trap_ne
21f0 : d0fe > bne * ;failed not equal (non zero)
>
21f2 : 68 > pla ;load status
21f3 : 48 > pha
> cmp_flag 0
21f4 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
21f6 : d0fe > bne * ;failed not equal (non zero)
>
21f8 : 28 > plp ;restore status
>
21f9 : a50c > lda zpt
21fb : c9ff > cmp #$ff
> trap_ne ;wrong bits set or cleared
21fd : d0fe > bne * ;failed not equal (non zero)
>
21ff : a900 > lda #0
2201 : 850c > sta zpt
> set_a $5a,$ff
> load_flag $ff
2203 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2205 : 48 > pha ;use stack to load status
2206 : a95a > lda #$5a ;precharge accu
2208 : 28 > plp
>
2209 : f70c > smb 7,zpt
> tst_a $5a,$ff
220b : 08 > php ;save flags
220c : c95a > cmp #$5a ;test result
> trap_ne
220e : d0fe > bne * ;failed not equal (non zero)
>
2210 : 68 > pla ;load status
2211 : 48 > pha
> cmp_flag $ff
2212 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2214 : d0fe > bne * ;failed not equal (non zero)
>
2216 : 28 > plp ;restore status
>
2217 : a50c > lda zpt
2219 : c980 > cmp #1<<7
> trap_ne ;wrong bits set or cleared
221b : d0fe > bne * ;failed not equal (non zero)
>
221d : e0ba cpx #$ba
trap_ne ;x altered during test
221f : d0fe > bne * ;failed not equal (non zero)
2221 : c0d0 cpy #$d0
trap_ne ;y altered during test
2223 : d0fe > bne * ;failed not equal (non zero)
2225 : ba tsx
2226 : e0ff cpx #$ff
trap_ne ;sp push/pop mismatch
2228 : d0fe > bne * ;failed not equal (non zero)
next_test
222a : ad0202 > lda test_case ;previous test
222d : c911 > cmp #test_num
> trap_ne ;test is out of sequence
222f : d0fe > bne * ;failed not equal (non zero)
>
0012 = >test_num = test_num + 1
2231 : a912 > lda #test_num ;*** next tests' number
2233 : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
endif
; testing CMP - (zp)
2236 : a2de ldx #$de ;protect x & y
2238 : a0ad ldy #$ad
set_a $80,0
> load_flag 0
223a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
223c : 48 > pha ;use stack to load status
223d : a980 > lda #$80 ;precharge accu
223f : 28 > plp
2240 : d22c cmp (ind1+8)
tst_a $80,fc
2242 : 08 > php ;save flags
2243 : c980 > cmp #$80 ;test result
> trap_ne
2245 : d0fe > bne * ;failed not equal (non zero)
>
2247 : 68 > pla ;load status
2248 : 48 > pha
> cmp_flag fc
2249 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
224b : d0fe > bne * ;failed not equal (non zero)
>
224d : 28 > plp ;restore status
set_a $7f,0
> load_flag 0
224e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2250 : 48 > pha ;use stack to load status
2251 : a97f > lda #$7f ;precharge accu
2253 : 28 > plp
2254 : d22c cmp (ind1+8)
tst_a $7f,fzc
2256 : 08 > php ;save flags
2257 : c97f > cmp #$7f ;test result
> trap_ne
2259 : d0fe > bne * ;failed not equal (non zero)
>
225b : 68 > pla ;load status
225c : 48 > pha
> cmp_flag fzc
225d : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
225f : d0fe > bne * ;failed not equal (non zero)
>
2261 : 28 > plp ;restore status
set_a $7e,0
> load_flag 0
2262 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2264 : 48 > pha ;use stack to load status
2265 : a97e > lda #$7e ;precharge accu
2267 : 28 > plp
2268 : d22c cmp (ind1+8)
tst_a $7e,fn
226a : 08 > php ;save flags
226b : c97e > cmp #$7e ;test result
> trap_ne
226d : d0fe > bne * ;failed not equal (non zero)
>
226f : 68 > pla ;load status
2270 : 48 > pha
> cmp_flag fn
2271 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2273 : d0fe > bne * ;failed not equal (non zero)
>
2275 : 28 > plp ;restore status
set_a $80,$ff
> load_flag $ff
2276 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2278 : 48 > pha ;use stack to load status
2279 : a980 > lda #$80 ;precharge accu
227b : 28 > plp
227c : d22c cmp (ind1+8)
tst_a $80,~fnz
227e : 08 > php ;save flags
227f : c980 > cmp #$80 ;test result
> trap_ne
2281 : d0fe > bne * ;failed not equal (non zero)
>
2283 : 68 > pla ;load status
2284 : 48 > pha
> cmp_flag ~fnz
2285 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2287 : d0fe > bne * ;failed not equal (non zero)
>
2289 : 28 > plp ;restore status
set_a $7f,$ff
> load_flag $ff
228a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
228c : 48 > pha ;use stack to load status
228d : a97f > lda #$7f ;precharge accu
228f : 28 > plp
2290 : d22c cmp (ind1+8)
tst_a $7f,~fn
2292 : 08 > php ;save flags
2293 : c97f > cmp #$7f ;test result
> trap_ne
2295 : d0fe > bne * ;failed not equal (non zero)
>
2297 : 68 > pla ;load status
2298 : 48 > pha
> cmp_flag ~fn
2299 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
229b : d0fe > bne * ;failed not equal (non zero)
>
229d : 28 > plp ;restore status
set_a $7e,$ff
> load_flag $ff
229e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
22a0 : 48 > pha ;use stack to load status
22a1 : a97e > lda #$7e ;precharge accu
22a3 : 28 > plp
22a4 : d22c cmp (ind1+8)
tst_a $7e,~fzc
22a6 : 08 > php ;save flags
22a7 : c97e > cmp #$7e ;test result
> trap_ne
22a9 : d0fe > bne * ;failed not equal (non zero)
>
22ab : 68 > pla ;load status
22ac : 48 > pha
> cmp_flag ~fzc
22ad : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
22af : d0fe > bne * ;failed not equal (non zero)
>
22b1 : 28 > plp ;restore status
22b2 : e0de cpx #$de
trap_ne ;x altered during test
22b4 : d0fe > bne * ;failed not equal (non zero)
22b6 : c0ad cpy #$ad
trap_ne ;y altered during test
22b8 : d0fe > bne * ;failed not equal (non zero)
22ba : ba tsx
22bb : e0ff cpx #$ff
trap_ne ;sp push/pop mismatch
22bd : d0fe > bne * ;failed not equal (non zero)
next_test
22bf : ad0202 > lda test_case ;previous test
22c2 : c912 > cmp #test_num
> trap_ne ;test is out of sequence
22c4 : d0fe > bne * ;failed not equal (non zero)
>
0013 = >test_num = test_num + 1
22c6 : a913 > lda #test_num ;*** next tests' number
22c8 : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; testing logical instructions - AND EOR ORA (zp)
22cb : a242 ldx #$42 ;protect x & y
22cd : a000 ldy #0 ;AND
22cf : a53a lda indAN ;set indirect address
22d1 : 850c sta zpt
22d3 : a53b lda indAN+1
22d5 : 850d sta zpt+1
22d7 : tand1
set_ay absANa,0
> load_flag 0
22d7 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
22d9 : 48 > pha ;use stack to load status
22da : b95302 > lda absANa,y ;precharge accu
22dd : 28 > plp
22de : 320c and (zpt)
tst_ay absrlo,absflo,0
22e0 : 08 > php ;save flags
22e1 : d95b02 > cmp absrlo,y ;test result
> trap_ne ;
22e4 : d0fe > bne * ;failed not equal (non zero)
>
22e6 : 68 > pla ;load status
> eor_flag 0
22e7 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
22e9 : d95f02 > cmp absflo,y ;test flags
> trap_ne
22ec : d0fe > bne * ;failed not equal (non zero)
>
22ee : e60c inc zpt
22f0 : c8 iny
22f1 : c004 cpy #4
22f3 : d0e2 bne tand1
22f5 : 88 dey
22f6 : c60c dec zpt
22f8 : tand2
set_ay absANa,$ff
> load_flag $ff
22f8 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
22fa : 48 > pha ;use stack to load status
22fb : b95302 > lda absANa,y ;precharge accu
22fe : 28 > plp
22ff : 320c and (zpt)
tst_ay absrlo,absflo,$ff-fnz
2301 : 08 > php ;save flags
2302 : d95b02 > cmp absrlo,y ;test result
> trap_ne ;
2305 : d0fe > bne * ;failed not equal (non zero)
>
2307 : 68 > pla ;load status
> eor_flag $ff-fnz
2308 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
230a : d95f02 > cmp absflo,y ;test flags
> trap_ne
230d : d0fe > bne * ;failed not equal (non zero)
>
230f : c60c dec zpt
2311 : 88 dey
2312 : 10e4 bpl tand2
2314 : a000 ldy #0 ;EOR
2316 : a542 lda indEO ;set indirect address
2318 : 850c sta zpt
231a : a543 lda indEO+1
231c : 850d sta zpt+1
231e : teor1
set_ay absEOa,0
> load_flag 0
231e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2320 : 48 > pha ;use stack to load status
2321 : b95702 > lda absEOa,y ;precharge accu
2324 : 28 > plp
2325 : 520c eor (zpt)
tst_ay absrlo,absflo,0
2327 : 08 > php ;save flags
2328 : d95b02 > cmp absrlo,y ;test result
> trap_ne ;
232b : d0fe > bne * ;failed not equal (non zero)
>
232d : 68 > pla ;load status
> eor_flag 0
232e : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2330 : d95f02 > cmp absflo,y ;test flags
> trap_ne
2333 : d0fe > bne * ;failed not equal (non zero)
>
2335 : e60c inc zpt
2337 : c8 iny
2338 : c004 cpy #4
233a : d0e2 bne teor1
233c : 88 dey
233d : c60c dec zpt
233f : teor2
set_ay absEOa,$ff
> load_flag $ff
233f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2341 : 48 > pha ;use stack to load status
2342 : b95702 > lda absEOa,y ;precharge accu
2345 : 28 > plp
2346 : 520c eor (zpt)
tst_ay absrlo,absflo,$ff-fnz
2348 : 08 > php ;save flags
2349 : d95b02 > cmp absrlo,y ;test result
> trap_ne ;
234c : d0fe > bne * ;failed not equal (non zero)
>
234e : 68 > pla ;load status
> eor_flag $ff-fnz
234f : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
2351 : d95f02 > cmp absflo,y ;test flags
> trap_ne
2354 : d0fe > bne * ;failed not equal (non zero)
>
2356 : c60c dec zpt
2358 : 88 dey
2359 : 10e4 bpl teor2
235b : a000 ldy #0 ;ORA
235d : a54a lda indOR ;set indirect address
235f : 850c sta zpt
2361 : a54b lda indOR+1
2363 : 850d sta zpt+1
2365 : tora1
set_ay absORa,0
> load_flag 0
2365 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2367 : 48 > pha ;use stack to load status
2368 : b94f02 > lda absORa,y ;precharge accu
236b : 28 > plp
236c : 120c ora (zpt)
tst_ay absrlo,absflo,0
236e : 08 > php ;save flags
236f : d95b02 > cmp absrlo,y ;test result
> trap_ne ;
2372 : d0fe > bne * ;failed not equal (non zero)
>
2374 : 68 > pla ;load status
> eor_flag 0
2375 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2377 : d95f02 > cmp absflo,y ;test flags
> trap_ne
237a : d0fe > bne * ;failed not equal (non zero)
>
237c : e60c inc zpt
237e : c8 iny
237f : c004 cpy #4
2381 : d0e2 bne tora1
2383 : 88 dey
2384 : c60c dec zpt
2386 : tora2
set_ay absORa,$ff
> load_flag $ff
2386 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2388 : 48 > pha ;use stack to load status
2389 : b94f02 > lda absORa,y ;precharge accu
238c : 28 > plp
238d : 120c ora (zpt)
tst_ay absrlo,absflo,$ff-fnz
238f : 08 > php ;save flags
2390 : d95b02 > cmp absrlo,y ;test result
> trap_ne ;
2393 : d0fe > bne * ;failed not equal (non zero)
>
2395 : 68 > pla ;load status
> eor_flag $ff-fnz
2396 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
2398 : d95f02 > cmp absflo,y ;test flags
> trap_ne
239b : d0fe > bne * ;failed not equal (non zero)
>
239d : c60c dec zpt
239f : 88 dey
23a0 : 10e4 bpl tora2
23a2 : e042 cpx #$42
trap_ne ;x altered during test
23a4 : d0fe > bne * ;failed not equal (non zero)
23a6 : ba tsx
23a7 : e0ff cpx #$ff
trap_ne ;sp push/pop mismatch
23a9 : d0fe > bne * ;failed not equal (non zero)
next_test
23ab : ad0202 > lda test_case ;previous test
23ae : c913 > cmp #test_num
> trap_ne ;test is out of sequence
23b0 : d0fe > bne * ;failed not equal (non zero)
>
0014 = >test_num = test_num + 1
23b2 : a914 > lda #test_num ;*** next tests' number
23b4 : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
if I_flag = 3
23b7 : 58 cli
endif
; full binary add/subtract test - (zp) only
; iterates through all combinations of operands and carry input
; uses increments/decrements to predict result & result flags
23b8 : d8 cld
23b9 : a20e ldx #ad2 ;for indexed test
23bb : a0ff ldy #$ff ;max range
23bd : a900 lda #0 ;start with adding zeroes & no carry
23bf : 850c sta adfc ;carry in - for diag
23c1 : 850d sta ad1 ;operand 1 - accumulator
23c3 : 850e sta ad2 ;operand 2 - memory or immediate
23c5 : 8d0502 sta ada2 ;non zp
23c8 : 850f sta adrl ;expected result bits 0-7
23ca : 8510 sta adrh ;expected result bit 8 (carry out)
23cc : a9ff lda #$ff ;complemented operand 2 for subtract
23ce : 8512 sta sb2
23d0 : 8d0602 sta sba2 ;non zp
23d3 : a902 lda #2 ;expected Z-flag
23d5 : 8511 sta adrf
23d7 : 18 tadd clc ;test with carry clear
23d8 : 204e26 jsr chkadd
23db : e60c inc adfc ;now with carry
23dd : e60f inc adrl ;result +1
23df : 08 php ;save N & Z from low result
23e0 : 08 php
23e1 : 68 pla ;accu holds expected flags
23e2 : 2982 and #$82 ;mask N & Z
23e4 : 28 plp
23e5 : d002 bne tadd1
23e7 : e610 inc adrh ;result bit 8 - carry
23e9 : 0510 tadd1 ora adrh ;merge C to expected flags
23eb : 8511 sta adrf ;save expected flags except overflow
23ed : 38 sec ;test with carry set
23ee : 204e26 jsr chkadd
23f1 : c60c dec adfc ;same for operand +1 but no carry
23f3 : e60d inc ad1
23f5 : d0e0 bne tadd ;iterate op1
23f7 : a900 lda #0 ;preset result to op2 when op1 = 0
23f9 : 8510 sta adrh
23fb : ee0502 inc ada2
23fe : e60e inc ad2
2400 : 08 php ;save NZ as operand 2 becomes the new result
2401 : 68 pla
2402 : 2982 and #$82 ;mask N00000Z0
2404 : 8511 sta adrf ;no need to check carry as we are adding to 0
2406 : c612 dec sb2 ;complement subtract operand 2
2408 : ce0602 dec sba2
240b : a50e lda ad2
240d : 850f sta adrl
240f : d0c6 bne tadd ;iterate op2
2411 : e00e cpx #ad2
trap_ne ;x altered during test
2413 : d0fe > bne * ;failed not equal (non zero)
2415 : c0ff cpy #$ff
trap_ne ;y altered during test
2417 : d0fe > bne * ;failed not equal (non zero)
2419 : ba tsx
241a : e0ff cpx #$ff
trap_ne ;sp push/pop mismatch
241c : d0fe > bne * ;failed not equal (non zero)
next_test
241e : ad0202 > lda test_case ;previous test
2421 : c914 > cmp #test_num
> trap_ne ;test is out of sequence
2423 : d0fe > bne * ;failed not equal (non zero)
>
0015 = >test_num = test_num + 1
2425 : a915 > lda #test_num ;*** next tests' number
2427 : 8d0202 > 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, the V flag is ignored
; although V is declared as beeing valid on the 65C02 it has absolutely
; no use in BCD math. No sign = no overflow!
; iterates through all valid combinations of operands and carry input
; uses increments/decrements to predict result & carry flag
242a : f8 sed
242b : a20e ldx #ad2 ;for indexed test
242d : a0ff ldy #$ff ;max range
242f : a999 lda #$99 ;start with adding 99 to 99 with carry
2431 : 850d sta ad1 ;operand 1 - accumulator
2433 : 850e sta ad2 ;operand 2 - memory or immediate
2435 : 8d0502 sta ada2 ;non zp
2438 : 850f sta adrl ;expected result bits 0-7
243a : a901 lda #1 ;set carry in & out
243c : 850c sta adfc ;carry in - for diag
243e : 8510 sta adrh ;expected result bit 8 (carry out)
2440 : a981 lda #$81 ;set N & C (99 + 99 + C = 99 + C)
2442 : 8511 sta adrf
2444 : a900 lda #0 ;complemented operand 2 for subtract
2446 : 8512 sta sb2
2448 : 8d0602 sta sba2 ;non zp
244b : 38 tdad sec ;test with carry set
244c : 20f724 jsr chkdad
244f : c60c dec adfc ;now with carry clear
2451 : a50f lda adrl ;decimal adjust result
2453 : d008 bne tdad1 ;skip clear carry & preset result 99 (9A-1)
2455 : c610 dec adrh
2457 : a999 lda #$99
2459 : 850f sta adrl
245b : d012 bne tdad3
245d : 290f tdad1 and #$f ;lower nibble mask
245f : d00c bne tdad2 ;no decimal adjust needed
2461 : c60f dec adrl ;decimal adjust (?0-6)
2463 : c60f dec adrl
2465 : c60f dec adrl
2467 : c60f dec adrl
2469 : c60f dec adrl
246b : c60f dec adrl
246d : c60f tdad2 dec adrl ;result -1
246f : 08 tdad3 php ;save valid flags
2470 : 68 pla
2471 : 2982 and #$82 ;N-----Z-
2473 : 0510 ora adrh ;N-----ZC
2475 : 8511 sta adrf
2477 : 18 clc ;test with carry clear
2478 : 20f724 jsr chkdad
247b : e60c inc adfc ;same for operand -1 but with carry
247d : a50d lda ad1 ;decimal adjust operand 1
247f : f015 beq tdad5 ;iterate operand 2
2481 : 290f and #$f ;lower nibble mask
2483 : d00c bne tdad4 ;skip decimal adjust
2485 : c60d dec ad1 ;decimal adjust (?0-6)
2487 : c60d dec ad1
2489 : c60d dec ad1
248b : c60d dec ad1
248d : c60d dec ad1
248f : c60d dec ad1
2491 : c60d tdad4 dec ad1 ;operand 1 -1
2493 : 4c4b24 jmp tdad ;iterate op1
2496 : a999 tdad5 lda #$99 ;precharge op1 max
2498 : 850d sta ad1
249a : a50e lda ad2 ;decimal adjust operand 2
249c : f039 beq tdad7 ;end of iteration
249e : 290f and #$f ;lower nibble mask
24a0 : d018 bne tdad6 ;skip decimal adjust
24a2 : c60e dec ad2 ;decimal adjust (?0-6)
24a4 : c60e dec ad2
24a6 : c60e dec ad2
24a8 : c60e dec ad2
24aa : c60e dec ad2
24ac : c60e dec ad2
24ae : e612 inc sb2 ;complemented decimal adjust for subtract (?9+6)
24b0 : e612 inc sb2
24b2 : e612 inc sb2
24b4 : e612 inc sb2
24b6 : e612 inc sb2
24b8 : e612 inc sb2
24ba : c60e tdad6 dec ad2 ;operand 2 -1
24bc : e612 inc sb2 ;complemented operand for subtract
24be : a512 lda sb2
24c0 : 8d0602 sta sba2 ;copy as non zp operand
24c3 : a50e lda ad2
24c5 : 8d0502 sta ada2 ;copy as non zp operand
24c8 : 850f sta adrl ;new result since op1+carry=00+carry +op2=op2
24ca : 08 php ;save flags
24cb : 68 pla
24cc : 2982 and #$82 ;N-----Z-
24ce : 0901 ora #1 ;N-----ZC
24d0 : 8511 sta adrf
24d2 : e610 inc adrh ;result carry
24d4 : 4c4b24 jmp tdad ;iterate op2
24d7 : e00e tdad7 cpx #ad2
trap_ne ;x altered during test
24d9 : d0fe > bne * ;failed not equal (non zero)
24db : c0ff cpy #$ff
trap_ne ;y altered during test
24dd : d0fe > bne * ;failed not equal (non zero)
24df : ba tsx
24e0 : e0ff cpx #$ff
trap_ne ;sp push/pop mismatch
24e2 : d0fe > bne * ;failed not equal (non zero)
24e4 : d8 cld
24e5 : ad0202 lda test_case
24e8 : c915 cmp #test_num
trap_ne ;previous test is out of sequence
24ea : d0fe > bne * ;failed not equal (non zero)
24ec : a9f0 lda #$f0 ;mark opcode testing complete
24ee : 8d0202 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
24f1 : 4cf124 > jmp * ;test passed, no errors
; -------------
; S U C C E S S ************************************************
24f4 : 4c0004 jmp start ;run again
; core subroutine of the decimal add/subtract test
; *** WARNING - tests documented behavior only! ***
; only valid BCD operands are tested, V flag is ignored
; iterates through all valid combinations of operands and carry input
; uses increments/decrements to predict result & carry flag
24f7 : chkdad
; decimal ADC / SBC zp
24f7 : 08 php ;save carry for subtract
24f8 : a50d lda ad1
24fa : 650e adc ad2 ;perform add
24fc : 08 php
24fd : c50f cmp adrl ;check result
trap_ne ;bad result
24ff : d0fe > bne * ;failed not equal (non zero)
2501 : 68 pla ;check flags
2502 : 2983 and #$83 ;mask N-----ZC
2504 : c511 cmp adrf
trap_ne ;bad flags
2506 : d0fe > bne * ;failed not equal (non zero)
2508 : 28 plp
2509 : 08 php ;save carry for next add
250a : a50d lda ad1
250c : e512 sbc sb2 ;perform subtract
250e : 08 php
250f : c50f cmp adrl ;check result
trap_ne ;bad result
2511 : d0fe > bne * ;failed not equal (non zero)
2513 : 68 pla ;check flags
2514 : 2983 and #$83 ;mask N-----ZC
2516 : c511 cmp adrf
trap_ne ;bad flags
2518 : d0fe > bne * ;failed not equal (non zero)
251a : 28 plp
; decimal ADC / SBC abs
251b : 08 php ;save carry for subtract
251c : a50d lda ad1
251e : 6d0502 adc ada2 ;perform add
2521 : 08 php
2522 : c50f cmp adrl ;check result
trap_ne ;bad result
2524 : d0fe > bne * ;failed not equal (non zero)
2526 : 68 pla ;check flags
2527 : 2983 and #$83 ;mask N-----ZC
2529 : c511 cmp adrf
trap_ne ;bad flags
252b : d0fe > bne * ;failed not equal (non zero)
252d : 28 plp
252e : 08 php ;save carry for next add
252f : a50d lda ad1
2531 : ed0602 sbc sba2 ;perform subtract
2534 : 08 php
2535 : c50f cmp adrl ;check result
trap_ne ;bad result
2537 : d0fe > bne * ;failed not equal (non zero)
2539 : 68 pla ;check flags
253a : 2983 and #$83 ;mask N-----ZC
253c : c511 cmp adrf
trap_ne ;bad flags
253e : d0fe > bne * ;failed not equal (non zero)
2540 : 28 plp
; decimal ADC / SBC #
2541 : 08 php ;save carry for subtract
2542 : a50e lda ad2
2544 : 8d0b02 sta ex_adci+1 ;set ADC # operand
2547 : a50d lda ad1
2549 : 200a02 jsr ex_adci ;execute ADC # in RAM
254c : 08 php
254d : c50f cmp adrl ;check result
trap_ne ;bad result
254f : d0fe > bne * ;failed not equal (non zero)
2551 : 68 pla ;check flags
2552 : 2983 and #$83 ;mask N-----ZC
2554 : c511 cmp adrf
trap_ne ;bad flags
2556 : d0fe > bne * ;failed not equal (non zero)
2558 : 28 plp
2559 : 08 php ;save carry for next add
255a : a512 lda sb2
255c : 8d0e02 sta ex_sbci+1 ;set SBC # operand
255f : a50d lda ad1
2561 : 200d02 jsr ex_sbci ;execute SBC # in RAM
2564 : 08 php
2565 : c50f cmp adrl ;check result
trap_ne ;bad result
2567 : d0fe > bne * ;failed not equal (non zero)
2569 : 68 pla ;check flags
256a : 2983 and #$83 ;mask N-----ZC
256c : c511 cmp adrf
trap_ne ;bad flags
256e : d0fe > bne * ;failed not equal (non zero)
2570 : 28 plp
; decimal ADC / SBC zp,x
2571 : 08 php ;save carry for subtract
2572 : a50d lda ad1
2574 : 7500 adc 0,x ;perform add
2576 : 08 php
2577 : c50f cmp adrl ;check result
trap_ne ;bad result
2579 : d0fe > bne * ;failed not equal (non zero)
257b : 68 pla ;check flags
257c : 2983 and #$83 ;mask N-----ZC
257e : c511 cmp adrf
trap_ne ;bad flags
2580 : d0fe > bne * ;failed not equal (non zero)
2582 : 28 plp
2583 : 08 php ;save carry for next add
2584 : a50d lda ad1
2586 : f504 sbc sb2-ad2,x ;perform subtract
2588 : 08 php
2589 : c50f cmp adrl ;check result
trap_ne ;bad result
258b : d0fe > bne * ;failed not equal (non zero)
258d : 68 pla ;check flags
258e : 2983 and #$83 ;mask N-----ZC
2590 : c511 cmp adrf
trap_ne ;bad flags
2592 : d0fe > bne * ;failed not equal (non zero)
2594 : 28 plp
; decimal ADC / SBC abs,x
2595 : 08 php ;save carry for subtract
2596 : a50d lda ad1
2598 : 7df701 adc ada2-ad2,x ;perform add
259b : 08 php
259c : c50f cmp adrl ;check result
trap_ne ;bad result
259e : d0fe > bne * ;failed not equal (non zero)
25a0 : 68 pla ;check flags
25a1 : 2983 and #$83 ;mask N-----ZC
25a3 : c511 cmp adrf
trap_ne ;bad flags
25a5 : d0fe > bne * ;failed not equal (non zero)
25a7 : 28 plp
25a8 : 08 php ;save carry for next add
25a9 : a50d lda ad1
25ab : fdf801 sbc sba2-ad2,x ;perform subtract
25ae : 08 php
25af : c50f cmp adrl ;check result
trap_ne ;bad result
25b1 : d0fe > bne * ;failed not equal (non zero)
25b3 : 68 pla ;check flags
25b4 : 2983 and #$83 ;mask N-----ZC
25b6 : c511 cmp adrf
trap_ne ;bad flags
25b8 : d0fe > bne * ;failed not equal (non zero)
25ba : 28 plp
; decimal ADC / SBC abs,y
25bb : 08 php ;save carry for subtract
25bc : a50d lda ad1
25be : 790601 adc ada2-$ff,y ;perform add
25c1 : 08 php
25c2 : c50f cmp adrl ;check result
trap_ne ;bad result
25c4 : d0fe > bne * ;failed not equal (non zero)
25c6 : 68 pla ;check flags
25c7 : 2983 and #$83 ;mask N-----ZC
25c9 : c511 cmp adrf
trap_ne ;bad flags
25cb : d0fe > bne * ;failed not equal (non zero)
25cd : 28 plp
25ce : 08 php ;save carry for next add
25cf : a50d lda ad1
25d1 : f90701 sbc sba2-$ff,y ;perform subtract
25d4 : 08 php
25d5 : c50f cmp adrl ;check result
trap_ne ;bad result
25d7 : d0fe > bne * ;failed not equal (non zero)
25d9 : 68 pla ;check flags
25da : 2983 and #$83 ;mask N-----ZC
25dc : c511 cmp adrf
trap_ne ;bad flags
25de : d0fe > bne * ;failed not equal (non zero)
25e0 : 28 plp
; decimal ADC / SBC (zp,x)
25e1 : 08 php ;save carry for subtract
25e2 : a50d lda ad1
25e4 : 6144 adc (lo adi2-ad2,x) ;perform add
25e6 : 08 php
25e7 : c50f cmp adrl ;check result
trap_ne ;bad result
25e9 : d0fe > bne * ;failed not equal (non zero)
25eb : 68 pla ;check flags
25ec : 2983 and #$83 ;mask N-----ZC
25ee : c511 cmp adrf
trap_ne ;bad flags
25f0 : d0fe > bne * ;failed not equal (non zero)
25f2 : 28 plp
25f3 : 08 php ;save carry for next add
25f4 : a50d lda ad1
25f6 : e146 sbc (lo sbi2-ad2,x) ;perform subtract
25f8 : 08 php
25f9 : c50f cmp adrl ;check result
trap_ne ;bad result
25fb : d0fe > bne * ;failed not equal (non zero)
25fd : 68 pla ;check flags
25fe : 2983 and #$83 ;mask N-----ZC
2600 : c511 cmp adrf
trap_ne ;bad flags
2602 : d0fe > bne * ;failed not equal (non zero)
2604 : 28 plp
; decimal ADC / SBC (abs),y
2605 : 08 php ;save carry for subtract
2606 : a50d lda ad1
2608 : 7156 adc (adiy2),y ;perform add
260a : 08 php
260b : c50f cmp adrl ;check result
trap_ne ;bad result
260d : d0fe > bne * ;failed not equal (non zero)
260f : 68 pla ;check flags
2610 : 2983 and #$83 ;mask N-----ZC
2612 : c511 cmp adrf
trap_ne ;bad flags
2614 : d0fe > bne * ;failed not equal (non zero)
2616 : 28 plp
2617 : 08 php ;save carry for next add
2618 : a50d lda ad1
261a : f158 sbc (sbiy2),y ;perform subtract
261c : 08 php
261d : c50f cmp adrl ;check result
trap_ne ;bad result
261f : d0fe > bne * ;failed not equal (non zero)
2621 : 68 pla ;check flags
2622 : 2983 and #$83 ;mask N-----ZC
2624 : c511 cmp adrf
trap_ne ;bad flags
2626 : d0fe > bne * ;failed not equal (non zero)
2628 : 28 plp
; decimal ADC / SBC (zp)
2629 : 08 php ;save carry for subtract
262a : a50d lda ad1
262c : 7252 adc (adi2) ;perform add
262e : 08 php
262f : c50f cmp adrl ;check result
trap_ne ;bad result
2631 : d0fe > bne * ;failed not equal (non zero)
2633 : 68 pla ;check flags
2634 : 2983 and #$83 ;mask N-----ZC
2636 : c511 cmp adrf
trap_ne ;bad flags
2638 : d0fe > bne * ;failed not equal (non zero)
263a : 28 plp
263b : 08 php ;save carry for next add
263c : a50d lda ad1
263e : f254 sbc (sbi2) ;perform subtract
2640 : 08 php
2641 : c50f cmp adrl ;check result
trap_ne ;bad result
2643 : d0fe > bne * ;failed not equal (non zero)
2645 : 68 pla ;check flags
2646 : 2983 and #$83 ;mask N-----ZC
2648 : c511 cmp adrf
trap_ne ;bad flags
264a : d0fe > bne * ;failed not equal (non zero)
264c : 28 plp
264d : 60 rts
; 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
264e : a511 chkadd lda adrf ;add V-flag if overflow
2650 : 2983 and #$83 ;keep N-----ZC / clear V
2652 : 48 pha
2653 : a50d lda ad1 ;test sign unequal between operands
2655 : 450e eor ad2
2657 : 300a bmi ckad1 ;no overflow possible - operands have different sign
2659 : a50d lda ad1 ;test sign equal between operands and result
265b : 450f eor adrl
265d : 1004 bpl ckad1 ;no overflow occured - operand and result have same sign
265f : 68 pla
2660 : 0940 ora #$40 ;set V
2662 : 48 pha
2663 : 68 ckad1 pla
2664 : 8511 sta adrf ;save expected flags
; binary ADC / SBC (zp)
2666 : 08 php ;save carry for subtract
2667 : a50d lda ad1
2669 : 7252 adc (adi2) ;perform add
266b : 08 php
266c : c50f cmp adrl ;check result
trap_ne ;bad result
266e : d0fe > bne * ;failed not equal (non zero)
2670 : 68 pla ;check flags
2671 : 29c3 and #$c3 ;mask NV----ZC
2673 : c511 cmp adrf
trap_ne ;bad flags
2675 : d0fe > bne * ;failed not equal (non zero)
2677 : 28 plp
2678 : 08 php ;save carry for next add
2679 : a50d lda ad1
267b : f254 sbc (sbi2) ;perform subtract
267d : 08 php
267e : c50f cmp adrl ;check result
trap_ne ;bad result
2680 : d0fe > bne * ;failed not equal (non zero)
2682 : 68 pla ;check flags
2683 : 29c3 and #$c3 ;mask NV----ZC
2685 : c511 cmp adrf
trap_ne ;bad flags
2687 : d0fe > bne * ;failed not equal (non zero)
2689 : 28 plp
268a : 60 rts
; target for the jump indirect test
268b : 9126 ji_adr dw test_ji
268d : 8216 dw ji_ret
268f : 88 dey
2690 : 88 dey
2691 : test_ji
2691 : 08 php ;either SP or Y count will fail, if we do not hit
2692 : 88 dey
2693 : 88 dey
2694 : 88 dey
2695 : 28 plp
trap_cs ;flags loaded?
2696 : b0fe > bcs * ;failed carry set
trap_vs
2698 : 70fe > bvs * ;failed overflow set
trap_mi
269a : 30fe > bmi * ;failed minus (bit 7 set)
trap_eq
269c : f0fe > beq * ;failed equal (zero)
269e : c949 cmp #'I' ;registers loaded?
trap_ne
26a0 : d0fe > bne * ;failed not equal (non zero)
26a2 : e04e cpx #'N'
trap_ne
26a4 : d0fe > bne * ;failed not equal (non zero)
26a6 : c041 cpy #('D'-3)
trap_ne
26a8 : d0fe > bne * ;failed not equal (non zero)
26aa : 48 pha ;save a,x
26ab : 8a txa
26ac : 48 pha
26ad : ba tsx
26ae : e0fd cpx #$fd ;check SP
trap_ne
26b0 : d0fe > bne * ;failed not equal (non zero)
26b2 : 68 pla ;restore x
26b3 : aa tax
set_stat $ff
> load_flag $ff
26b4 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
26b6 : 48 > pha ;use stack to load status
26b7 : 28 > plp
26b8 : 68 pla ;restore a
26b9 : e8 inx ;return registers with modifications
26ba : 49aa eor #$aa ;N=1, V=1, Z=0, C=1
26bc : 6cff02 jmp (ji_tab+2)
26bf : ea nop
26c0 : ea nop
trap ;runover protection
26c1 : 4cc126 > jmp * ;failed anyway
26c4 : 4c0004 jmp start ;catastrophic error - cannot continue
; target for the jump indirect test
26c7 : 0e27 jxi_adr dw trap_ind
26c9 : 0e27 dw trap_ind
26cb : d526 dw test_jxi ;+4
26cd : ce16 dw jxi_ret ;+6
26cf : 0e27 dw trap_ind
26d1 : 0e27 dw trap_ind
26d3 : 88 dey
26d4 : 88 dey
26d5 : test_jxi
26d5 : 08 php ;either SP or Y count will fail, if we do not hit
26d6 : 88 dey
26d7 : 88 dey
26d8 : 88 dey
26d9 : 28 plp
trap_cs ;flags loaded?
26da : b0fe > bcs * ;failed carry set
trap_vs
26dc : 70fe > bvs * ;failed overflow set
trap_mi
26de : 30fe > bmi * ;failed minus (bit 7 set)
trap_eq
26e0 : f0fe > beq * ;failed equal (zero)
26e2 : c958 cmp #'X' ;registers loaded?
trap_ne
26e4 : d0fe > bne * ;failed not equal (non zero)
26e6 : e004 cpx #4
trap_ne
26e8 : d0fe > bne * ;failed not equal (non zero)
26ea : c046 cpy #('I'-3)
trap_ne
26ec : d0fe > bne * ;failed not equal (non zero)
26ee : 48 pha ;save a,x
26ef : 8a txa
26f0 : 48 pha
26f1 : ba tsx
26f2 : e0fd cpx #$fd ;check SP
trap_ne
26f4 : d0fe > bne * ;failed not equal (non zero)
26f6 : 68 pla ;restore x
26f7 : aa tax
set_stat $ff
> load_flag $ff
26f8 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
26fa : 48 > pha ;use stack to load status
26fb : 28 > plp
26fc : 68 pla ;restore a
26fd : e8 inx ;return registers with modifications
26fe : e8 inx
26ff : 49aa eor #$aa ;N=1, V=1, Z=0, C=1
2701 : 7cf902 jmp (jxi_tab,x)
2704 : ea nop
2705 : ea nop
trap ;runover protection
2706 : 4c0627 > jmp * ;failed anyway
2709 : 4c0004 jmp start ;catastrophic error - cannot continue
; JMP (abs,x) with bad x
270c : ea nop
270d : ea nop
270e : trap_ind
270e : ea nop
270f : ea nop
trap ;near miss indexed indirect jump
2710 : 4c1027 > jmp * ;failed anyway
2713 : 4c0004 jmp start ;catastrophic error - cannot continue
;trap in case of unexpected IRQ, NMI, BRK, RESET
2716 : nmi_trap
trap ;check stack for conditions at NMI
2716 : 4c1627 > jmp * ;failed anyway
2719 : 4c0004 jmp start ;catastrophic error - cannot continue
271c : res_trap
trap ;unexpected RESET
271c : 4c1c27 > jmp * ;failed anyway
271f : 4c0004 jmp start ;catastrophic error - cannot continue
2722 : 88 dey
2723 : 88 dey
2724 : irq_trap ;BRK test or unextpected BRK or IRQ
2724 : 08 php ;either SP or Y count will fail, if we do not hit
2725 : 88 dey
2726 : 88 dey
2727 : 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)
2728 : c9bd cmp #$ff-'B' ;BRK pass 2 registers loaded?
272a : f042 beq break2
272c : c942 cmp #'B' ;BRK pass 1 registers loaded?
trap_ne
272e : d0fe > bne * ;failed not equal (non zero)
2730 : e052 cpx #'R'
trap_ne
2732 : d0fe > bne * ;failed not equal (non zero)
2734 : c048 cpy #'K'-3
trap_ne
2736 : d0fe > bne * ;failed not equal (non zero)
2738 : 850a sta irq_a ;save registers during break test
273a : 860b stx irq_x
273c : ba tsx ;test break on stack
273d : bd0201 lda $102,x
cmp_flag 0 ;break test should have B=1 & unused=1 on stack
2740 : c930 > cmp #(0 |fao)&m8 ;expected flags + always on bits
trap_ne ;possible no break flag on stack
2742 : d0fe > bne * ;failed not equal (non zero)
2744 : 68 pla
cmp_flag intdis ;should have added interrupt disable
2745 : c934 > cmp #(intdis |fao)&m8 ;expected flags + always on bits
trap_ne
2747 : d0fe > bne * ;failed not equal (non zero)
2749 : ba tsx
274a : e0fc cpx #$fc ;sp -3? (return addr, flags)
trap_ne
274c : d0fe > bne * ;failed not equal (non zero)
274e : adff01 lda $1ff ;propper return on stack
2751 : c917 cmp #hi(brk_ret0)
trap_ne
2753 : d0fe > bne * ;failed not equal (non zero)
2755 : adfe01 lda $1fe
2758 : c920 cmp #lo(brk_ret0)
trap_ne
275a : d0fe > bne * ;failed not equal (non zero)
load_flag $ff
275c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
275e : 48 pha
275f : a60b ldx irq_x
2761 : e8 inx ;return registers with modifications
2762 : a50a lda irq_a
2764 : 49aa eor #$aa
2766 : 28 plp ;N=1, V=1, Z=1, C=1 but original flags should be restored
2767 : 40 rti
trap ;runover protection
2768 : 4c6827 > jmp * ;failed anyway
276b : 4c0004 jmp start ;catastrophic error - cannot continue
276e : break2 ;BRK pass 2
276e : e0ad cpx #$ff-'R'
trap_ne
2770 : d0fe > bne * ;failed not equal (non zero)
2772 : c0b1 cpy #$ff-'K'-3
trap_ne
2774 : d0fe > bne * ;failed not equal (non zero)
2776 : 850a sta irq_a ;save registers during break test
2778 : 860b stx irq_x
277a : ba tsx ;test break on stack
277b : bd0201 lda $102,x
cmp_flag $ff ;break test should have B=1
277e : c9ff > cmp #($ff |fao)&m8 ;expected flags + always on bits
trap_ne ;possibly no break flag on stack
2780 : d0fe > bne * ;failed not equal (non zero)
2782 : 68 pla
cmp_flag $ff-decmode ;actual passed flags should have decmode cleared
2783 : c9f7 > cmp #($ff-decmode |fao)&m8 ;expected flags + always on bits
trap_ne
2785 : d0fe > bne * ;failed not equal (non zero)
2787 : ba tsx
2788 : e0fc cpx #$fc ;sp -3? (return addr, flags)
trap_ne
278a : d0fe > bne * ;failed not equal (non zero)
278c : adff01 lda $1ff ;propper return on stack
278f : c917 cmp #hi(brk_ret1)
trap_ne
2791 : d0fe > bne * ;failed not equal (non zero)
2793 : adfe01 lda $1fe
2796 : c946 cmp #lo(brk_ret1)
trap_ne
2798 : d0fe > bne * ;failed not equal (non zero)
load_flag intdis
279a : a904 > lda #intdis ;allow test to change I-flag (no mask)
279c : 48 pha
279d : a60b ldx irq_x
279f : e8 inx ;return registers with modifications
27a0 : a50a lda irq_a
27a2 : 49aa eor #$aa
27a4 : 28 plp ;N=0, V=0, Z=0, C=0 but original flags should be restored
27a5 : 40 rti
trap ;runover protection
27a6 : 4ca627 > jmp * ;failed anyway
27a9 : 4c0004 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_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
; code at end of image due to the need to add blank space as required
if ($ff & (ji_ret - * - 2)) < ($ff & (jxi_ret - * - 2))
; JMP (abs) when $xxff and $xx00 are from same page
ds lo(ji_ret - * - 2)
nop
nop
ji_px nop ;low address byte matched with ji_ret
nop
trap ;jmp indirect page cross bug
; JMP (abs,x) when $xxff and $xx00 are from same page
ds lo(jxi_ret - * - 2)
nop
nop
jxi_px nop ;low address byte matched with jxi_ret
nop
trap ;jmp indexed indirect page cross bug
else
; JMP (abs,x) when $xxff and $xx00 are from same page
27ac : 00000000000000.. ds lo(jxi_ret - * - 2)
27cc : ea nop
27cd : ea nop
27ce : ea jxi_px nop ;low address byte matched with jxi_ret
27cf : ea nop
trap ;jmp indexed indirect page cross bug
27d0 : 4cd027 > jmp * ;failed anyway
; JMP (abs) when $xxff and $xx00 are from same page
27d3 : 00000000000000.. ds lo(ji_ret - * - 2)
2880 : ea nop
2881 : ea nop
2882 : ea ji_px nop ;low address byte matched with ji_ret
2883 : ea nop
trap ;jmp indirect page cross bug
2884 : 4c8428 > jmp * ;failed anyway
endif
if (load_data_direct = 1) & (ROM_vectors = 1)
fffa = org $fffa ;vectors
fffa : 1627 dw nmi_trap
fffc : 1c27 dw res_trap
fffe : 2427 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 $0400 (1024).