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 . ; 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).