AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 1 ---------------------------------------------------- 6502_functional_test.a65 ---------------------------------------------------- 6102 lines read, no errors in pass 1. ; ; 6 5 0 2 F U N C T I O N A L T E S T ; ; Copyright (C) 2012-2015 Klaus Dormann ; ; This program is free software: you can redistribute it and/or modify ; it under the terms of the GNU General Public License as published by ; the Free Software Foundation, either version 3 of the License, or ; (at your option) any later version. ; ; This program is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ; GNU General Public License for more details. ; ; You should have received a copy of the GNU General Public License ; along with this program. If not, see . ; This program is designed to test all opcodes of a 6502 emulator using all ; addressing modes with focus on propper setting of the processor status ; register bits. ; ; version 04-dec-2017 ; contact info at http://2m5.de or email K@2m5.de ; ; assembled with AS65 from http://www.kingswood-consulting.co.uk/assemblers/ ; command line switches: -l -m -s2 -w -h0 ; | | | | no page headers in listing ; | | | wide listing (133 char/col) ; | | write intel hex file instead of binary ; | expand macros in listing ; generate pass2 listing ; ; No IO - should be run from a monitor with access to registers. ; To run load intel hex image with a load command, than alter PC to 400 hex ; (code_segment) and enter a go command. ; Loop on program counter determines error or successful completion of test. ; Check listing for relevant traps (jump/branch *). ; Please note that in early tests some instructions will have to be used before ; they are actually tested! ; ; RESET, NMI or IRQ should not occur and will be trapped if vectors are enabled. ; Tests documented behavior of the original NMOS 6502 only! No unofficial ; opcodes. Additional opcodes of newer versions of the CPU (65C02, 65816) will ; not be tested. Decimal ops will only be tested with valid BCD operands and ; N V Z flags will be ignored. ; ; Debugging hints: ; Most of the code is written sequentially. if you hit a trap, check the ; immediately preceeding code for the instruction to be tested. Results are ; tested first, flags are checked second by pushing them onto the stack and ; pulling them to the accumulator after the result was checked. The "real" ; flags are no longer valid for the tested instruction at this time! ; If the tested instruction was indexed, the relevant index (X or Y) must ; also be checked. Opposed to the flags, X and Y registers are still valid. ; ; versions: ; 28-jul-2012 1st version distributed for testing ; 29-jul-2012 fixed references to location 0, now #0 ; added license - GPLv3 ; 30-jul-2012 added configuration options ; 01-aug-2012 added trap macro to allow user to change error handling ; 01-dec-2012 fixed trap in branch field must be a branch ; 02-mar-2013 fixed PLA flags not tested ; 19-jul-2013 allowed ROM vectors to be loaded when load_data_direct = 0 ; added test sequence check to detect if tests jump their fence ; 23-jul-2013 added RAM integrity check option ; 16-aug-2013 added error report to standard output option ; 13-dec-2014 added binary/decimal opcode table switch test ; 14-dec-2014 improved relative address test ; 23-aug-2015 added option to disable self modifying tests ; 24-aug-2015 all self modifying immediate opcodes now execute in data RAM ; added small branch offset pretest ; 21-oct-2015 added option to disable decimal mode ADC & SBC tests ; 04-dec-2017 fixed BRK only tested with interrupts enabled ; added option to skip the remainder of a failing test ; in report.i65 ; C O N F I G U R A T I O N ;ROM_vectors writable (0=no, 1=yes) ;if ROM vectors can not be used interrupts will not be trapped ;as a consequence BRK can not be tested but will be emulated to test RTI 0001 = ROM_vectors = 1 ;load_data_direct (0=move from code segment, 1=load directly) ;loading directly is preferred but may not be supported by your platform ;0 produces only consecutive object code, 1 is not suitable for a binary image 0001 = load_data_direct = 1 ;I_flag behavior (0=force enabled, 1=force disabled, 2=prohibit change, 3=allow ;change) 2 requires extra code and is not recommended. SEI & CLI can only be ;tested if you allow changing the interrupt status (I_flag = 3) 0003 = I_flag = 3 ;configure memory - try to stay away from memory used by the system ;zero_page memory start address, $50 (80) consecutive Bytes required ; add 2 if I_flag = 2 0000 = zero_page = $0 ;data_segment memory start address, $6A (106) consecutive Bytes required 0200 = data_segment = $200 if (data_segment & $ff) != 0 ERROR ERROR ERROR low byte of data_segment MUST be $00 !! endif ;code_segment memory start address, 13kB of consecutive space required ; add 2.5 kB if I_flag = 2 0800 = code_segment = $800 ;self modifying code may be disabled to allow running in ROM ;0=part of the code is self modifying and must reside in RAM ;1=tests disabled: branch range 0000 = disable_selfmod = 0 ;report errors through I/O channel (0=use standard self trap loops, 1=include ;report.i65 as I/O channel, add 3.5 kB) 0000 = report = 0 ;RAM integrity test option. Checks for undesired RAM writes. ;set lowest non RAM or RAM mirror address page (-1=disable, 0=64k, $40=16k) ;leave disabled if a monitor, OS or background interrupt is allowed to alter RAM ffff = ram_top = -1 ;disable test decimal mode ADC & SBC, 0=enable, 1=disable, ;2=disable including decimal flag in processor status 0000 = disable_decimal = 0 noopt ;do not take shortcuts ;macros for error & success traps to allow user modification ;example: ;trap macro ; jsr my_error_handler ; endm ;trap_eq macro ; bne skip\? ; trap ;failed equal (zero) ;skip\? ; endm ; ; my_error_handler should pop the calling address from the stack and report it. ; putting larger portions of code (more than 3 bytes) inside the trap macro ; may lead to branch range problems for some tests. if report = 0 trap macro jmp * ;failed anyway endm trap_eq macro beq * ;failed equal (zero) endm trap_ne macro bne * ;failed not equal (non zero) endm trap_cs macro bcs * ;failed carry set endm trap_cc macro bcc * ;failed carry clear endm trap_mi macro bmi * ;failed minus (bit 7 set) endm trap_pl macro bpl * ;failed plus (bit 7 clear) endm trap_vs macro bvs * ;failed overflow set endm trap_vc macro bvc * ;failed overflow clear endm ; please observe that during the test the stack gets invalidated ; therefore a RTS inside the success macro is not possible success macro jmp * ;test passed, no errors endm endif if report = 1 trap macro jsr report_error endm trap_eq macro bne skip\? trap ;failed equal (zero) skip\? endm trap_ne macro beq skip\? trap ;failed not equal (non zero) skip\? endm trap_cs macro bcc skip\? trap ;failed carry set skip\? endm trap_cc macro bcs skip\? trap ;failed carry clear skip\? endm trap_mi macro bpl skip\? trap ;failed minus (bit 7 set) skip\? endm trap_pl macro bmi skip\? trap ;failed plus (bit 7 clear) skip\? endm trap_vs macro bvc skip\? trap ;failed overflow set skip\? endm trap_vc macro bvs skip\? trap ;failed overflow clear skip\? endm ; please observe that during the test the stack gets invalidated ; therefore a RTS inside the success macro is not possible success macro jsr report_success endm endif 0001 = carry equ %00000001 ;flag bits in status 0002 = zero equ %00000010 0004 = intdis equ %00000100 0008 = decmode equ %00001000 0010 = break equ %00010000 0020 = reserv equ %00100000 0040 = overfl equ %01000000 0080 = minus equ %10000000 0001 = fc equ carry 0002 = fz equ zero 0003 = fzc equ carry+zero 0040 = fv equ overfl 0042 = fvz equ overfl+zero 0080 = fn equ minus 0081 = fnc equ minus+carry 0082 = fnz equ minus+zero 0083 = fnzc equ minus+zero+carry 00c0 = fnv equ minus+overfl 0030 = fao equ break+reserv ;bits always on after PHP, BRK 0034 = fai equ fao+intdis ;+ forced interrupt disable 0038 = faod equ fao+decmode ;+ ignore decimal 003c = faid equ fai+decmode ;+ ignore decimal 00ff = m8 equ $ff ;8 bit mask 00fb = m8i equ $ff&~intdis ;8 bit mask - interrupt disable ;macros to allow masking of status bits. ;masking test of decimal bit ;masking of interrupt enable/disable on load and compare ;masking of always on bits after PHP or BRK (unused & break) on compare if disable_decimal < 2 if I_flag = 0 load_flag macro lda #\1&m8i ;force enable interrupts (mask I) endm cmp_flag macro cmp #(\1|fao)&m8i ;I_flag is always enabled + always on bits endm eor_flag macro eor #(\1&m8i|fao) ;mask I, invert expected flags + always on bits endm endif if I_flag = 1 load_flag macro lda #\1|intdis ;force disable interrupts endm cmp_flag macro cmp #(\1|fai)&m8 ;I_flag is always disabled + always on bits endm eor_flag macro eor #(\1|fai) ;invert expected flags + always on bits + I endm endif if I_flag = 2 load_flag macro lda #\1 ora flag_I_on ;restore I-flag and flag_I_off endm cmp_flag macro eor flag_I_on ;I_flag is never changed cmp #(\1|fao)&m8i ;expected flags + always on bits, mask I endm eor_flag macro eor flag_I_on ;I_flag is never changed eor #(\1&m8i|fao) ;mask I, invert expected flags + always on bits endm endif if I_flag = 3 load_flag macro lda #\1 ;allow test to change I-flag (no mask) endm cmp_flag macro cmp #(\1|fao)&m8 ;expected flags + always on bits endm eor_flag macro eor #\1|fao ;invert expected flags + always on bits endm endif else if I_flag = 0 load_flag macro lda #\1&m8i ;force enable interrupts (mask I) endm cmp_flag macro ora #decmode ;ignore decimal mode bit cmp #(\1|faod)&m8i ;I_flag is always enabled + always on bits endm eor_flag macro ora #decmode ;ignore decimal mode bit eor #(\1&m8i|faod) ;mask I, invert expected flags + always on bits endm endif if I_flag = 1 load_flag macro lda #\1|intdis ;force disable interrupts endm cmp_flag macro ora #decmode ;ignore decimal mode bit cmp #(\1|faid)&m8 ;I_flag is always disabled + always on bits endm eor_flag macro ora #decmode ;ignore decimal mode bit eor #(\1|faid) ;invert expected flags + always on bits + I endm endif if I_flag = 2 load_flag macro lda #\1 ora flag_I_on ;restore I-flag and flag_I_off endm cmp_flag macro eor flag_I_on ;I_flag is never changed ora #decmode ;ignore decimal mode bit cmp #(\1|faod)&m8i ;expected flags + always on bits, mask I endm eor_flag macro eor flag_I_on ;I_flag is never changed ora #decmode ;ignore decimal mode bit eor #(\1&m8i|faod) ;mask I, invert expected flags + always on bits endm endif if I_flag = 3 load_flag macro lda #\1 ;allow test to change I-flag (no mask) endm cmp_flag macro ora #decmode ;ignore decimal mode bit cmp #(\1|faod)&m8 ;expected flags + always on bits endm eor_flag macro ora #decmode ;ignore decimal mode bit eor #\1|faod ;invert expected flags + always on bits endm endif endif ;macros to set (register|memory|zeropage) & status set_stat macro ;setting flags in the processor status register load_flag \1 pha ;use stack to load status plp endm set_a macro ;precharging accu & status load_flag \2 pha ;use stack to load status lda #\1 ;precharge accu plp endm set_x macro ;precharging index & status load_flag \2 pha ;use stack to load status ldx #\1 ;precharge index x plp endm set_y macro ;precharging index & status load_flag \2 pha ;use stack to load status ldy #\1 ;precharge index y plp endm set_ax macro ;precharging indexed accu & immediate status load_flag \2 pha ;use stack to load status lda \1,x ;precharge accu plp endm set_ay macro ;precharging indexed accu & immediate status load_flag \2 pha ;use stack to load status lda \1,y ;precharge accu plp endm set_z macro ;precharging indexed zp & immediate status load_flag \2 pha ;use stack to load status lda \1,x ;load to zeropage sta zpt plp endm set_zx macro ;precharging zp,x & immediate status load_flag \2 pha ;use stack to load status lda \1,x ;load to indexed zeropage sta zpt,x plp endm set_abs macro ;precharging indexed memory & immediate status load_flag \2 pha ;use stack to load status lda \1,x ;load to memory sta abst plp endm set_absx macro ;precharging abs,x & immediate status load_flag \2 pha ;use stack to load status lda \1,x ;load to indexed memory sta abst,x plp endm ;macros to test (register|memory|zeropage) & status & (mask) tst_stat macro ;testing flags in the processor status register php ;save status pla ;use stack to retrieve status pha cmp_flag \1 trap_ne plp ;restore status endm tst_a macro ;testing result in accu & flags php ;save flags cmp #\1 ;test result trap_ne pla ;load status pha cmp_flag \2 trap_ne plp ;restore status endm tst_x macro ;testing result in x index & flags php ;save flags cpx #\1 ;test result trap_ne pla ;load status pha cmp_flag \2 trap_ne plp ;restore status endm tst_y macro ;testing result in y index & flags php ;save flags cpy #\1 ;test result trap_ne pla ;load status pha cmp_flag \2 trap_ne plp ;restore status endm tst_ax macro ;indexed testing result in accu & flags php ;save flags cmp \1,x ;test result trap_ne pla ;load status eor_flag \3 cmp \2,x ;test flags trap_ne ; endm tst_ay macro ;indexed testing result in accu & flags php ;save flags cmp \1,y ;test result trap_ne ; pla ;load status eor_flag \3 cmp \2,y ;test flags trap_ne endm tst_z macro ;indexed testing result in zp & flags php ;save flags lda zpt cmp \1,x ;test result trap_ne pla ;load status eor_flag \3 cmp \2,x ;test flags trap_ne endm tst_zx macro ;testing result in zp,x & flags php ;save flags lda zpt,x cmp \1,x ;test result trap_ne pla ;load status eor_flag \3 cmp \2,x ;test flags trap_ne endm tst_abs macro ;indexed testing result in memory & flags php ;save flags lda abst cmp \1,x ;test result trap_ne pla ;load status eor_flag \3 cmp \2,x ;test flags trap_ne endm tst_absx macro ;testing result in abs,x & flags php ;save flags lda abst,x cmp \1,x ;test result trap_ne pla ;load status eor_flag \3 cmp \2,x ;test flags trap_ne endm ; RAM integrity test ; verifies that none of the previous tests has altered RAM outside of the ; designated write areas. ; uses zpt word as indirect pointer, zpt+2 word as checksum if ram_top > -1 check_ram macro cld lda #0 sta zpt ;set low byte of indirect pointer sta zpt+3 ;checksum high byte if disable_selfmod = 0 sta range_adr ;reset self modifying code endif clc ldx #zp_bss-zero_page ;zeropage - write test area ccs3\? adc zero_page,x bcc ccs2\? inc zpt+3 ;carry to high byte clc ccs2\? inx bne ccs3\? ldx #hi(abs1) ;set high byte of indirect pointer stx zpt+1 ldy #lo(abs1) ;data after write & execute test area ccs5\? adc (zpt),y bcc ccs4\? inc zpt+3 ;carry to high byte clc ccs4\? iny bne ccs5\? inx ;advance RAM high address stx zpt+1 cpx #ram_top bne ccs5\? sta zpt+2 ;checksum low is cmp ram_chksm ;checksum low expected trap_ne ;checksum mismatch lda zpt+3 ;checksum high is cmp ram_chksm+1 ;checksum high expected trap_ne ;checksum mismatch endm else check_ram macro ;RAM check disabled - RAM size not set endm endif next_test macro ;make sure, tests don't jump the fence lda test_case ;previous test cmp #test_num trap_ne ;test is out of sequence test_num = test_num + 1 lda #test_num ;*** next tests' number sta test_case ;check_ram ;uncomment to find altered RAM after each test endm if load_data_direct = 1 data else bss ;uninitialized segment, copy of data at end of code! endif 0000 = org zero_page ;break test interrupt save 0000 : 00 irq_a ds 1 ;a register 0001 : 00 irq_x ds 1 ;x register if I_flag = 2 ;masking for I bit in status flag_I_on ds 1 ;or mask to load flags flag_I_off ds 1 ;and mask to load flags endif 0002 : zpt ;5 bytes store/modify test area ;add/subtract operand generation and result/flag prediction 0002 : 00 adfc ds 1 ;carry flag before op 0003 : 00 ad1 ds 1 ;operand 1 - accumulator 0004 : 00 ad2 ds 1 ;operand 2 - memory / immediate 0005 : 00 adrl ds 1 ;expected result bits 0-7 0006 : 00 adrh ds 1 ;expected result bit 8 (carry) 0007 : 00 adrf ds 1 ;expected flags NV0000ZC (only binary mode) 0008 : 00 sb2 ds 1 ;operand 2 complemented for subtract 0009 : zp_bss 0009 : c3824100 zp1 db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR 000d : 7f zp7f db $7f ;test pattern for compare ;logical zeropage operands 000e : 001f7180 zpOR db 0,$1f,$71,$80 ;test pattern for OR 0012 : 0fff7f80 zpAN db $0f,$ff,$7f,$80 ;test pattern for AND 0016 : ff0f8f8f zpEO db $ff,$0f,$8f,$8f ;test pattern for EOR ;indirect addressing pointers 001a : 1702 ind1 dw abs1 ;indirect pointer to pattern in absolute memory 001c : 1802 dw abs1+1 001e : 1902 dw abs1+2 0020 : 1a02 dw abs1+3 0022 : 1b02 dw abs7f 0024 : 1f01 inw1 dw abs1-$f8 ;indirect pointer for wrap-test pattern 0026 : 0302 indt dw abst ;indirect pointer to store area in absolute memory 0028 : 0402 dw abst+1 002a : 0502 dw abst+2 002c : 0602 dw abst+3 002e : 0b01 inwt dw abst-$f8 ;indirect pointer for wrap-test store 0030 : 4e02 indAN dw absAN ;indirect pointer to AND pattern in absolute memory 0032 : 4f02 dw absAN+1 0034 : 5002 dw absAN+2 0036 : 5102 dw absAN+3 0038 : 5202 indEO dw absEO ;indirect pointer to EOR pattern in absolute memory 003a : 5302 dw absEO+1 003c : 5402 dw absEO+2 003e : 5502 dw absEO+3 0040 : 4a02 indOR dw absOR ;indirect pointer to OR pattern in absolute memory 0042 : 4b02 dw absOR+1 0044 : 4c02 dw absOR+2 0046 : 4d02 dw absOR+3 ;add/subtract indirect pointers 0048 : 0302 adi2 dw ada2 ;indirect pointer to operand 2 in absolute memory 004a : 0402 sbi2 dw sba2 ;indirect pointer to complemented operand 2 (SBC) 004c : 0401 adiy2 dw ada2-$ff ;with offset for indirect indexed 004e : 0501 sbiy2 dw sba2-$ff 0050 : zp_bss_end 0200 = org data_segment 0200 : 00 test_case ds 1 ;current test number 0201 : 0000 ram_chksm ds 2 ;checksum for RAM integrity test ;add/subtract operand copy - abs tests write area 0203 : abst ;5 bytes store/modify test area 0203 : 00 ada2 ds 1 ;operand 2 0204 : 00 sba2 ds 1 ;operand 2 complemented for subtract 0205 : 000000 ds 3 ;fill remaining bytes 0208 : data_bss if load_data_direct = 1 0208 : 2900 ex_andi and #0 ;execute immediate opcodes 020a : 60 rts 020b : 4900 ex_eori eor #0 ;execute immediate opcodes 020d : 60 rts 020e : 0900 ex_orai ora #0 ;execute immediate opcodes 0210 : 60 rts 0211 : 6900 ex_adci adc #0 ;execute immediate opcodes 0213 : 60 rts 0214 : e900 ex_sbci sbc #0 ;execute immediate opcodes 0216 : 60 rts else ex_andi ds 3 ex_eori ds 3 ex_orai ds 3 ex_adci ds 3 ex_sbci ds 3 endif 0217 : c3824100 abs1 db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR 021b : 7f abs7f db $7f ;test pattern for compare ;loads 021c : 80800002 fLDx db fn,fn,0,fz ;expected flags for load ;shifts 0220 : rASL ;expected result ASL & ROL -carry 0220 : 86048200 rROL db $86,$04,$82,0 ; " 0224 : 87058301 rROLc db $87,$05,$83,1 ;expected result ROL +carry 0228 : rLSR ;expected result LSR & ROR -carry 0228 : 61412000 rROR db $61,$41,$20,0 ; " 022c : e1c1a080 rRORc db $e1,$c1,$a0,$80 ;expected result ROR +carry 0230 : fASL ;expected flags for shifts 0230 : 81018002 fROL db fnc,fc,fn,fz ;no carry in 0234 : 81018000 fROLc db fnc,fc,fn,0 ;carry in 0238 : fLSR 0238 : 01000102 fROR db fc,0,fc,fz ;no carry in 023c : 81808180 fRORc db fnc,fn,fnc,fn ;carry in ;increments (decrements) 0240 : 7f80ff0001 rINC db $7f,$80,$ff,0,1 ;expected result for INC/DEC 0245 : 0080800200 fINC db 0,fn,fn,fz,0 ;expected flags for INC/DEC ;logical memory operand 024a : 001f7180 absOR db 0,$1f,$71,$80 ;test pattern for OR 024e : 0fff7f80 absAN db $0f,$ff,$7f,$80 ;test pattern for AND 0252 : ff0f8f8f absEO db $ff,$0f,$8f,$8f ;test pattern for EOR ;logical accu operand 0256 : 00f11f00 absORa db 0,$f1,$1f,0 ;test pattern for OR 025a : f0ffffff absANa db $f0,$ff,$ff,$ff ;test pattern for AND 025e : fff0f00f absEOa db $ff,$f0,$f0,$0f ;test pattern for EOR ;logical results 0262 : 00ff7f80 absrlo db 0,$ff,$7f,$80 0266 : 02800080 absflo db fz,fn,0,fn 026a : data_bss_end code 0800 = org code_segment 0800 : d8 start cld 0801 : a2ff ldx #$ff 0803 : 9a txs 0804 : a900 lda #0 ;*** test 0 = initialize 0806 : 8d0002 sta test_case 0000 = test_num = 0 ;stop interrupts before initializing BSS if I_flag = 1 sei endif ;initialize I/O for report channel if report = 1 jsr report_init endif ;pretest small branch offset 0809 : a205 ldx #5 080b : 4c3308 jmp psb_test 080e : psb_bwok 080e : a005 ldy #5 0810 : d008 bne psb_forw trap ;branch should be taken 0812 : 4c1208 > jmp * ;failed anyway 0815 : 88 dey ;forward landing zone 0816 : 88 dey 0817 : 88 dey 0818 : 88 dey 0819 : 88 dey 081a : psb_forw 081a : 88 dey 081b : 88 dey 081c : 88 dey 081d : 88 dey 081e : 88 dey 081f : f017 beq psb_fwok trap ;forward offset 0821 : 4c2108 > jmp * ;failed anyway 0824 : ca dex ;backward landing zone 0825 : ca dex 0826 : ca dex 0827 : ca dex 0828 : ca dex 0829 : psb_back 0829 : ca dex 082a : ca dex 082b : ca dex 082c : ca dex 082d : ca dex 082e : f0de beq psb_bwok trap ;backward offset 0830 : 4c3008 > jmp * ;failed anyway 0833 : psb_test 0833 : d0f4 bne psb_back trap ;branch should be taken 0835 : 4c3508 > jmp * ;failed anyway 0838 : psb_fwok ;initialize BSS segment if load_data_direct != 1 ldx #zp_end-zp_init-1 ld_zp lda zp_init,x sta zp_bss,x dex bpl ld_zp ldx #data_end-data_init-1 ld_data lda data_init,x sta data_bss,x dex bpl ld_data if ROM_vectors = 1 ldx #5 ld_vect lda vec_init,x sta vec_bss,x dex bpl ld_vect endif endif ;retain status of interrupt flag if I_flag = 2 php pla and #4 ;isolate flag sta flag_I_on ;or mask eor #lo(~4) ;reverse sta flag_I_off ;and mask endif ;generate checksum for RAM integrity test if ram_top > -1 lda #0 sta zpt ;set low byte of indirect pointer sta ram_chksm+1 ;checksum high byte if disable_selfmod = 0 sta range_adr ;reset self modifying code endif clc ldx #zp_bss-zero_page ;zeropage - write test area gcs3 adc zero_page,x bcc gcs2 inc ram_chksm+1 ;carry to high byte clc gcs2 inx bne gcs3 ldx #hi(abs1) ;set high byte of indirect pointer stx zpt+1 ldy #lo(abs1) ;data after write & execute test area gcs5 adc (zpt),y bcc gcs4 inc ram_chksm+1 ;carry to high byte clc gcs4 iny bne gcs5 inx ;advance RAM high address stx zpt+1 cpx #ram_top bne gcs5 sta ram_chksm ;checksum complete endif next_test 0838 : ad0002 > lda test_case ;previous test 083b : c900 > cmp #test_num > trap_ne ;test is out of sequence 083d : d0fe > bne * ;failed not equal (non zero) > 0001 = >test_num = test_num + 1 083f : a901 > lda #test_num ;*** next tests' number 0841 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test if disable_selfmod = 0 ;testing relative addressing with BEQ 0844 : a0fe ldy #$fe ;testing maximum range, not -1/-2 (invalid/self adr) 0846 : range_loop 0846 : 88 dey ;next relative address 0847 : 98 tya 0848 : aa tax ;precharge count to end of loop 0849 : 1008 bpl range_fw ;calculate relative address 084b : 18 clc ;avoid branch self or to relative address of branch 084c : 6902 adc #2 084e : ea nop ;offset landing zone - tolerate +/-5 offset to branch 084f : ea nop 0850 : ea nop 0851 : ea nop 0852 : ea nop 0853 : range_fw 0853 : ea nop 0854 : ea nop 0855 : ea nop 0856 : ea nop 0857 : ea nop 0858 : 497f eor #$7f ;complement except sign 085a : 8de608 sta range_adr ;load into test target 085d : a900 lda #0 ;should set zero flag in status register 085f : 4ce508 jmp range_op 0862 : ca dex ; offset landing zone - backward branch too far 0863 : ca dex 0864 : ca dex 0865 : ca dex 0866 : ca dex ;relative address target field with branch under test in the middle 0867 : ca dex ;-128 - max backward 0868 : ca dex 0869 : ca dex 086a : ca dex 086b : ca dex 086c : ca dex 086d : ca dex 086e : ca dex 086f : ca dex ;-120 0870 : ca dex 0871 : ca dex 0872 : ca dex 0873 : ca dex 0874 : ca dex 0875 : ca dex 0876 : ca dex 0877 : ca dex 0878 : ca dex 0879 : ca dex ;-110 087a : ca dex 087b : ca dex 087c : ca dex 087d : ca dex 087e : ca dex 087f : ca dex 0880 : ca dex 0881 : ca dex 0882 : ca dex 0883 : ca dex ;-100 0884 : ca dex 0885 : ca dex 0886 : ca dex 0887 : ca dex 0888 : ca dex 0889 : ca dex 088a : ca dex 088b : ca dex 088c : ca dex 088d : ca dex ;-90 088e : ca dex 088f : ca dex 0890 : ca dex 0891 : ca dex 0892 : ca dex 0893 : ca dex 0894 : ca dex 0895 : ca dex 0896 : ca dex 0897 : ca dex ;-80 0898 : ca dex 0899 : ca dex 089a : ca dex 089b : ca dex 089c : ca dex 089d : ca dex 089e : ca dex 089f : ca dex 08a0 : ca dex 08a1 : ca dex ;-70 08a2 : ca dex 08a3 : ca dex 08a4 : ca dex 08a5 : ca dex 08a6 : ca dex 08a7 : ca dex 08a8 : ca dex 08a9 : ca dex 08aa : ca dex 08ab : ca dex ;-60 08ac : ca dex 08ad : ca dex 08ae : ca dex 08af : ca dex 08b0 : ca dex 08b1 : ca dex 08b2 : ca dex 08b3 : ca dex 08b4 : ca dex 08b5 : ca dex ;-50 08b6 : ca dex 08b7 : ca dex 08b8 : ca dex 08b9 : ca dex 08ba : ca dex 08bb : ca dex 08bc : ca dex 08bd : ca dex 08be : ca dex 08bf : ca dex ;-40 08c0 : ca dex 08c1 : ca dex 08c2 : ca dex 08c3 : ca dex 08c4 : ca dex 08c5 : ca dex 08c6 : ca dex 08c7 : ca dex 08c8 : ca dex 08c9 : ca dex ;-30 08ca : ca dex 08cb : ca dex 08cc : ca dex 08cd : ca dex 08ce : ca dex 08cf : ca dex 08d0 : ca dex 08d1 : ca dex 08d2 : ca dex 08d3 : ca dex ;-20 08d4 : ca dex 08d5 : ca dex 08d6 : ca dex 08d7 : ca dex 08d8 : ca dex 08d9 : ca dex 08da : ca dex 08db : ca dex 08dc : ca dex 08dd : ca dex ;-10 08de : ca dex 08df : ca dex 08e0 : ca dex 08e1 : ca dex 08e2 : ca dex 08e3 : ca dex 08e4 : ca dex ;-3 08e5 : range_op ;test target with zero flag=0, z=1 if previous dex 08e6 = range_adr = *+1 ;modifiable relative address 08e5 : f03e beq *+64 ;+64 if called without modification 08e7 : ca dex ;+0 08e8 : ca dex 08e9 : ca dex 08ea : ca dex 08eb : ca dex 08ec : ca dex 08ed : ca dex 08ee : ca dex 08ef : ca dex 08f0 : ca dex 08f1 : ca dex ;+10 08f2 : ca dex 08f3 : ca dex 08f4 : ca dex 08f5 : ca dex 08f6 : ca dex 08f7 : ca dex 08f8 : ca dex 08f9 : ca dex 08fa : ca dex 08fb : ca dex ;+20 08fc : ca dex 08fd : ca dex 08fe : ca dex 08ff : ca dex 0900 : ca dex 0901 : ca dex 0902 : ca dex 0903 : ca dex 0904 : ca dex 0905 : ca dex ;+30 0906 : ca dex 0907 : ca dex 0908 : ca dex 0909 : ca dex 090a : ca dex 090b : ca dex 090c : ca dex 090d : ca dex 090e : ca dex 090f : ca dex ;+40 0910 : ca dex 0911 : ca dex 0912 : ca dex 0913 : ca dex 0914 : ca dex 0915 : ca dex 0916 : ca dex 0917 : ca dex 0918 : ca dex 0919 : ca dex ;+50 091a : ca dex 091b : ca dex 091c : ca dex 091d : ca dex 091e : ca dex 091f : ca dex 0920 : ca dex 0921 : ca dex 0922 : ca dex 0923 : ca dex ;+60 0924 : ca dex 0925 : ca dex 0926 : ca dex 0927 : ca dex 0928 : ca dex 0929 : ca dex 092a : ca dex 092b : ca dex 092c : ca dex 092d : ca dex ;+70 092e : ca dex 092f : ca dex 0930 : ca dex 0931 : ca dex 0932 : ca dex 0933 : ca dex 0934 : ca dex 0935 : ca dex 0936 : ca dex 0937 : ca dex ;+80 0938 : ca dex 0939 : ca dex 093a : ca dex 093b : ca dex 093c : ca dex 093d : ca dex 093e : ca dex 093f : ca dex 0940 : ca dex 0941 : ca dex ;+90 0942 : ca dex 0943 : ca dex 0944 : ca dex 0945 : ca dex 0946 : ca dex 0947 : ca dex 0948 : ca dex 0949 : ca dex 094a : ca dex 094b : ca dex ;+100 094c : ca dex 094d : ca dex 094e : ca dex 094f : ca dex 0950 : ca dex 0951 : ca dex 0952 : ca dex 0953 : ca dex 0954 : ca dex 0955 : ca dex ;+110 0956 : ca dex 0957 : ca dex 0958 : ca dex 0959 : ca dex 095a : ca dex 095b : ca dex 095c : ca dex 095d : ca dex 095e : ca dex 095f : ca dex ;+120 0960 : ca dex 0961 : ca dex 0962 : ca dex 0963 : ca dex 0964 : ca dex 0965 : ca dex 0966 : ea nop ;offset landing zone - forward branch too far 0967 : ea nop 0968 : ea nop 0969 : ea nop 096a : ea nop 096b : f008 beq range_ok ;+127 - max forward trap ; bad range 096d : 4c6d09 > jmp * ;failed anyway 0970 : ea nop ;offset landing zone - tolerate +/-5 offset to branch 0971 : ea nop 0972 : ea nop 0973 : ea nop 0974 : ea nop 0975 : range_ok 0975 : ea nop 0976 : ea nop 0977 : ea nop 0978 : ea nop 0979 : ea nop 097a : c000 cpy #0 097c : f003 beq range_end 097e : 4c4608 jmp range_loop 0981 : range_end ;range test successful endif next_test 0981 : ad0002 > lda test_case ;previous test 0984 : c901 > cmp #test_num > trap_ne ;test is out of sequence 0986 : d0fe > bne * ;failed not equal (non zero) > 0002 = >test_num = test_num + 1 0988 : a902 > lda #test_num ;*** next tests' number 098a : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ;partial test BNE & CMP, CPX, CPY immediate 098d : c001 cpy #1 ;testing BNE true 098f : d003 bne test_bne trap 0991 : 4c9109 > jmp * ;failed anyway 0994 : test_bne 0994 : a900 lda #0 0996 : c900 cmp #0 ;test compare immediate trap_ne 0998 : d0fe > bne * ;failed not equal (non zero) trap_cc 099a : 90fe > bcc * ;failed carry clear trap_mi 099c : 30fe > bmi * ;failed minus (bit 7 set) 099e : c901 cmp #1 trap_eq 09a0 : f0fe > beq * ;failed equal (zero) trap_cs 09a2 : b0fe > bcs * ;failed carry set trap_pl 09a4 : 10fe > bpl * ;failed plus (bit 7 clear) 09a6 : aa tax 09a7 : e000 cpx #0 ;test compare x immediate trap_ne 09a9 : d0fe > bne * ;failed not equal (non zero) trap_cc 09ab : 90fe > bcc * ;failed carry clear trap_mi 09ad : 30fe > bmi * ;failed minus (bit 7 set) 09af : e001 cpx #1 trap_eq 09b1 : f0fe > beq * ;failed equal (zero) trap_cs 09b3 : b0fe > bcs * ;failed carry set trap_pl 09b5 : 10fe > bpl * ;failed plus (bit 7 clear) 09b7 : a8 tay 09b8 : c000 cpy #0 ;test compare y immediate trap_ne 09ba : d0fe > bne * ;failed not equal (non zero) trap_cc 09bc : 90fe > bcc * ;failed carry clear trap_mi 09be : 30fe > bmi * ;failed minus (bit 7 set) 09c0 : c001 cpy #1 trap_eq 09c2 : f0fe > beq * ;failed equal (zero) trap_cs 09c4 : b0fe > bcs * ;failed carry set trap_pl 09c6 : 10fe > bpl * ;failed plus (bit 7 clear) next_test 09c8 : ad0002 > lda test_case ;previous test 09cb : c902 > cmp #test_num > trap_ne ;test is out of sequence 09cd : d0fe > bne * ;failed not equal (non zero) > 0003 = >test_num = test_num + 1 09cf : a903 > lda #test_num ;*** next tests' number 09d1 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ;testing stack operations PHA PHP PLA PLP 09d4 : a2ff ldx #$ff ;initialize stack 09d6 : 9a txs 09d7 : a955 lda #$55 09d9 : 48 pha 09da : a9aa lda #$aa 09dc : 48 pha 09dd : cdfe01 cmp $1fe ;on stack ? trap_ne 09e0 : d0fe > bne * ;failed not equal (non zero) 09e2 : ba tsx 09e3 : 8a txa ;overwrite accu 09e4 : c9fd cmp #$fd ;sp decremented? trap_ne 09e6 : d0fe > bne * ;failed not equal (non zero) 09e8 : 68 pla 09e9 : c9aa cmp #$aa ;successful retreived from stack? trap_ne 09eb : d0fe > bne * ;failed not equal (non zero) 09ed : 68 pla 09ee : c955 cmp #$55 trap_ne 09f0 : d0fe > bne * ;failed not equal (non zero) 09f2 : cdff01 cmp $1ff ;remains on stack? trap_ne 09f5 : d0fe > bne * ;failed not equal (non zero) 09f7 : ba tsx 09f8 : e0ff cpx #$ff ;sp incremented? trap_ne 09fa : d0fe > bne * ;failed not equal (non zero) next_test 09fc : ad0002 > lda test_case ;previous test 09ff : c903 > cmp #test_num > trap_ne ;test is out of sequence 0a01 : d0fe > bne * ;failed not equal (non zero) > 0004 = >test_num = test_num + 1 0a03 : a904 > lda #test_num ;*** next tests' number 0a05 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ;testing branch decisions BPL BMI BVC BVS BCC BCS BNE BEQ set_stat $ff ;all on > load_flag $ff 0a08 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0a0a : 48 > pha ;use stack to load status 0a0b : 28 > plp 0a0c : 101a bpl nbr1 ;branches should not be taken 0a0e : 501b bvc nbr2 0a10 : 901c bcc nbr3 0a12 : d01d bne nbr4 0a14 : 3003 bmi br1 ;branches should be taken trap 0a16 : 4c160a > jmp * ;failed anyway 0a19 : 7003 br1 bvs br2 trap 0a1b : 4c1b0a > jmp * ;failed anyway 0a1e : b003 br2 bcs br3 trap 0a20 : 4c200a > jmp * ;failed anyway 0a23 : f00f br3 beq br4 trap 0a25 : 4c250a > jmp * ;failed anyway 0a28 : nbr1 trap ;previous bpl taken 0a28 : 4c280a > jmp * ;failed anyway 0a2b : nbr2 trap ;previous bvc taken 0a2b : 4c2b0a > jmp * ;failed anyway 0a2e : nbr3 trap ;previous bcc taken 0a2e : 4c2e0a > jmp * ;failed anyway 0a31 : nbr4 trap ;previous bne taken 0a31 : 4c310a > jmp * ;failed anyway 0a34 : 08 br4 php 0a35 : ba tsx 0a36 : e0fe cpx #$fe ;sp after php? trap_ne 0a38 : d0fe > bne * ;failed not equal (non zero) 0a3a : 68 pla cmp_flag $ff ;returned all flags on? 0a3b : c9ff > cmp #($ff |fao)&m8 ;expected flags + always on bits trap_ne 0a3d : d0fe > bne * ;failed not equal (non zero) 0a3f : ba tsx 0a40 : e0ff cpx #$ff ;sp after php? trap_ne 0a42 : d0fe > bne * ;failed not equal (non zero) set_stat 0 ;all off > load_flag 0 0a44 : a900 > lda #0 ;allow test to change I-flag (no mask) > 0a46 : 48 > pha ;use stack to load status 0a47 : 28 > plp 0a48 : 301a bmi nbr11 ;branches should not be taken 0a4a : 701b bvs nbr12 0a4c : b01c bcs nbr13 0a4e : f01d beq nbr14 0a50 : 1003 bpl br11 ;branches should be taken trap 0a52 : 4c520a > jmp * ;failed anyway 0a55 : 5003 br11 bvc br12 trap 0a57 : 4c570a > jmp * ;failed anyway 0a5a : 9003 br12 bcc br13 trap 0a5c : 4c5c0a > jmp * ;failed anyway 0a5f : d00f br13 bne br14 trap 0a61 : 4c610a > jmp * ;failed anyway 0a64 : nbr11 trap ;previous bmi taken 0a64 : 4c640a > jmp * ;failed anyway 0a67 : nbr12 trap ;previous bvs taken 0a67 : 4c670a > jmp * ;failed anyway 0a6a : nbr13 trap ;previous bcs taken 0a6a : 4c6a0a > jmp * ;failed anyway 0a6d : nbr14 trap ;previous beq taken 0a6d : 4c6d0a > jmp * ;failed anyway 0a70 : 08 br14 php 0a71 : 68 pla cmp_flag 0 ;flags off except break (pushed by sw) + reserved? 0a72 : c930 > cmp #(0 |fao)&m8 ;expected flags + always on bits trap_ne 0a74 : d0fe > bne * ;failed not equal (non zero) ;crosscheck flags set_stat zero > load_flag zero 0a76 : a902 > lda #zero ;allow test to change I-flag (no mask) > 0a78 : 48 > pha ;use stack to load status 0a79 : 28 > plp 0a7a : d002 bne brzs1 0a7c : f003 beq brzs2 0a7e : brzs1 trap ;branch zero/non zero 0a7e : 4c7e0a > jmp * ;failed anyway 0a81 : b002 brzs2 bcs brzs3 0a83 : 9003 bcc brzs4 0a85 : brzs3 trap ;branch carry/no carry 0a85 : 4c850a > jmp * ;failed anyway 0a88 : 3002 brzs4 bmi brzs5 0a8a : 1003 bpl brzs6 0a8c : brzs5 trap ;branch minus/plus 0a8c : 4c8c0a > jmp * ;failed anyway 0a8f : 7002 brzs6 bvs brzs7 0a91 : 5003 bvc brzs8 0a93 : brzs7 trap ;branch overflow/no overflow 0a93 : 4c930a > jmp * ;failed anyway 0a96 : brzs8 set_stat carry > load_flag carry 0a96 : a901 > lda #carry ;allow test to change I-flag (no mask) > 0a98 : 48 > pha ;use stack to load status 0a99 : 28 > plp 0a9a : f002 beq brcs1 0a9c : d003 bne brcs2 0a9e : brcs1 trap ;branch zero/non zero 0a9e : 4c9e0a > jmp * ;failed anyway 0aa1 : 9002 brcs2 bcc brcs3 0aa3 : b003 bcs brcs4 0aa5 : brcs3 trap ;branch carry/no carry 0aa5 : 4ca50a > jmp * ;failed anyway 0aa8 : 3002 brcs4 bmi brcs5 0aaa : 1003 bpl brcs6 0aac : brcs5 trap ;branch minus/plus 0aac : 4cac0a > jmp * ;failed anyway 0aaf : 7002 brcs6 bvs brcs7 0ab1 : 5003 bvc brcs8 0ab3 : brcs7 trap ;branch overflow/no overflow 0ab3 : 4cb30a > jmp * ;failed anyway 0ab6 : brcs8 set_stat minus > load_flag minus 0ab6 : a980 > lda #minus ;allow test to change I-flag (no mask) > 0ab8 : 48 > pha ;use stack to load status 0ab9 : 28 > plp 0aba : f002 beq brmi1 0abc : d003 bne brmi2 0abe : brmi1 trap ;branch zero/non zero 0abe : 4cbe0a > jmp * ;failed anyway 0ac1 : b002 brmi2 bcs brmi3 0ac3 : 9003 bcc brmi4 0ac5 : brmi3 trap ;branch carry/no carry 0ac5 : 4cc50a > jmp * ;failed anyway 0ac8 : 1002 brmi4 bpl brmi5 0aca : 3003 bmi brmi6 0acc : brmi5 trap ;branch minus/plus 0acc : 4ccc0a > jmp * ;failed anyway 0acf : 7002 brmi6 bvs brmi7 0ad1 : 5003 bvc brmi8 0ad3 : brmi7 trap ;branch overflow/no overflow 0ad3 : 4cd30a > jmp * ;failed anyway 0ad6 : brmi8 set_stat overfl > load_flag overfl 0ad6 : a940 > lda #overfl ;allow test to change I-flag (no mask) > 0ad8 : 48 > pha ;use stack to load status 0ad9 : 28 > plp 0ada : f002 beq brvs1 0adc : d003 bne brvs2 0ade : brvs1 trap ;branch zero/non zero 0ade : 4cde0a > jmp * ;failed anyway 0ae1 : b002 brvs2 bcs brvs3 0ae3 : 9003 bcc brvs4 0ae5 : brvs3 trap ;branch carry/no carry 0ae5 : 4ce50a > jmp * ;failed anyway 0ae8 : 3002 brvs4 bmi brvs5 0aea : 1003 bpl brvs6 0aec : brvs5 trap ;branch minus/plus 0aec : 4cec0a > jmp * ;failed anyway 0aef : 5002 brvs6 bvc brvs7 0af1 : 7003 bvs brvs8 0af3 : brvs7 trap ;branch overflow/no overflow 0af3 : 4cf30a > jmp * ;failed anyway 0af6 : brvs8 set_stat $ff-zero > load_flag $ff-zero 0af6 : a9fd > lda #$ff-zero ;allow test to change I-flag (no mask) > 0af8 : 48 > pha ;use stack to load status 0af9 : 28 > plp 0afa : f002 beq brzc1 0afc : d003 bne brzc2 0afe : brzc1 trap ;branch zero/non zero 0afe : 4cfe0a > jmp * ;failed anyway 0b01 : 9002 brzc2 bcc brzc3 0b03 : b003 bcs brzc4 0b05 : brzc3 trap ;branch carry/no carry 0b05 : 4c050b > jmp * ;failed anyway 0b08 : 1002 brzc4 bpl brzc5 0b0a : 3003 bmi brzc6 0b0c : brzc5 trap ;branch minus/plus 0b0c : 4c0c0b > jmp * ;failed anyway 0b0f : 5002 brzc6 bvc brzc7 0b11 : 7003 bvs brzc8 0b13 : brzc7 trap ;branch overflow/no overflow 0b13 : 4c130b > jmp * ;failed anyway 0b16 : brzc8 set_stat $ff-carry > load_flag $ff-carry 0b16 : a9fe > lda #$ff-carry ;allow test to change I-flag (no mask) > 0b18 : 48 > pha ;use stack to load status 0b19 : 28 > plp 0b1a : d002 bne brcc1 0b1c : f003 beq brcc2 0b1e : brcc1 trap ;branch zero/non zero 0b1e : 4c1e0b > jmp * ;failed anyway 0b21 : b002 brcc2 bcs brcc3 0b23 : 9003 bcc brcc4 0b25 : brcc3 trap ;branch carry/no carry 0b25 : 4c250b > jmp * ;failed anyway 0b28 : 1002 brcc4 bpl brcc5 0b2a : 3003 bmi brcc6 0b2c : brcc5 trap ;branch minus/plus 0b2c : 4c2c0b > jmp * ;failed anyway 0b2f : 5002 brcc6 bvc brcc7 0b31 : 7003 bvs brcc8 0b33 : brcc7 trap ;branch overflow/no overflow 0b33 : 4c330b > jmp * ;failed anyway 0b36 : brcc8 set_stat $ff-minus > load_flag $ff-minus 0b36 : a97f > lda #$ff-minus ;allow test to change I-flag (no mask) > 0b38 : 48 > pha ;use stack to load status 0b39 : 28 > plp 0b3a : d002 bne brpl1 0b3c : f003 beq brpl2 0b3e : brpl1 trap ;branch zero/non zero 0b3e : 4c3e0b > jmp * ;failed anyway 0b41 : 9002 brpl2 bcc brpl3 0b43 : b003 bcs brpl4 0b45 : brpl3 trap ;branch carry/no carry 0b45 : 4c450b > jmp * ;failed anyway 0b48 : 3002 brpl4 bmi brpl5 0b4a : 1003 bpl brpl6 0b4c : brpl5 trap ;branch minus/plus 0b4c : 4c4c0b > jmp * ;failed anyway 0b4f : 5002 brpl6 bvc brpl7 0b51 : 7003 bvs brpl8 0b53 : brpl7 trap ;branch overflow/no overflow 0b53 : 4c530b > jmp * ;failed anyway 0b56 : brpl8 set_stat $ff-overfl > load_flag $ff-overfl 0b56 : a9bf > lda #$ff-overfl ;allow test to change I-flag (no mask) > 0b58 : 48 > pha ;use stack to load status 0b59 : 28 > plp 0b5a : d002 bne brvc1 0b5c : f003 beq brvc2 0b5e : brvc1 trap ;branch zero/non zero 0b5e : 4c5e0b > jmp * ;failed anyway 0b61 : 9002 brvc2 bcc brvc3 0b63 : b003 bcs brvc4 0b65 : brvc3 trap ;branch carry/no carry 0b65 : 4c650b > jmp * ;failed anyway 0b68 : 1002 brvc4 bpl brvc5 0b6a : 3003 bmi brvc6 0b6c : brvc5 trap ;branch minus/plus 0b6c : 4c6c0b > jmp * ;failed anyway 0b6f : 7002 brvc6 bvs brvc7 0b71 : 5003 bvc brvc8 0b73 : brvc7 trap ;branch overflow/no overflow 0b73 : 4c730b > jmp * ;failed anyway 0b76 : brvc8 next_test 0b76 : ad0002 > lda test_case ;previous test 0b79 : c904 > cmp #test_num > trap_ne ;test is out of sequence 0b7b : d0fe > bne * ;failed not equal (non zero) > 0005 = >test_num = test_num + 1 0b7d : a905 > lda #test_num ;*** next tests' number 0b7f : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; test PHA does not alter flags or accumulator but PLA does 0b82 : a255 ldx #$55 ;x & y protected 0b84 : a0aa ldy #$aa set_a 1,$ff ;push > load_flag $ff 0b86 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0b88 : 48 > pha ;use stack to load status 0b89 : a901 > lda #1 ;precharge accu 0b8b : 28 > plp 0b8c : 48 pha tst_a 1,$ff 0b8d : 08 > php ;save flags 0b8e : c901 > cmp #1 ;test result > trap_ne 0b90 : d0fe > bne * ;failed not equal (non zero) > 0b92 : 68 > pla ;load status 0b93 : 48 > pha > cmp_flag $ff 0b94 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits > > trap_ne 0b96 : d0fe > bne * ;failed not equal (non zero) > 0b98 : 28 > plp ;restore status set_a 0,0 > load_flag 0 0b99 : a900 > lda #0 ;allow test to change I-flag (no mask) > 0b9b : 48 > pha ;use stack to load status 0b9c : a900 > lda #0 ;precharge accu 0b9e : 28 > plp 0b9f : 48 pha tst_a 0,0 0ba0 : 08 > php ;save flags 0ba1 : c900 > cmp #0 ;test result > trap_ne 0ba3 : d0fe > bne * ;failed not equal (non zero) > 0ba5 : 68 > pla ;load status 0ba6 : 48 > pha > cmp_flag 0 0ba7 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 0ba9 : d0fe > bne * ;failed not equal (non zero) > 0bab : 28 > plp ;restore status set_a $ff,$ff > load_flag $ff 0bac : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0bae : 48 > pha ;use stack to load status 0baf : a9ff > lda #$ff ;precharge accu 0bb1 : 28 > plp 0bb2 : 48 pha tst_a $ff,$ff 0bb3 : 08 > php ;save flags 0bb4 : c9ff > cmp #$ff ;test result > trap_ne 0bb6 : d0fe > bne * ;failed not equal (non zero) > 0bb8 : 68 > pla ;load status 0bb9 : 48 > pha > cmp_flag $ff 0bba : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits > > trap_ne 0bbc : d0fe > bne * ;failed not equal (non zero) > 0bbe : 28 > plp ;restore status set_a 1,0 > load_flag 0 0bbf : a900 > lda #0 ;allow test to change I-flag (no mask) > 0bc1 : 48 > pha ;use stack to load status 0bc2 : a901 > lda #1 ;precharge accu 0bc4 : 28 > plp 0bc5 : 48 pha tst_a 1,0 0bc6 : 08 > php ;save flags 0bc7 : c901 > cmp #1 ;test result > trap_ne 0bc9 : d0fe > bne * ;failed not equal (non zero) > 0bcb : 68 > pla ;load status 0bcc : 48 > pha > cmp_flag 0 0bcd : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 0bcf : d0fe > bne * ;failed not equal (non zero) > 0bd1 : 28 > plp ;restore status set_a 0,$ff > load_flag $ff 0bd2 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0bd4 : 48 > pha ;use stack to load status 0bd5 : a900 > lda #0 ;precharge accu 0bd7 : 28 > plp 0bd8 : 48 pha tst_a 0,$ff 0bd9 : 08 > php ;save flags 0bda : c900 > cmp #0 ;test result > trap_ne 0bdc : d0fe > bne * ;failed not equal (non zero) > 0bde : 68 > pla ;load status 0bdf : 48 > pha > cmp_flag $ff 0be0 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits > > trap_ne 0be2 : d0fe > bne * ;failed not equal (non zero) > 0be4 : 28 > plp ;restore status set_a $ff,0 > load_flag 0 0be5 : a900 > lda #0 ;allow test to change I-flag (no mask) > 0be7 : 48 > pha ;use stack to load status 0be8 : a9ff > lda #$ff ;precharge accu 0bea : 28 > plp 0beb : 48 pha tst_a $ff,0 0bec : 08 > php ;save flags 0bed : c9ff > cmp #$ff ;test result > trap_ne 0bef : d0fe > bne * ;failed not equal (non zero) > 0bf1 : 68 > pla ;load status 0bf2 : 48 > pha > cmp_flag 0 0bf3 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 0bf5 : d0fe > bne * ;failed not equal (non zero) > 0bf7 : 28 > plp ;restore status set_a 0,$ff ;pull > load_flag $ff 0bf8 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0bfa : 48 > pha ;use stack to load status 0bfb : a900 > lda #0 ;precharge accu 0bfd : 28 > plp 0bfe : 68 pla tst_a $ff,$ff-zero 0bff : 08 > php ;save flags 0c00 : c9ff > cmp #$ff ;test result > trap_ne 0c02 : d0fe > bne * ;failed not equal (non zero) > 0c04 : 68 > pla ;load status 0c05 : 48 > pha > cmp_flag $ff-zero 0c06 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0c08 : d0fe > bne * ;failed not equal (non zero) > 0c0a : 28 > plp ;restore status set_a $ff,0 > load_flag 0 0c0b : a900 > lda #0 ;allow test to change I-flag (no mask) > 0c0d : 48 > pha ;use stack to load status 0c0e : a9ff > lda #$ff ;precharge accu 0c10 : 28 > plp 0c11 : 68 pla tst_a 0,zero 0c12 : 08 > php ;save flags 0c13 : c900 > cmp #0 ;test result > trap_ne 0c15 : d0fe > bne * ;failed not equal (non zero) > 0c17 : 68 > pla ;load status 0c18 : 48 > pha > cmp_flag zero 0c19 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0c1b : d0fe > bne * ;failed not equal (non zero) > 0c1d : 28 > plp ;restore status set_a $fe,$ff > load_flag $ff 0c1e : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0c20 : 48 > pha ;use stack to load status 0c21 : a9fe > lda #$fe ;precharge accu 0c23 : 28 > plp 0c24 : 68 pla tst_a 1,$ff-zero-minus 0c25 : 08 > php ;save flags 0c26 : c901 > cmp #1 ;test result > trap_ne 0c28 : d0fe > bne * ;failed not equal (non zero) > 0c2a : 68 > pla ;load status 0c2b : 48 > pha > cmp_flag $ff-zero-minus 0c2c : c97d > cmp #($ff-zero-minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0c2e : d0fe > bne * ;failed not equal (non zero) > 0c30 : 28 > plp ;restore status set_a 0,0 > load_flag 0 0c31 : a900 > lda #0 ;allow test to change I-flag (no mask) > 0c33 : 48 > pha ;use stack to load status 0c34 : a900 > lda #0 ;precharge accu 0c36 : 28 > plp 0c37 : 68 pla tst_a $ff,minus 0c38 : 08 > php ;save flags 0c39 : c9ff > cmp #$ff ;test result > trap_ne 0c3b : d0fe > bne * ;failed not equal (non zero) > 0c3d : 68 > pla ;load status 0c3e : 48 > pha > cmp_flag minus 0c3f : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0c41 : d0fe > bne * ;failed not equal (non zero) > 0c43 : 28 > plp ;restore status set_a $ff,$ff > load_flag $ff 0c44 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0c46 : 48 > pha ;use stack to load status 0c47 : a9ff > lda #$ff ;precharge accu 0c49 : 28 > plp 0c4a : 68 pla tst_a 0,$ff-minus 0c4b : 08 > php ;save flags 0c4c : c900 > cmp #0 ;test result > trap_ne 0c4e : d0fe > bne * ;failed not equal (non zero) > 0c50 : 68 > pla ;load status 0c51 : 48 > pha > cmp_flag $ff-minus 0c52 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0c54 : d0fe > bne * ;failed not equal (non zero) > 0c56 : 28 > plp ;restore status set_a $fe,0 > load_flag 0 0c57 : a900 > lda #0 ;allow test to change I-flag (no mask) > 0c59 : 48 > pha ;use stack to load status 0c5a : a9fe > lda #$fe ;precharge accu 0c5c : 28 > plp 0c5d : 68 pla tst_a 1,0 0c5e : 08 > php ;save flags 0c5f : c901 > cmp #1 ;test result > trap_ne 0c61 : d0fe > bne * ;failed not equal (non zero) > 0c63 : 68 > pla ;load status 0c64 : 48 > pha > cmp_flag 0 0c65 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 0c67 : d0fe > bne * ;failed not equal (non zero) > 0c69 : 28 > plp ;restore status 0c6a : e055 cpx #$55 ;x & y unchanged? trap_ne 0c6c : d0fe > bne * ;failed not equal (non zero) 0c6e : c0aa cpy #$aa trap_ne 0c70 : d0fe > bne * ;failed not equal (non zero) next_test 0c72 : ad0002 > lda test_case ;previous test 0c75 : c905 > cmp #test_num > trap_ne ;test is out of sequence 0c77 : d0fe > bne * ;failed not equal (non zero) > 0006 = >test_num = test_num + 1 0c79 : a906 > lda #test_num ;*** next tests' number 0c7b : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; partial pretest EOR # set_a $3c,0 > load_flag 0 0c7e : a900 > lda #0 ;allow test to change I-flag (no mask) > 0c80 : 48 > pha ;use stack to load status 0c81 : a93c > lda #$3c ;precharge accu 0c83 : 28 > plp 0c84 : 49c3 eor #$c3 tst_a $ff,fn 0c86 : 08 > php ;save flags 0c87 : c9ff > cmp #$ff ;test result > trap_ne 0c89 : d0fe > bne * ;failed not equal (non zero) > 0c8b : 68 > pla ;load status 0c8c : 48 > pha > cmp_flag fn 0c8d : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 0c8f : d0fe > bne * ;failed not equal (non zero) > 0c91 : 28 > plp ;restore status set_a $c3,0 > load_flag 0 0c92 : a900 > lda #0 ;allow test to change I-flag (no mask) > 0c94 : 48 > pha ;use stack to load status 0c95 : a9c3 > lda #$c3 ;precharge accu 0c97 : 28 > plp 0c98 : 49c3 eor #$c3 tst_a 0,fz 0c9a : 08 > php ;save flags 0c9b : c900 > cmp #0 ;test result > trap_ne 0c9d : d0fe > bne * ;failed not equal (non zero) > 0c9f : 68 > pla ;load status 0ca0 : 48 > pha > cmp_flag fz 0ca1 : c932 > cmp #(fz|fao)&m8 ;expected flags + always on bits > > trap_ne 0ca3 : d0fe > bne * ;failed not equal (non zero) > 0ca5 : 28 > plp ;restore status next_test 0ca6 : ad0002 > lda test_case ;previous test 0ca9 : c906 > cmp #test_num > trap_ne ;test is out of sequence 0cab : d0fe > bne * ;failed not equal (non zero) > 0007 = >test_num = test_num + 1 0cad : a907 > lda #test_num ;*** next tests' number 0caf : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; PC modifying instructions except branches (NOP, JMP, JSR, RTS, BRK, RTI) ; testing NOP 0cb2 : a224 ldx #$24 0cb4 : a042 ldy #$42 set_a $18,0 > load_flag 0 0cb6 : a900 > lda #0 ;allow test to change I-flag (no mask) > 0cb8 : 48 > pha ;use stack to load status 0cb9 : a918 > lda #$18 ;precharge accu 0cbb : 28 > plp 0cbc : ea nop tst_a $18,0 0cbd : 08 > php ;save flags 0cbe : c918 > cmp #$18 ;test result > trap_ne 0cc0 : d0fe > bne * ;failed not equal (non zero) > 0cc2 : 68 > pla ;load status 0cc3 : 48 > pha > cmp_flag 0 0cc4 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 0cc6 : d0fe > bne * ;failed not equal (non zero) > 0cc8 : 28 > plp ;restore status 0cc9 : e024 cpx #$24 trap_ne 0ccb : d0fe > bne * ;failed not equal (non zero) 0ccd : c042 cpy #$42 trap_ne 0ccf : d0fe > bne * ;failed not equal (non zero) 0cd1 : a2db ldx #$db 0cd3 : a0bd ldy #$bd set_a $e7,$ff > load_flag $ff 0cd5 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0cd7 : 48 > pha ;use stack to load status 0cd8 : a9e7 > lda #$e7 ;precharge accu 0cda : 28 > plp 0cdb : ea nop tst_a $e7,$ff 0cdc : 08 > php ;save flags 0cdd : c9e7 > cmp #$e7 ;test result > trap_ne 0cdf : d0fe > bne * ;failed not equal (non zero) > 0ce1 : 68 > pla ;load status 0ce2 : 48 > pha > cmp_flag $ff 0ce3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits > > trap_ne 0ce5 : d0fe > bne * ;failed not equal (non zero) > 0ce7 : 28 > plp ;restore status 0ce8 : e0db cpx #$db trap_ne 0cea : d0fe > bne * ;failed not equal (non zero) 0cec : c0bd cpy #$bd trap_ne 0cee : d0fe > bne * ;failed not equal (non zero) next_test 0cf0 : ad0002 > lda test_case ;previous test 0cf3 : c907 > cmp #test_num > trap_ne ;test is out of sequence 0cf5 : d0fe > bne * ;failed not equal (non zero) > 0008 = >test_num = test_num + 1 0cf7 : a908 > lda #test_num ;*** next tests' number 0cf9 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; jump absolute set_stat $0 > load_flag $0 0cfc : a900 > lda #$0 ;allow test to change I-flag (no mask) > 0cfe : 48 > pha ;use stack to load status 0cff : 28 > plp 0d00 : a946 lda #'F' 0d02 : a241 ldx #'A' 0d04 : a052 ldy #'R' ;N=0, V=0, Z=0, C=0 0d06 : 4cef3a jmp test_far 0d09 : ea nop 0d0a : ea nop trap_ne ;runover protection 0d0b : d0fe > bne * ;failed not equal (non zero) 0d0d : e8 inx 0d0e : e8 inx 0d0f : far_ret trap_eq ;returned flags OK? 0d0f : f0fe > beq * ;failed equal (zero) trap_pl 0d11 : 10fe > bpl * ;failed plus (bit 7 clear) trap_cc 0d13 : 90fe > bcc * ;failed carry clear trap_vc 0d15 : 50fe > bvc * ;failed overflow clear 0d17 : c9ec cmp #('F'^$aa) ;returned registers OK? trap_ne 0d19 : d0fe > bne * ;failed not equal (non zero) 0d1b : e042 cpx #('A'+1) trap_ne 0d1d : d0fe > bne * ;failed not equal (non zero) 0d1f : c04f cpy #('R'-3) trap_ne 0d21 : d0fe > bne * ;failed not equal (non zero) 0d23 : ca dex 0d24 : c8 iny 0d25 : c8 iny 0d26 : c8 iny 0d27 : 49aa eor #$aa ;N=0, V=1, Z=0, C=1 0d29 : 4c320d jmp test_near 0d2c : ea nop 0d2d : ea nop trap_ne ;runover protection 0d2e : d0fe > bne * ;failed not equal (non zero) 0d30 : e8 inx 0d31 : e8 inx 0d32 : test_near trap_eq ;passed flags OK? 0d32 : f0fe > beq * ;failed equal (zero) trap_mi 0d34 : 30fe > bmi * ;failed minus (bit 7 set) trap_cc 0d36 : 90fe > bcc * ;failed carry clear trap_vc 0d38 : 50fe > bvc * ;failed overflow clear 0d3a : c946 cmp #'F' ;passed registers OK? trap_ne 0d3c : d0fe > bne * ;failed not equal (non zero) 0d3e : e041 cpx #'A' trap_ne 0d40 : d0fe > bne * ;failed not equal (non zero) 0d42 : c052 cpy #'R' trap_ne 0d44 : d0fe > bne * ;failed not equal (non zero) next_test 0d46 : ad0002 > lda test_case ;previous test 0d49 : c908 > cmp #test_num > trap_ne ;test is out of sequence 0d4b : d0fe > bne * ;failed not equal (non zero) > 0009 = >test_num = test_num + 1 0d4d : a909 > lda #test_num ;*** next tests' number 0d4f : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; jump indirect set_stat 0 > load_flag 0 0d52 : a900 > lda #0 ;allow test to change I-flag (no mask) > 0d54 : 48 > pha ;use stack to load status 0d55 : 28 > plp 0d56 : a949 lda #'I' 0d58 : a24e ldx #'N' 0d5a : a044 ldy #'D' ;N=0, V=0, Z=0, C=0 0d5c : 6c1e3b jmp (ptr_tst_ind) 0d5f : ea nop trap_ne ;runover protection 0d60 : d0fe > bne * ;failed not equal (non zero) 0d62 : 88 dey 0d63 : 88 dey 0d64 : ind_ret 0d64 : 08 php ;either SP or Y count will fail, if we do not hit 0d65 : 88 dey 0d66 : 88 dey 0d67 : 88 dey 0d68 : 28 plp trap_eq ;returned flags OK? 0d69 : f0fe > beq * ;failed equal (zero) trap_pl 0d6b : 10fe > bpl * ;failed plus (bit 7 clear) trap_cc 0d6d : 90fe > bcc * ;failed carry clear trap_vc 0d6f : 50fe > bvc * ;failed overflow clear 0d71 : c9e3 cmp #('I'^$aa) ;returned registers OK? trap_ne 0d73 : d0fe > bne * ;failed not equal (non zero) 0d75 : e04f cpx #('N'+1) trap_ne 0d77 : d0fe > bne * ;failed not equal (non zero) 0d79 : c03e cpy #('D'-6) trap_ne 0d7b : d0fe > bne * ;failed not equal (non zero) 0d7d : ba tsx ;SP check 0d7e : e0ff cpx #$ff trap_ne 0d80 : d0fe > bne * ;failed not equal (non zero) next_test 0d82 : ad0002 > lda test_case ;previous test 0d85 : c909 > cmp #test_num > trap_ne ;test is out of sequence 0d87 : d0fe > bne * ;failed not equal (non zero) > 000a = >test_num = test_num + 1 0d89 : a90a > lda #test_num ;*** next tests' number 0d8b : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; jump subroutine & return from subroutine set_stat 0 > load_flag 0 0d8e : a900 > lda #0 ;allow test to change I-flag (no mask) > 0d90 : 48 > pha ;use stack to load status 0d91 : 28 > plp 0d92 : a94a lda #'J' 0d94 : a253 ldx #'S' 0d96 : a052 ldy #'R' ;N=0, V=0, Z=0, C=0 0d98 : 205d3b jsr test_jsr 0d9a = jsr_ret = *-1 ;last address of jsr = return address 0d9b : 08 php ;either SP or Y count will fail, if we do not hit 0d9c : 88 dey 0d9d : 88 dey 0d9e : 88 dey 0d9f : 28 plp trap_eq ;returned flags OK? 0da0 : f0fe > beq * ;failed equal (zero) trap_pl 0da2 : 10fe > bpl * ;failed plus (bit 7 clear) trap_cc 0da4 : 90fe > bcc * ;failed carry clear trap_vc 0da6 : 50fe > bvc * ;failed overflow clear 0da8 : c9e0 cmp #('J'^$aa) ;returned registers OK? trap_ne 0daa : d0fe > bne * ;failed not equal (non zero) 0dac : e054 cpx #('S'+1) trap_ne 0dae : d0fe > bne * ;failed not equal (non zero) 0db0 : c04c cpy #('R'-6) trap_ne 0db2 : d0fe > bne * ;failed not equal (non zero) 0db4 : ba tsx ;sp? 0db5 : e0ff cpx #$ff trap_ne 0db7 : d0fe > bne * ;failed not equal (non zero) next_test 0db9 : ad0002 > lda test_case ;previous test 0dbc : c90a > cmp #test_num > trap_ne ;test is out of sequence 0dbe : d0fe > bne * ;failed not equal (non zero) > 000b = >test_num = test_num + 1 0dc0 : a90b > lda #test_num ;*** next tests' number 0dc2 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; break & return from interrupt if ROM_vectors = 1 load_flag 0 ;with interrupts enabled if allowed! 0dc5 : a900 > lda #0 ;allow test to change I-flag (no mask) 0dc7 : 48 pha 0dc8 : a942 lda #'B' 0dca : a252 ldx #'R' 0dcc : a04b ldy #'K' 0dce : 28 plp ;N=0, V=0, Z=0, C=0 0dcf : 00 brk else lda #hi brk_ret0 ;emulated break pha lda #lo brk_ret0 pha load_flag fao ;set break & unused on stack pha load_flag intdis ;during interrupt pha lda #'B' ldx #'R' ldy #'K' plp ;N=0, V=0, Z=0, C=0 jmp irq_trap endif 0dd0 : 88 dey ;should not be executed 0dd1 : brk_ret0 ;address of break return 0dd1 : 08 php ;either SP or Y count will fail, if we do not hit 0dd2 : 88 dey 0dd3 : 88 dey 0dd4 : 88 dey 0dd5 : c9e8 cmp #'B'^$aa ;returned registers OK? ;the IRQ vector was never executed if A & X stay unmodified trap_ne 0dd7 : d0fe > bne * ;failed not equal (non zero) 0dd9 : e053 cpx #'R'+1 trap_ne 0ddb : d0fe > bne * ;failed not equal (non zero) 0ddd : c045 cpy #'K'-6 trap_ne 0ddf : d0fe > bne * ;failed not equal (non zero) 0de1 : 68 pla ;returned flags OK (unchanged)? cmp_flag 0 0de2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits trap_ne 0de4 : d0fe > bne * ;failed not equal (non zero) 0de6 : ba tsx ;sp? 0de7 : e0ff cpx #$ff trap_ne 0de9 : d0fe > bne * ;failed not equal (non zero) if ROM_vectors = 1 load_flag $ff ;with interrupts disabled if allowed! 0deb : a9ff > lda #$ff ;allow test to change I-flag (no mask) 0ded : 48 pha 0dee : a9bd lda #$ff-'B' 0df0 : a2ad ldx #$ff-'R' 0df2 : a0b4 ldy #$ff-'K' 0df4 : 28 plp ;N=1, V=1, Z=1, C=1 0df5 : 00 brk else lda #hi brk_ret1 ;emulated break pha lda #lo brk_ret1 pha load_flag $ff pha ;set break & unused on stack pha ;actual flags lda #$ff-'B' ldx #$ff-'R' ldy #$ff-'K' plp ;N=1, V=1, Z=1, C=1 jmp irq_trap endif 0df6 : 88 dey ;should not be executed 0df7 : brk_ret1 ;address of break return 0df7 : 08 php ;either SP or Y count will fail, if we do not hit 0df8 : 88 dey 0df9 : 88 dey 0dfa : 88 dey 0dfb : c917 cmp #($ff-'B')^$aa ;returned registers OK? ;the IRQ vector was never executed if A & X stay unmodified trap_ne 0dfd : d0fe > bne * ;failed not equal (non zero) 0dff : e0ae cpx #$ff-'R'+1 trap_ne 0e01 : d0fe > bne * ;failed not equal (non zero) 0e03 : c0ae cpy #$ff-'K'-6 trap_ne 0e05 : d0fe > bne * ;failed not equal (non zero) 0e07 : 68 pla ;returned flags OK (unchanged)? cmp_flag $ff 0e08 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits trap_ne 0e0a : d0fe > bne * ;failed not equal (non zero) 0e0c : ba tsx ;sp? 0e0d : e0ff cpx #$ff trap_ne 0e0f : d0fe > bne * ;failed not equal (non zero) next_test 0e11 : ad0002 > lda test_case ;previous test 0e14 : c90b > cmp #test_num > trap_ne ;test is out of sequence 0e16 : d0fe > bne * ;failed not equal (non zero) > 000c = >test_num = test_num + 1 0e18 : a90c > lda #test_num ;*** next tests' number 0e1a : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; test set and clear flags CLC CLI CLD CLV SEC SEI SED set_stat $ff > load_flag $ff 0e1d : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0e1f : 48 > pha ;use stack to load status 0e20 : 28 > plp 0e21 : 18 clc tst_stat $ff-carry 0e22 : 08 > php ;save status 0e23 : 68 > pla ;use stack to retrieve status 0e24 : 48 > pha > cmp_flag $ff-carry 0e25 : c9fe > cmp #($ff-carry|fao)&m8 ;expected flags + always on bits > > trap_ne 0e27 : d0fe > bne * ;failed not equal (non zero) > 0e29 : 28 > plp ;restore status 0e2a : 38 sec tst_stat $ff 0e2b : 08 > php ;save status 0e2c : 68 > pla ;use stack to retrieve status 0e2d : 48 > pha > cmp_flag $ff 0e2e : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits > > trap_ne 0e30 : d0fe > bne * ;failed not equal (non zero) > 0e32 : 28 > plp ;restore status if I_flag = 3 0e33 : 58 cli tst_stat $ff-intdis 0e34 : 08 > php ;save status 0e35 : 68 > pla ;use stack to retrieve status 0e36 : 48 > pha > cmp_flag $ff-intdis 0e37 : c9fb > cmp #($ff-intdis|fao)&m8 ;expected flags + always on bits > > trap_ne 0e39 : d0fe > bne * ;failed not equal (non zero) > 0e3b : 28 > plp ;restore status 0e3c : 78 sei tst_stat $ff 0e3d : 08 > php ;save status 0e3e : 68 > pla ;use stack to retrieve status 0e3f : 48 > pha > cmp_flag $ff 0e40 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits > > trap_ne 0e42 : d0fe > bne * ;failed not equal (non zero) > 0e44 : 28 > plp ;restore status endif 0e45 : d8 cld tst_stat $ff-decmode 0e46 : 08 > php ;save status 0e47 : 68 > pla ;use stack to retrieve status 0e48 : 48 > pha > cmp_flag $ff-decmode 0e49 : c9f7 > cmp #($ff-decmode|fao)&m8 ;expected flags + always on bits > > trap_ne 0e4b : d0fe > bne * ;failed not equal (non zero) > 0e4d : 28 > plp ;restore status 0e4e : f8 sed tst_stat $ff 0e4f : 08 > php ;save status 0e50 : 68 > pla ;use stack to retrieve status 0e51 : 48 > pha > cmp_flag $ff 0e52 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits > > trap_ne 0e54 : d0fe > bne * ;failed not equal (non zero) > 0e56 : 28 > plp ;restore status 0e57 : b8 clv tst_stat $ff-overfl 0e58 : 08 > php ;save status 0e59 : 68 > pla ;use stack to retrieve status 0e5a : 48 > pha > cmp_flag $ff-overfl 0e5b : c9bf > cmp #($ff-overfl|fao)&m8 ;expected flags + always on bits > > trap_ne 0e5d : d0fe > bne * ;failed not equal (non zero) > 0e5f : 28 > plp ;restore status set_stat 0 > load_flag 0 0e60 : a900 > lda #0 ;allow test to change I-flag (no mask) > 0e62 : 48 > pha ;use stack to load status 0e63 : 28 > plp tst_stat 0 0e64 : 08 > php ;save status 0e65 : 68 > pla ;use stack to retrieve status 0e66 : 48 > pha > cmp_flag 0 0e67 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 0e69 : d0fe > bne * ;failed not equal (non zero) > 0e6b : 28 > plp ;restore status 0e6c : 38 sec tst_stat carry 0e6d : 08 > php ;save status 0e6e : 68 > pla ;use stack to retrieve status 0e6f : 48 > pha > cmp_flag carry 0e70 : c931 > cmp #(carry|fao)&m8 ;expected flags + always on bits > > trap_ne 0e72 : d0fe > bne * ;failed not equal (non zero) > 0e74 : 28 > plp ;restore status 0e75 : 18 clc tst_stat 0 0e76 : 08 > php ;save status 0e77 : 68 > pla ;use stack to retrieve status 0e78 : 48 > pha > cmp_flag 0 0e79 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 0e7b : d0fe > bne * ;failed not equal (non zero) > 0e7d : 28 > plp ;restore status if I_flag = 3 0e7e : 78 sei tst_stat intdis 0e7f : 08 > php ;save status 0e80 : 68 > pla ;use stack to retrieve status 0e81 : 48 > pha > cmp_flag intdis 0e82 : c934 > cmp #(intdis|fao)&m8 ;expected flags + always on bits > > trap_ne 0e84 : d0fe > bne * ;failed not equal (non zero) > 0e86 : 28 > plp ;restore status 0e87 : 58 cli tst_stat 0 0e88 : 08 > php ;save status 0e89 : 68 > pla ;use stack to retrieve status 0e8a : 48 > pha > cmp_flag 0 0e8b : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 0e8d : d0fe > bne * ;failed not equal (non zero) > 0e8f : 28 > plp ;restore status endif 0e90 : f8 sed tst_stat decmode 0e91 : 08 > php ;save status 0e92 : 68 > pla ;use stack to retrieve status 0e93 : 48 > pha > cmp_flag decmode 0e94 : c938 > cmp #(decmode|fao)&m8 ;expected flags + always on bits > > trap_ne 0e96 : d0fe > bne * ;failed not equal (non zero) > 0e98 : 28 > plp ;restore status 0e99 : d8 cld tst_stat 0 0e9a : 08 > php ;save status 0e9b : 68 > pla ;use stack to retrieve status 0e9c : 48 > pha > cmp_flag 0 0e9d : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 0e9f : d0fe > bne * ;failed not equal (non zero) > 0ea1 : 28 > plp ;restore status set_stat overfl > load_flag overfl 0ea2 : a940 > lda #overfl ;allow test to change I-flag (no mask) > 0ea4 : 48 > pha ;use stack to load status 0ea5 : 28 > plp tst_stat overfl 0ea6 : 08 > php ;save status 0ea7 : 68 > pla ;use stack to retrieve status 0ea8 : 48 > pha > cmp_flag overfl 0ea9 : c970 > cmp #(overfl|fao)&m8 ;expected flags + always on bits > > trap_ne 0eab : d0fe > bne * ;failed not equal (non zero) > 0ead : 28 > plp ;restore status 0eae : b8 clv tst_stat 0 0eaf : 08 > php ;save status 0eb0 : 68 > pla ;use stack to retrieve status 0eb1 : 48 > pha > cmp_flag 0 0eb2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 0eb4 : d0fe > bne * ;failed not equal (non zero) > 0eb6 : 28 > plp ;restore status next_test 0eb7 : ad0002 > lda test_case ;previous test 0eba : c90c > cmp #test_num > trap_ne ;test is out of sequence 0ebc : d0fe > bne * ;failed not equal (non zero) > 000d = >test_num = test_num + 1 0ebe : a90d > lda #test_num ;*** next tests' number 0ec0 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; testing index register increment/decrement and transfer ; INX INY DEX DEY TAX TXA TAY TYA 0ec3 : a2fe ldx #$fe set_stat $ff > load_flag $ff 0ec5 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0ec7 : 48 > pha ;use stack to load status 0ec8 : 28 > plp 0ec9 : e8 inx ;ff tst_x $ff,$ff-zero 0eca : 08 > php ;save flags 0ecb : e0ff > cpx #$ff ;test result > trap_ne 0ecd : d0fe > bne * ;failed not equal (non zero) > 0ecf : 68 > pla ;load status 0ed0 : 48 > pha > cmp_flag $ff-zero 0ed1 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0ed3 : d0fe > bne * ;failed not equal (non zero) > 0ed5 : 28 > plp ;restore status 0ed6 : e8 inx ;00 tst_x 0,$ff-minus 0ed7 : 08 > php ;save flags 0ed8 : e000 > cpx #0 ;test result > trap_ne 0eda : d0fe > bne * ;failed not equal (non zero) > 0edc : 68 > pla ;load status 0edd : 48 > pha > cmp_flag $ff-minus 0ede : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0ee0 : d0fe > bne * ;failed not equal (non zero) > 0ee2 : 28 > plp ;restore status 0ee3 : e8 inx ;01 tst_x 1,$ff-minus-zero 0ee4 : 08 > php ;save flags 0ee5 : e001 > cpx #1 ;test result > trap_ne 0ee7 : d0fe > bne * ;failed not equal (non zero) > 0ee9 : 68 > pla ;load status 0eea : 48 > pha > cmp_flag $ff-minus-zero 0eeb : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0eed : d0fe > bne * ;failed not equal (non zero) > 0eef : 28 > plp ;restore status 0ef0 : ca dex ;00 tst_x 0,$ff-minus 0ef1 : 08 > php ;save flags 0ef2 : e000 > cpx #0 ;test result > trap_ne 0ef4 : d0fe > bne * ;failed not equal (non zero) > 0ef6 : 68 > pla ;load status 0ef7 : 48 > pha > cmp_flag $ff-minus 0ef8 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0efa : d0fe > bne * ;failed not equal (non zero) > 0efc : 28 > plp ;restore status 0efd : ca dex ;ff tst_x $ff,$ff-zero 0efe : 08 > php ;save flags 0eff : e0ff > cpx #$ff ;test result > trap_ne 0f01 : d0fe > bne * ;failed not equal (non zero) > 0f03 : 68 > pla ;load status 0f04 : 48 > pha > cmp_flag $ff-zero 0f05 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0f07 : d0fe > bne * ;failed not equal (non zero) > 0f09 : 28 > plp ;restore status 0f0a : ca dex ;fe set_stat 0 > load_flag 0 0f0b : a900 > lda #0 ;allow test to change I-flag (no mask) > 0f0d : 48 > pha ;use stack to load status 0f0e : 28 > plp 0f0f : e8 inx ;ff tst_x $ff,minus 0f10 : 08 > php ;save flags 0f11 : e0ff > cpx #$ff ;test result > trap_ne 0f13 : d0fe > bne * ;failed not equal (non zero) > 0f15 : 68 > pla ;load status 0f16 : 48 > pha > cmp_flag minus 0f17 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0f19 : d0fe > bne * ;failed not equal (non zero) > 0f1b : 28 > plp ;restore status 0f1c : e8 inx ;00 tst_x 0,zero 0f1d : 08 > php ;save flags 0f1e : e000 > cpx #0 ;test result > trap_ne 0f20 : d0fe > bne * ;failed not equal (non zero) > 0f22 : 68 > pla ;load status 0f23 : 48 > pha > cmp_flag zero 0f24 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0f26 : d0fe > bne * ;failed not equal (non zero) > 0f28 : 28 > plp ;restore status 0f29 : e8 inx ;01 tst_x 1,0 0f2a : 08 > php ;save flags 0f2b : e001 > cpx #1 ;test result > trap_ne 0f2d : d0fe > bne * ;failed not equal (non zero) > 0f2f : 68 > pla ;load status 0f30 : 48 > pha > cmp_flag 0 0f31 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 0f33 : d0fe > bne * ;failed not equal (non zero) > 0f35 : 28 > plp ;restore status 0f36 : ca dex ;00 tst_x 0,zero 0f37 : 08 > php ;save flags 0f38 : e000 > cpx #0 ;test result > trap_ne 0f3a : d0fe > bne * ;failed not equal (non zero) > 0f3c : 68 > pla ;load status 0f3d : 48 > pha > cmp_flag zero 0f3e : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0f40 : d0fe > bne * ;failed not equal (non zero) > 0f42 : 28 > plp ;restore status 0f43 : ca dex ;ff tst_x $ff,minus 0f44 : 08 > php ;save flags 0f45 : e0ff > cpx #$ff ;test result > trap_ne 0f47 : d0fe > bne * ;failed not equal (non zero) > 0f49 : 68 > pla ;load status 0f4a : 48 > pha > cmp_flag minus 0f4b : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0f4d : d0fe > bne * ;failed not equal (non zero) > 0f4f : 28 > plp ;restore status 0f50 : a0fe ldy #$fe set_stat $ff > load_flag $ff 0f52 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0f54 : 48 > pha ;use stack to load status 0f55 : 28 > plp 0f56 : c8 iny ;ff tst_y $ff,$ff-zero 0f57 : 08 > php ;save flags 0f58 : c0ff > cpy #$ff ;test result > trap_ne 0f5a : d0fe > bne * ;failed not equal (non zero) > 0f5c : 68 > pla ;load status 0f5d : 48 > pha > cmp_flag $ff-zero 0f5e : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0f60 : d0fe > bne * ;failed not equal (non zero) > 0f62 : 28 > plp ;restore status 0f63 : c8 iny ;00 tst_y 0,$ff-minus 0f64 : 08 > php ;save flags 0f65 : c000 > cpy #0 ;test result > trap_ne 0f67 : d0fe > bne * ;failed not equal (non zero) > 0f69 : 68 > pla ;load status 0f6a : 48 > pha > cmp_flag $ff-minus 0f6b : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0f6d : d0fe > bne * ;failed not equal (non zero) > 0f6f : 28 > plp ;restore status 0f70 : c8 iny ;01 tst_y 1,$ff-minus-zero 0f71 : 08 > php ;save flags 0f72 : c001 > cpy #1 ;test result > trap_ne 0f74 : d0fe > bne * ;failed not equal (non zero) > 0f76 : 68 > pla ;load status 0f77 : 48 > pha > cmp_flag $ff-minus-zero 0f78 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0f7a : d0fe > bne * ;failed not equal (non zero) > 0f7c : 28 > plp ;restore status 0f7d : 88 dey ;00 tst_y 0,$ff-minus 0f7e : 08 > php ;save flags 0f7f : c000 > cpy #0 ;test result > trap_ne 0f81 : d0fe > bne * ;failed not equal (non zero) > 0f83 : 68 > pla ;load status 0f84 : 48 > pha > cmp_flag $ff-minus 0f85 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0f87 : d0fe > bne * ;failed not equal (non zero) > 0f89 : 28 > plp ;restore status 0f8a : 88 dey ;ff tst_y $ff,$ff-zero 0f8b : 08 > php ;save flags 0f8c : c0ff > cpy #$ff ;test result > trap_ne 0f8e : d0fe > bne * ;failed not equal (non zero) > 0f90 : 68 > pla ;load status 0f91 : 48 > pha > cmp_flag $ff-zero 0f92 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0f94 : d0fe > bne * ;failed not equal (non zero) > 0f96 : 28 > plp ;restore status 0f97 : 88 dey ;fe set_stat 0 > load_flag 0 0f98 : a900 > lda #0 ;allow test to change I-flag (no mask) > 0f9a : 48 > pha ;use stack to load status 0f9b : 28 > plp 0f9c : c8 iny ;ff tst_y $ff,0+minus 0f9d : 08 > php ;save flags 0f9e : c0ff > cpy #$ff ;test result > trap_ne 0fa0 : d0fe > bne * ;failed not equal (non zero) > 0fa2 : 68 > pla ;load status 0fa3 : 48 > pha > cmp_flag 0+minus 0fa4 : c9b0 > cmp #(0+minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0fa6 : d0fe > bne * ;failed not equal (non zero) > 0fa8 : 28 > plp ;restore status 0fa9 : c8 iny ;00 tst_y 0,zero 0faa : 08 > php ;save flags 0fab : c000 > cpy #0 ;test result > trap_ne 0fad : d0fe > bne * ;failed not equal (non zero) > 0faf : 68 > pla ;load status 0fb0 : 48 > pha > cmp_flag zero 0fb1 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0fb3 : d0fe > bne * ;failed not equal (non zero) > 0fb5 : 28 > plp ;restore status 0fb6 : c8 iny ;01 tst_y 1,0 0fb7 : 08 > php ;save flags 0fb8 : c001 > cpy #1 ;test result > trap_ne 0fba : d0fe > bne * ;failed not equal (non zero) > 0fbc : 68 > pla ;load status 0fbd : 48 > pha > cmp_flag 0 0fbe : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 0fc0 : d0fe > bne * ;failed not equal (non zero) > 0fc2 : 28 > plp ;restore status 0fc3 : 88 dey ;00 tst_y 0,zero 0fc4 : 08 > php ;save flags 0fc5 : c000 > cpy #0 ;test result > trap_ne 0fc7 : d0fe > bne * ;failed not equal (non zero) > 0fc9 : 68 > pla ;load status 0fca : 48 > pha > cmp_flag zero 0fcb : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0fcd : d0fe > bne * ;failed not equal (non zero) > 0fcf : 28 > plp ;restore status 0fd0 : 88 dey ;ff tst_y $ff,minus 0fd1 : 08 > php ;save flags 0fd2 : c0ff > cpy #$ff ;test result > trap_ne 0fd4 : d0fe > bne * ;failed not equal (non zero) > 0fd6 : 68 > pla ;load status 0fd7 : 48 > pha > cmp_flag minus 0fd8 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0fda : d0fe > bne * ;failed not equal (non zero) > 0fdc : 28 > plp ;restore status 0fdd : a2ff ldx #$ff set_stat $ff > load_flag $ff 0fdf : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0fe1 : 48 > pha ;use stack to load status 0fe2 : 28 > plp 0fe3 : 8a txa tst_a $ff,$ff-zero 0fe4 : 08 > php ;save flags 0fe5 : c9ff > cmp #$ff ;test result > trap_ne 0fe7 : d0fe > bne * ;failed not equal (non zero) > 0fe9 : 68 > pla ;load status 0fea : 48 > pha > cmp_flag $ff-zero 0feb : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0fed : d0fe > bne * ;failed not equal (non zero) > 0fef : 28 > plp ;restore status 0ff0 : 08 php 0ff1 : e8 inx ;00 0ff2 : 28 plp 0ff3 : 8a txa tst_a 0,$ff-minus 0ff4 : 08 > php ;save flags 0ff5 : c900 > cmp #0 ;test result > trap_ne 0ff7 : d0fe > bne * ;failed not equal (non zero) > 0ff9 : 68 > pla ;load status 0ffa : 48 > pha > cmp_flag $ff-minus 0ffb : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0ffd : d0fe > bne * ;failed not equal (non zero) > 0fff : 28 > plp ;restore status 1000 : 08 php 1001 : e8 inx ;01 1002 : 28 plp 1003 : 8a txa tst_a 1,$ff-minus-zero 1004 : 08 > php ;save flags 1005 : c901 > cmp #1 ;test result > trap_ne 1007 : d0fe > bne * ;failed not equal (non zero) > 1009 : 68 > pla ;load status 100a : 48 > pha > cmp_flag $ff-minus-zero 100b : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 100d : d0fe > bne * ;failed not equal (non zero) > 100f : 28 > plp ;restore status set_stat 0 > load_flag 0 1010 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1012 : 48 > pha ;use stack to load status 1013 : 28 > plp 1014 : 8a txa tst_a 1,0 1015 : 08 > php ;save flags 1016 : c901 > cmp #1 ;test result > trap_ne 1018 : d0fe > bne * ;failed not equal (non zero) > 101a : 68 > pla ;load status 101b : 48 > pha > cmp_flag 0 101c : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 101e : d0fe > bne * ;failed not equal (non zero) > 1020 : 28 > plp ;restore status 1021 : 08 php 1022 : ca dex ;00 1023 : 28 plp 1024 : 8a txa tst_a 0,zero 1025 : 08 > php ;save flags 1026 : c900 > cmp #0 ;test result > trap_ne 1028 : d0fe > bne * ;failed not equal (non zero) > 102a : 68 > pla ;load status 102b : 48 > pha > cmp_flag zero 102c : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits > > trap_ne 102e : d0fe > bne * ;failed not equal (non zero) > 1030 : 28 > plp ;restore status 1031 : 08 php 1032 : ca dex ;ff 1033 : 28 plp 1034 : 8a txa tst_a $ff,minus 1035 : 08 > php ;save flags 1036 : c9ff > cmp #$ff ;test result > trap_ne 1038 : d0fe > bne * ;failed not equal (non zero) > 103a : 68 > pla ;load status 103b : 48 > pha > cmp_flag minus 103c : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits > > trap_ne 103e : d0fe > bne * ;failed not equal (non zero) > 1040 : 28 > plp ;restore status 1041 : a0ff ldy #$ff set_stat $ff > load_flag $ff 1043 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1045 : 48 > pha ;use stack to load status 1046 : 28 > plp 1047 : 98 tya tst_a $ff,$ff-zero 1048 : 08 > php ;save flags 1049 : c9ff > cmp #$ff ;test result > trap_ne 104b : d0fe > bne * ;failed not equal (non zero) > 104d : 68 > pla ;load status 104e : 48 > pha > cmp_flag $ff-zero 104f : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 1051 : d0fe > bne * ;failed not equal (non zero) > 1053 : 28 > plp ;restore status 1054 : 08 php 1055 : c8 iny ;00 1056 : 28 plp 1057 : 98 tya tst_a 0,$ff-minus 1058 : 08 > php ;save flags 1059 : c900 > cmp #0 ;test result > trap_ne 105b : d0fe > bne * ;failed not equal (non zero) > 105d : 68 > pla ;load status 105e : 48 > pha > cmp_flag $ff-minus 105f : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits > > trap_ne 1061 : d0fe > bne * ;failed not equal (non zero) > 1063 : 28 > plp ;restore status 1064 : 08 php 1065 : c8 iny ;01 1066 : 28 plp 1067 : 98 tya tst_a 1,$ff-minus-zero 1068 : 08 > php ;save flags 1069 : c901 > cmp #1 ;test result > trap_ne 106b : d0fe > bne * ;failed not equal (non zero) > 106d : 68 > pla ;load status 106e : 48 > pha > cmp_flag $ff-minus-zero 106f : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 1071 : d0fe > bne * ;failed not equal (non zero) > 1073 : 28 > plp ;restore status set_stat 0 > load_flag 0 1074 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1076 : 48 > pha ;use stack to load status 1077 : 28 > plp 1078 : 98 tya tst_a 1,0 1079 : 08 > php ;save flags 107a : c901 > cmp #1 ;test result > trap_ne 107c : d0fe > bne * ;failed not equal (non zero) > 107e : 68 > pla ;load status 107f : 48 > pha > cmp_flag 0 1080 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 1082 : d0fe > bne * ;failed not equal (non zero) > 1084 : 28 > plp ;restore status 1085 : 08 php 1086 : 88 dey ;00 1087 : 28 plp 1088 : 98 tya tst_a 0,zero 1089 : 08 > php ;save flags 108a : c900 > cmp #0 ;test result > trap_ne 108c : d0fe > bne * ;failed not equal (non zero) > 108e : 68 > pla ;load status 108f : 48 > pha > cmp_flag zero 1090 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits > > trap_ne 1092 : d0fe > bne * ;failed not equal (non zero) > 1094 : 28 > plp ;restore status 1095 : 08 php 1096 : 88 dey ;ff 1097 : 28 plp 1098 : 98 tya tst_a $ff,minus 1099 : 08 > php ;save flags 109a : c9ff > cmp #$ff ;test result > trap_ne 109c : d0fe > bne * ;failed not equal (non zero) > 109e : 68 > pla ;load status 109f : 48 > pha > cmp_flag minus 10a0 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits > > trap_ne 10a2 : d0fe > bne * ;failed not equal (non zero) > 10a4 : 28 > plp ;restore status load_flag $ff 10a5 : a9ff > lda #$ff ;allow test to change I-flag (no mask) 10a7 : 48 pha 10a8 : a2ff ldx #$ff ;ff 10aa : 8a txa 10ab : 28 plp 10ac : a8 tay tst_y $ff,$ff-zero 10ad : 08 > php ;save flags 10ae : c0ff > cpy #$ff ;test result > trap_ne 10b0 : d0fe > bne * ;failed not equal (non zero) > 10b2 : 68 > pla ;load status 10b3 : 48 > pha > cmp_flag $ff-zero 10b4 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 10b6 : d0fe > bne * ;failed not equal (non zero) > 10b8 : 28 > plp ;restore status 10b9 : 08 php 10ba : e8 inx ;00 10bb : 8a txa 10bc : 28 plp 10bd : a8 tay tst_y 0,$ff-minus 10be : 08 > php ;save flags 10bf : c000 > cpy #0 ;test result > trap_ne 10c1 : d0fe > bne * ;failed not equal (non zero) > 10c3 : 68 > pla ;load status 10c4 : 48 > pha > cmp_flag $ff-minus 10c5 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits > > trap_ne 10c7 : d0fe > bne * ;failed not equal (non zero) > 10c9 : 28 > plp ;restore status 10ca : 08 php 10cb : e8 inx ;01 10cc : 8a txa 10cd : 28 plp 10ce : a8 tay tst_y 1,$ff-minus-zero 10cf : 08 > php ;save flags 10d0 : c001 > cpy #1 ;test result > trap_ne 10d2 : d0fe > bne * ;failed not equal (non zero) > 10d4 : 68 > pla ;load status 10d5 : 48 > pha > cmp_flag $ff-minus-zero 10d6 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 10d8 : d0fe > bne * ;failed not equal (non zero) > 10da : 28 > plp ;restore status load_flag 0 10db : a900 > lda #0 ;allow test to change I-flag (no mask) 10dd : 48 pha 10de : a900 lda #0 10e0 : 8a txa 10e1 : 28 plp 10e2 : a8 tay tst_y 1,0 10e3 : 08 > php ;save flags 10e4 : c001 > cpy #1 ;test result > trap_ne 10e6 : d0fe > bne * ;failed not equal (non zero) > 10e8 : 68 > pla ;load status 10e9 : 48 > pha > cmp_flag 0 10ea : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 10ec : d0fe > bne * ;failed not equal (non zero) > 10ee : 28 > plp ;restore status 10ef : 08 php 10f0 : ca dex ;00 10f1 : 8a txa 10f2 : 28 plp 10f3 : a8 tay tst_y 0,zero 10f4 : 08 > php ;save flags 10f5 : c000 > cpy #0 ;test result > trap_ne 10f7 : d0fe > bne * ;failed not equal (non zero) > 10f9 : 68 > pla ;load status 10fa : 48 > pha > cmp_flag zero 10fb : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits > > trap_ne 10fd : d0fe > bne * ;failed not equal (non zero) > 10ff : 28 > plp ;restore status 1100 : 08 php 1101 : ca dex ;ff 1102 : 8a txa 1103 : 28 plp 1104 : a8 tay tst_y $ff,minus 1105 : 08 > php ;save flags 1106 : c0ff > cpy #$ff ;test result > trap_ne 1108 : d0fe > bne * ;failed not equal (non zero) > 110a : 68 > pla ;load status 110b : 48 > pha > cmp_flag minus 110c : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits > > trap_ne 110e : d0fe > bne * ;failed not equal (non zero) > 1110 : 28 > plp ;restore status load_flag $ff 1111 : a9ff > lda #$ff ;allow test to change I-flag (no mask) 1113 : 48 pha 1114 : a0ff ldy #$ff ;ff 1116 : 98 tya 1117 : 28 plp 1118 : aa tax tst_x $ff,$ff-zero 1119 : 08 > php ;save flags 111a : e0ff > cpx #$ff ;test result > trap_ne 111c : d0fe > bne * ;failed not equal (non zero) > 111e : 68 > pla ;load status 111f : 48 > pha > cmp_flag $ff-zero 1120 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 1122 : d0fe > bne * ;failed not equal (non zero) > 1124 : 28 > plp ;restore status 1125 : 08 php 1126 : c8 iny ;00 1127 : 98 tya 1128 : 28 plp 1129 : aa tax tst_x 0,$ff-minus 112a : 08 > php ;save flags 112b : e000 > cpx #0 ;test result > trap_ne 112d : d0fe > bne * ;failed not equal (non zero) > 112f : 68 > pla ;load status 1130 : 48 > pha > cmp_flag $ff-minus 1131 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits > > trap_ne 1133 : d0fe > bne * ;failed not equal (non zero) > 1135 : 28 > plp ;restore status 1136 : 08 php 1137 : c8 iny ;01 1138 : 98 tya 1139 : 28 plp 113a : aa tax tst_x 1,$ff-minus-zero 113b : 08 > php ;save flags 113c : e001 > cpx #1 ;test result > trap_ne 113e : d0fe > bne * ;failed not equal (non zero) > 1140 : 68 > pla ;load status 1141 : 48 > pha > cmp_flag $ff-minus-zero 1142 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 1144 : d0fe > bne * ;failed not equal (non zero) > 1146 : 28 > plp ;restore status load_flag 0 1147 : a900 > lda #0 ;allow test to change I-flag (no mask) 1149 : 48 pha 114a : a900 lda #0 ;preset status 114c : 98 tya 114d : 28 plp 114e : aa tax tst_x 1,0 114f : 08 > php ;save flags 1150 : e001 > cpx #1 ;test result > trap_ne 1152 : d0fe > bne * ;failed not equal (non zero) > 1154 : 68 > pla ;load status 1155 : 48 > pha > cmp_flag 0 1156 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 1158 : d0fe > bne * ;failed not equal (non zero) > 115a : 28 > plp ;restore status 115b : 08 php 115c : 88 dey ;00 115d : 98 tya 115e : 28 plp 115f : aa tax tst_x 0,zero 1160 : 08 > php ;save flags 1161 : e000 > cpx #0 ;test result > trap_ne 1163 : d0fe > bne * ;failed not equal (non zero) > 1165 : 68 > pla ;load status 1166 : 48 > pha > cmp_flag zero 1167 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits > > trap_ne 1169 : d0fe > bne * ;failed not equal (non zero) > 116b : 28 > plp ;restore status 116c : 08 php 116d : 88 dey ;ff 116e : 98 tya 116f : 28 plp 1170 : aa tax tst_x $ff,minus 1171 : 08 > php ;save flags 1172 : e0ff > cpx #$ff ;test result > trap_ne 1174 : d0fe > bne * ;failed not equal (non zero) > 1176 : 68 > pla ;load status 1177 : 48 > pha > cmp_flag minus 1178 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits > > trap_ne 117a : d0fe > bne * ;failed not equal (non zero) > 117c : 28 > plp ;restore status next_test 117d : ad0002 > lda test_case ;previous test 1180 : c90d > cmp #test_num > trap_ne ;test is out of sequence 1182 : d0fe > bne * ;failed not equal (non zero) > 000e = >test_num = test_num + 1 1184 : a90e > lda #test_num ;*** next tests' number 1186 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ;TSX sets NZ - TXS does not ; This section also tests for proper stack wrap around. 1189 : a201 ldx #1 ;01 set_stat $ff > load_flag $ff 118b : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 118d : 48 > pha ;use stack to load status 118e : 28 > plp 118f : 9a txs 1190 : 08 php 1191 : ad0101 lda $101 cmp_flag $ff 1194 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits trap_ne 1196 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1198 : a900 > lda #0 ;allow test to change I-flag (no mask) > 119a : 48 > pha ;use stack to load status 119b : 28 > plp 119c : 9a txs 119d : 08 php 119e : ad0101 lda $101 cmp_flag 0 11a1 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits trap_ne 11a3 : d0fe > bne * ;failed not equal (non zero) 11a5 : ca dex ;00 set_stat $ff > load_flag $ff 11a6 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 11a8 : 48 > pha ;use stack to load status 11a9 : 28 > plp 11aa : 9a txs 11ab : 08 php 11ac : ad0001 lda $100 cmp_flag $ff 11af : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits trap_ne 11b1 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 11b3 : a900 > lda #0 ;allow test to change I-flag (no mask) > 11b5 : 48 > pha ;use stack to load status 11b6 : 28 > plp 11b7 : 9a txs 11b8 : 08 php 11b9 : ad0001 lda $100 cmp_flag 0 11bc : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits trap_ne 11be : d0fe > bne * ;failed not equal (non zero) 11c0 : ca dex ;ff set_stat $ff > load_flag $ff 11c1 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 11c3 : 48 > pha ;use stack to load status 11c4 : 28 > plp 11c5 : 9a txs 11c6 : 08 php 11c7 : adff01 lda $1ff cmp_flag $ff 11ca : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits trap_ne 11cc : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 11ce : a900 > lda #0 ;allow test to change I-flag (no mask) > 11d0 : 48 > pha ;use stack to load status 11d1 : 28 > plp 11d2 : 9a txs 11d3 : 08 php 11d4 : adff01 lda $1ff cmp_flag 0 11d7 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits 11d9 : a201 ldx #1 11db : 9a txs ;sp=01 set_stat $ff > load_flag $ff 11dc : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 11de : 48 > pha ;use stack to load status 11df : 28 > plp 11e0 : ba tsx ;clears Z, N 11e1 : 08 php ;sp=00 11e2 : e001 cpx #1 trap_ne 11e4 : d0fe > bne * ;failed not equal (non zero) 11e6 : ad0101 lda $101 cmp_flag $ff-minus-zero 11e9 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits trap_ne 11eb : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 11ed : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 11ef : 48 > pha ;use stack to load status 11f0 : 28 > plp 11f1 : ba tsx ;clears N, sets Z 11f2 : 08 php ;sp=ff 11f3 : e000 cpx #0 trap_ne 11f5 : d0fe > bne * ;failed not equal (non zero) 11f7 : ad0001 lda $100 cmp_flag $ff-minus 11fa : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits trap_ne 11fc : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 11fe : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1200 : 48 > pha ;use stack to load status 1201 : 28 > plp 1202 : ba tsx ;clears N, sets Z 1203 : 08 php ;sp=fe 1204 : e0ff cpx #$ff trap_ne 1206 : d0fe > bne * ;failed not equal (non zero) 1208 : adff01 lda $1ff cmp_flag $ff-zero 120b : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits trap_ne 120d : d0fe > bne * ;failed not equal (non zero) 120f : a201 ldx #1 1211 : 9a txs ;sp=01 set_stat 0 > load_flag 0 1212 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1214 : 48 > pha ;use stack to load status 1215 : 28 > plp 1216 : ba tsx ;clears Z, N 1217 : 08 php ;sp=00 1218 : e001 cpx #1 trap_ne 121a : d0fe > bne * ;failed not equal (non zero) 121c : ad0101 lda $101 cmp_flag 0 121f : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits trap_ne 1221 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1223 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1225 : 48 > pha ;use stack to load status 1226 : 28 > plp 1227 : ba tsx ;clears N, sets Z 1228 : 08 php ;sp=ff 1229 : e000 cpx #0 trap_ne 122b : d0fe > bne * ;failed not equal (non zero) 122d : ad0001 lda $100 cmp_flag zero 1230 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits trap_ne 1232 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1234 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1236 : 48 > pha ;use stack to load status 1237 : 28 > plp 1238 : ba tsx ;clears N, sets Z 1239 : 08 php ;sp=fe 123a : e0ff cpx #$ff trap_ne 123c : d0fe > bne * ;failed not equal (non zero) 123e : adff01 lda $1ff cmp_flag minus 1241 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits trap_ne 1243 : d0fe > bne * ;failed not equal (non zero) 1245 : 68 pla ;sp=ff next_test 1246 : ad0002 > lda test_case ;previous test 1249 : c90e > cmp #test_num > trap_ne ;test is out of sequence 124b : d0fe > bne * ;failed not equal (non zero) > 000f = >test_num = test_num + 1 124d : a90f > lda #test_num ;*** next tests' number 124f : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; testing index register load & store LDY LDX STY STX all addressing modes ; LDX / STX - zp,y / abs,y 1252 : a003 ldy #3 1254 : tldx set_stat 0 > load_flag 0 1254 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1256 : 48 > pha ;use stack to load status 1257 : 28 > plp 1258 : b609 ldx zp1,y 125a : 08 php ;test stores do not alter flags 125b : 8a txa 125c : 49c3 eor #$c3 125e : 28 plp 125f : 990302 sta abst,y 1262 : 08 php ;flags after load/store sequence 1263 : 49c3 eor #$c3 1265 : d91702 cmp abs1,y ;test result trap_ne 1268 : d0fe > bne * ;failed not equal (non zero) 126a : 68 pla ;load status eor_flag 0 126b : 4930 > eor #0|fao ;invert expected flags + always on bits 126d : d91c02 cmp fLDx,y ;test flags trap_ne 1270 : d0fe > bne * ;failed not equal (non zero) 1272 : 88 dey 1273 : 10df bpl tldx 1275 : a003 ldy #3 1277 : tldx1 set_stat $ff > load_flag $ff 1277 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1279 : 48 > pha ;use stack to load status 127a : 28 > plp 127b : b609 ldx zp1,y 127d : 08 php ;test stores do not alter flags 127e : 8a txa 127f : 49c3 eor #$c3 1281 : 28 plp 1282 : 990302 sta abst,y 1285 : 08 php ;flags after load/store sequence 1286 : 49c3 eor #$c3 1288 : d91702 cmp abs1,y ;test result trap_ne 128b : d0fe > bne * ;failed not equal (non zero) 128d : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 128e : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1290 : d91c02 cmp fLDx,y ;test flags trap_ne 1293 : d0fe > bne * ;failed not equal (non zero) 1295 : 88 dey 1296 : 10df bpl tldx1 1298 : a003 ldy #3 129a : tldx2 set_stat 0 > load_flag 0 129a : a900 > lda #0 ;allow test to change I-flag (no mask) > 129c : 48 > pha ;use stack to load status 129d : 28 > plp 129e : be1702 ldx abs1,y 12a1 : 08 php ;test stores do not alter flags 12a2 : 8a txa 12a3 : 49c3 eor #$c3 12a5 : aa tax 12a6 : 28 plp 12a7 : 9602 stx zpt,y 12a9 : 08 php ;flags after load/store sequence 12aa : 49c3 eor #$c3 12ac : d90900 cmp zp1,y ;test result trap_ne 12af : d0fe > bne * ;failed not equal (non zero) 12b1 : 68 pla ;load status eor_flag 0 12b2 : 4930 > eor #0|fao ;invert expected flags + always on bits 12b4 : d91c02 cmp fLDx,y ;test flags trap_ne 12b7 : d0fe > bne * ;failed not equal (non zero) 12b9 : 88 dey 12ba : 10de bpl tldx2 12bc : a003 ldy #3 12be : tldx3 set_stat $ff > load_flag $ff 12be : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 12c0 : 48 > pha ;use stack to load status 12c1 : 28 > plp 12c2 : be1702 ldx abs1,y 12c5 : 08 php ;test stores do not alter flags 12c6 : 8a txa 12c7 : 49c3 eor #$c3 12c9 : aa tax 12ca : 28 plp 12cb : 9602 stx zpt,y 12cd : 08 php ;flags after load/store sequence 12ce : 49c3 eor #$c3 12d0 : d90900 cmp zp1,y ;test result trap_ne 12d3 : d0fe > bne * ;failed not equal (non zero) 12d5 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 12d6 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 12d8 : d91c02 cmp fLDx,y ;test flags trap_ne 12db : d0fe > bne * ;failed not equal (non zero) 12dd : 88 dey 12de : 10de bpl tldx3 12e0 : a003 ldy #3 ;testing store result 12e2 : a200 ldx #0 12e4 : b90200 tstx lda zpt,y 12e7 : 49c3 eor #$c3 12e9 : d90900 cmp zp1,y trap_ne ;store to zp data 12ec : d0fe > bne * ;failed not equal (non zero) 12ee : 9602 stx zpt,y ;clear 12f0 : b90302 lda abst,y 12f3 : 49c3 eor #$c3 12f5 : d91702 cmp abs1,y trap_ne ;store to abs data 12f8 : d0fe > bne * ;failed not equal (non zero) 12fa : 8a txa 12fb : 990302 sta abst,y ;clear 12fe : 88 dey 12ff : 10e3 bpl tstx next_test 1301 : ad0002 > lda test_case ;previous test 1304 : c90f > cmp #test_num > trap_ne ;test is out of sequence 1306 : d0fe > bne * ;failed not equal (non zero) > 0010 = >test_num = test_num + 1 1308 : a910 > lda #test_num ;*** next tests' number 130a : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; indexed wraparound test (only zp should wrap) 130d : a0fd ldy #3+$fa 130f : b60f tldx4 ldx zp1-$fa&$ff,y ;wrap on indexed zp 1311 : 8a txa 1312 : 990901 sta abst-$fa,y ;no STX abs,y! 1315 : 88 dey 1316 : c0fa cpy #$fa 1318 : b0f5 bcs tldx4 131a : a0fd ldy #3+$fa 131c : be1d01 tldx5 ldx abs1-$fa,y ;no wrap on indexed abs 131f : 9608 stx zpt-$fa&$ff,y 1321 : 88 dey 1322 : c0fa cpy #$fa 1324 : b0f6 bcs tldx5 1326 : a003 ldy #3 ;testing wraparound result 1328 : a200 ldx #0 132a : b90200 tstx1 lda zpt,y 132d : d90900 cmp zp1,y trap_ne ;store to zp data 1330 : d0fe > bne * ;failed not equal (non zero) 1332 : 9602 stx zpt,y ;clear 1334 : b90302 lda abst,y 1337 : d91702 cmp abs1,y trap_ne ;store to abs data 133a : d0fe > bne * ;failed not equal (non zero) 133c : 8a txa 133d : 990302 sta abst,y ;clear 1340 : 88 dey 1341 : 10e7 bpl tstx1 next_test 1343 : ad0002 > lda test_case ;previous test 1346 : c910 > cmp #test_num > trap_ne ;test is out of sequence 1348 : d0fe > bne * ;failed not equal (non zero) > 0011 = >test_num = test_num + 1 134a : a911 > lda #test_num ;*** next tests' number 134c : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; LDY / STY - zp,x / abs,x 134f : a203 ldx #3 1351 : tldy set_stat 0 > load_flag 0 1351 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1353 : 48 > pha ;use stack to load status 1354 : 28 > plp 1355 : b409 ldy zp1,x 1357 : 08 php ;test stores do not alter flags 1358 : 98 tya 1359 : 49c3 eor #$c3 135b : 28 plp 135c : 9d0302 sta abst,x 135f : 08 php ;flags after load/store sequence 1360 : 49c3 eor #$c3 1362 : dd1702 cmp abs1,x ;test result trap_ne 1365 : d0fe > bne * ;failed not equal (non zero) 1367 : 68 pla ;load status eor_flag 0 1368 : 4930 > eor #0|fao ;invert expected flags + always on bits 136a : dd1c02 cmp fLDx,x ;test flags trap_ne 136d : d0fe > bne * ;failed not equal (non zero) 136f : ca dex 1370 : 10df bpl tldy 1372 : a203 ldx #3 1374 : tldy1 set_stat $ff > load_flag $ff 1374 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1376 : 48 > pha ;use stack to load status 1377 : 28 > plp 1378 : b409 ldy zp1,x 137a : 08 php ;test stores do not alter flags 137b : 98 tya 137c : 49c3 eor #$c3 137e : 28 plp 137f : 9d0302 sta abst,x 1382 : 08 php ;flags after load/store sequence 1383 : 49c3 eor #$c3 1385 : dd1702 cmp abs1,x ;test result trap_ne 1388 : d0fe > bne * ;failed not equal (non zero) 138a : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 138b : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 138d : dd1c02 cmp fLDx,x ;test flags trap_ne 1390 : d0fe > bne * ;failed not equal (non zero) 1392 : ca dex 1393 : 10df bpl tldy1 1395 : a203 ldx #3 1397 : tldy2 set_stat 0 > load_flag 0 1397 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1399 : 48 > pha ;use stack to load status 139a : 28 > plp 139b : bc1702 ldy abs1,x 139e : 08 php ;test stores do not alter flags 139f : 98 tya 13a0 : 49c3 eor #$c3 13a2 : a8 tay 13a3 : 28 plp 13a4 : 9402 sty zpt,x 13a6 : 08 php ;flags after load/store sequence 13a7 : 49c3 eor #$c3 13a9 : d509 cmp zp1,x ;test result trap_ne 13ab : d0fe > bne * ;failed not equal (non zero) 13ad : 68 pla ;load status eor_flag 0 13ae : 4930 > eor #0|fao ;invert expected flags + always on bits 13b0 : dd1c02 cmp fLDx,x ;test flags trap_ne 13b3 : d0fe > bne * ;failed not equal (non zero) 13b5 : ca dex 13b6 : 10df bpl tldy2 13b8 : a203 ldx #3 13ba : tldy3 set_stat $ff > load_flag $ff 13ba : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 13bc : 48 > pha ;use stack to load status 13bd : 28 > plp 13be : bc1702 ldy abs1,x 13c1 : 08 php ;test stores do not alter flags 13c2 : 98 tya 13c3 : 49c3 eor #$c3 13c5 : a8 tay 13c6 : 28 plp 13c7 : 9402 sty zpt,x 13c9 : 08 php ;flags after load/store sequence 13ca : 49c3 eor #$c3 13cc : d509 cmp zp1,x ;test result trap_ne 13ce : d0fe > bne * ;failed not equal (non zero) 13d0 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 13d1 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 13d3 : dd1c02 cmp fLDx,x ;test flags trap_ne 13d6 : d0fe > bne * ;failed not equal (non zero) 13d8 : ca dex 13d9 : 10df bpl tldy3 13db : a203 ldx #3 ;testing store result 13dd : a000 ldy #0 13df : b502 tsty lda zpt,x 13e1 : 49c3 eor #$c3 13e3 : d509 cmp zp1,x trap_ne ;store to zp,x data 13e5 : d0fe > bne * ;failed not equal (non zero) 13e7 : 9402 sty zpt,x ;clear 13e9 : bd0302 lda abst,x 13ec : 49c3 eor #$c3 13ee : dd1702 cmp abs1,x trap_ne ;store to abs,x data 13f1 : d0fe > bne * ;failed not equal (non zero) 13f3 : 8a txa 13f4 : 9d0302 sta abst,x ;clear 13f7 : ca dex 13f8 : 10e5 bpl tsty next_test 13fa : ad0002 > lda test_case ;previous test 13fd : c911 > cmp #test_num > trap_ne ;test is out of sequence 13ff : d0fe > bne * ;failed not equal (non zero) > 0012 = >test_num = test_num + 1 1401 : a912 > lda #test_num ;*** next tests' number 1403 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; indexed wraparound test (only zp should wrap) 1406 : a2fd ldx #3+$fa 1408 : b40f tldy4 ldy zp1-$fa&$ff,x ;wrap on indexed zp 140a : 98 tya 140b : 9d0901 sta abst-$fa,x ;no STX abs,x! 140e : ca dex 140f : e0fa cpx #$fa 1411 : b0f5 bcs tldy4 1413 : a2fd ldx #3+$fa 1415 : bc1d01 tldy5 ldy abs1-$fa,x ;no wrap on indexed abs 1418 : 9408 sty zpt-$fa&$ff,x 141a : ca dex 141b : e0fa cpx #$fa 141d : b0f6 bcs tldy5 141f : a203 ldx #3 ;testing wraparound result 1421 : a000 ldy #0 1423 : b502 tsty1 lda zpt,x 1425 : d509 cmp zp1,x trap_ne ;store to zp,x data 1427 : d0fe > bne * ;failed not equal (non zero) 1429 : 9402 sty zpt,x ;clear 142b : bd0302 lda abst,x 142e : dd1702 cmp abs1,x trap_ne ;store to abs,x data 1431 : d0fe > bne * ;failed not equal (non zero) 1433 : 8a txa 1434 : 9d0302 sta abst,x ;clear 1437 : ca dex 1438 : 10e9 bpl tsty1 next_test 143a : ad0002 > lda test_case ;previous test 143d : c912 > cmp #test_num > trap_ne ;test is out of sequence 143f : d0fe > bne * ;failed not equal (non zero) > 0013 = >test_num = test_num + 1 1441 : a913 > lda #test_num ;*** next tests' number 1443 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; LDX / STX - zp / abs / # set_stat 0 > load_flag 0 1446 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1448 : 48 > pha ;use stack to load status 1449 : 28 > plp 144a : a609 ldx zp1 144c : 08 php ;test stores do not alter flags 144d : 8a txa 144e : 49c3 eor #$c3 1450 : aa tax 1451 : 28 plp 1452 : 8e0302 stx abst 1455 : 08 php ;flags after load/store sequence 1456 : 49c3 eor #$c3 1458 : aa tax 1459 : e0c3 cpx #$c3 ;test result trap_ne 145b : d0fe > bne * ;failed not equal (non zero) 145d : 68 pla ;load status eor_flag 0 145e : 4930 > eor #0|fao ;invert expected flags + always on bits 1460 : cd1c02 cmp fLDx ;test flags trap_ne 1463 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1465 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1467 : 48 > pha ;use stack to load status 1468 : 28 > plp 1469 : a60a ldx zp1+1 146b : 08 php ;test stores do not alter flags 146c : 8a txa 146d : 49c3 eor #$c3 146f : aa tax 1470 : 28 plp 1471 : 8e0402 stx abst+1 1474 : 08 php ;flags after load/store sequence 1475 : 49c3 eor #$c3 1477 : aa tax 1478 : e082 cpx #$82 ;test result trap_ne 147a : d0fe > bne * ;failed not equal (non zero) 147c : 68 pla ;load status eor_flag 0 147d : 4930 > eor #0|fao ;invert expected flags + always on bits 147f : cd1d02 cmp fLDx+1 ;test flags trap_ne 1482 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1484 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1486 : 48 > pha ;use stack to load status 1487 : 28 > plp 1488 : a60b ldx zp1+2 148a : 08 php ;test stores do not alter flags 148b : 8a txa 148c : 49c3 eor #$c3 148e : aa tax 148f : 28 plp 1490 : 8e0502 stx abst+2 1493 : 08 php ;flags after load/store sequence 1494 : 49c3 eor #$c3 1496 : aa tax 1497 : e041 cpx #$41 ;test result trap_ne 1499 : d0fe > bne * ;failed not equal (non zero) 149b : 68 pla ;load status eor_flag 0 149c : 4930 > eor #0|fao ;invert expected flags + always on bits 149e : cd1e02 cmp fLDx+2 ;test flags trap_ne 14a1 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 14a3 : a900 > lda #0 ;allow test to change I-flag (no mask) > 14a5 : 48 > pha ;use stack to load status 14a6 : 28 > plp 14a7 : a60c ldx zp1+3 14a9 : 08 php ;test stores do not alter flags 14aa : 8a txa 14ab : 49c3 eor #$c3 14ad : aa tax 14ae : 28 plp 14af : 8e0602 stx abst+3 14b2 : 08 php ;flags after load/store sequence 14b3 : 49c3 eor #$c3 14b5 : aa tax 14b6 : e000 cpx #0 ;test result trap_ne 14b8 : d0fe > bne * ;failed not equal (non zero) 14ba : 68 pla ;load status eor_flag 0 14bb : 4930 > eor #0|fao ;invert expected flags + always on bits 14bd : cd1f02 cmp fLDx+3 ;test flags trap_ne 14c0 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 14c2 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 14c4 : 48 > pha ;use stack to load status 14c5 : 28 > plp 14c6 : a609 ldx zp1 14c8 : 08 php ;test stores do not alter flags 14c9 : 8a txa 14ca : 49c3 eor #$c3 14cc : aa tax 14cd : 28 plp 14ce : 8e0302 stx abst 14d1 : 08 php ;flags after load/store sequence 14d2 : 49c3 eor #$c3 14d4 : aa tax 14d5 : e0c3 cpx #$c3 ;test result trap_ne ; 14d7 : d0fe > bne * ;failed not equal (non zero) 14d9 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 14da : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 14dc : cd1c02 cmp fLDx ;test flags trap_ne 14df : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 14e1 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 14e3 : 48 > pha ;use stack to load status 14e4 : 28 > plp 14e5 : a60a ldx zp1+1 14e7 : 08 php ;test stores do not alter flags 14e8 : 8a txa 14e9 : 49c3 eor #$c3 14eb : aa tax 14ec : 28 plp 14ed : 8e0402 stx abst+1 14f0 : 08 php ;flags after load/store sequence 14f1 : 49c3 eor #$c3 14f3 : aa tax 14f4 : e082 cpx #$82 ;test result trap_ne 14f6 : d0fe > bne * ;failed not equal (non zero) 14f8 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 14f9 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 14fb : cd1d02 cmp fLDx+1 ;test flags trap_ne 14fe : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1500 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1502 : 48 > pha ;use stack to load status 1503 : 28 > plp 1504 : a60b ldx zp1+2 1506 : 08 php ;test stores do not alter flags 1507 : 8a txa 1508 : 49c3 eor #$c3 150a : aa tax 150b : 28 plp 150c : 8e0502 stx abst+2 150f : 08 php ;flags after load/store sequence 1510 : 49c3 eor #$c3 1512 : aa tax 1513 : e041 cpx #$41 ;test result trap_ne ; 1515 : d0fe > bne * ;failed not equal (non zero) 1517 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1518 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 151a : cd1e02 cmp fLDx+2 ;test flags trap_ne 151d : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 151f : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1521 : 48 > pha ;use stack to load status 1522 : 28 > plp 1523 : a60c ldx zp1+3 1525 : 08 php ;test stores do not alter flags 1526 : 8a txa 1527 : 49c3 eor #$c3 1529 : aa tax 152a : 28 plp 152b : 8e0602 stx abst+3 152e : 08 php ;flags after load/store sequence 152f : 49c3 eor #$c3 1531 : aa tax 1532 : e000 cpx #0 ;test result trap_ne 1534 : d0fe > bne * ;failed not equal (non zero) 1536 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1537 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1539 : cd1f02 cmp fLDx+3 ;test flags trap_ne 153c : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 153e : a900 > lda #0 ;allow test to change I-flag (no mask) > 1540 : 48 > pha ;use stack to load status 1541 : 28 > plp 1542 : ae1702 ldx abs1 1545 : 08 php ;test stores do not alter flags 1546 : 8a txa 1547 : 49c3 eor #$c3 1549 : aa tax 154a : 28 plp 154b : 8602 stx zpt 154d : 08 php ;flags after load/store sequence 154e : 49c3 eor #$c3 1550 : c509 cmp zp1 ;test result trap_ne 1552 : d0fe > bne * ;failed not equal (non zero) 1554 : 68 pla ;load status eor_flag 0 1555 : 4930 > eor #0|fao ;invert expected flags + always on bits 1557 : cd1c02 cmp fLDx ;test flags trap_ne 155a : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 155c : a900 > lda #0 ;allow test to change I-flag (no mask) > 155e : 48 > pha ;use stack to load status 155f : 28 > plp 1560 : ae1802 ldx abs1+1 1563 : 08 php ;test stores do not alter flags 1564 : 8a txa 1565 : 49c3 eor #$c3 1567 : aa tax 1568 : 28 plp 1569 : 8603 stx zpt+1 156b : 08 php ;flags after load/store sequence 156c : 49c3 eor #$c3 156e : c50a cmp zp1+1 ;test result trap_ne 1570 : d0fe > bne * ;failed not equal (non zero) 1572 : 68 pla ;load status eor_flag 0 1573 : 4930 > eor #0|fao ;invert expected flags + always on bits 1575 : cd1d02 cmp fLDx+1 ;test flags trap_ne 1578 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 157a : a900 > lda #0 ;allow test to change I-flag (no mask) > 157c : 48 > pha ;use stack to load status 157d : 28 > plp 157e : ae1902 ldx abs1+2 1581 : 08 php ;test stores do not alter flags 1582 : 8a txa 1583 : 49c3 eor #$c3 1585 : aa tax 1586 : 28 plp 1587 : 8604 stx zpt+2 1589 : 08 php ;flags after load/store sequence 158a : 49c3 eor #$c3 158c : c50b cmp zp1+2 ;test result trap_ne 158e : d0fe > bne * ;failed not equal (non zero) 1590 : 68 pla ;load status eor_flag 0 1591 : 4930 > eor #0|fao ;invert expected flags + always on bits 1593 : cd1e02 cmp fLDx+2 ;test flags trap_ne 1596 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1598 : a900 > lda #0 ;allow test to change I-flag (no mask) > 159a : 48 > pha ;use stack to load status 159b : 28 > plp 159c : ae1a02 ldx abs1+3 159f : 08 php ;test stores do not alter flags 15a0 : 8a txa 15a1 : 49c3 eor #$c3 15a3 : aa tax 15a4 : 28 plp 15a5 : 8605 stx zpt+3 15a7 : 08 php ;flags after load/store sequence 15a8 : 49c3 eor #$c3 15aa : c50c cmp zp1+3 ;test result trap_ne 15ac : d0fe > bne * ;failed not equal (non zero) 15ae : 68 pla ;load status eor_flag 0 15af : 4930 > eor #0|fao ;invert expected flags + always on bits 15b1 : cd1f02 cmp fLDx+3 ;test flags trap_ne 15b4 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 15b6 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 15b8 : 48 > pha ;use stack to load status 15b9 : 28 > plp 15ba : ae1702 ldx abs1 15bd : 08 php ;test stores do not alter flags 15be : 8a txa 15bf : 49c3 eor #$c3 15c1 : aa tax 15c2 : 28 plp 15c3 : 8602 stx zpt 15c5 : 08 php ;flags after load/store sequence 15c6 : 49c3 eor #$c3 15c8 : aa tax 15c9 : e409 cpx zp1 ;test result trap_ne 15cb : d0fe > bne * ;failed not equal (non zero) 15cd : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 15ce : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 15d0 : cd1c02 cmp fLDx ;test flags trap_ne 15d3 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 15d5 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 15d7 : 48 > pha ;use stack to load status 15d8 : 28 > plp 15d9 : ae1802 ldx abs1+1 15dc : 08 php ;test stores do not alter flags 15dd : 8a txa 15de : 49c3 eor #$c3 15e0 : aa tax 15e1 : 28 plp 15e2 : 8603 stx zpt+1 15e4 : 08 php ;flags after load/store sequence 15e5 : 49c3 eor #$c3 15e7 : aa tax 15e8 : e40a cpx zp1+1 ;test result trap_ne 15ea : d0fe > bne * ;failed not equal (non zero) 15ec : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 15ed : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 15ef : cd1d02 cmp fLDx+1 ;test flags trap_ne 15f2 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 15f4 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 15f6 : 48 > pha ;use stack to load status 15f7 : 28 > plp 15f8 : ae1902 ldx abs1+2 15fb : 08 php ;test stores do not alter flags 15fc : 8a txa 15fd : 49c3 eor #$c3 15ff : aa tax 1600 : 28 plp 1601 : 8604 stx zpt+2 1603 : 08 php ;flags after load/store sequence 1604 : 49c3 eor #$c3 1606 : aa tax 1607 : e40b cpx zp1+2 ;test result trap_ne 1609 : d0fe > bne * ;failed not equal (non zero) 160b : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 160c : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 160e : cd1e02 cmp fLDx+2 ;test flags trap_ne 1611 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1613 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1615 : 48 > pha ;use stack to load status 1616 : 28 > plp 1617 : ae1a02 ldx abs1+3 161a : 08 php ;test stores do not alter flags 161b : 8a txa 161c : 49c3 eor #$c3 161e : aa tax 161f : 28 plp 1620 : 8605 stx zpt+3 1622 : 08 php ;flags after load/store sequence 1623 : 49c3 eor #$c3 1625 : aa tax 1626 : e40c cpx zp1+3 ;test result trap_ne 1628 : d0fe > bne * ;failed not equal (non zero) 162a : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 162b : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 162d : cd1f02 cmp fLDx+3 ;test flags trap_ne 1630 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1632 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1634 : 48 > pha ;use stack to load status 1635 : 28 > plp 1636 : a2c3 ldx #$c3 1638 : 08 php 1639 : ec1702 cpx abs1 ;test result trap_ne 163c : d0fe > bne * ;failed not equal (non zero) 163e : 68 pla ;load status eor_flag 0 163f : 4930 > eor #0|fao ;invert expected flags + always on bits 1641 : cd1c02 cmp fLDx ;test flags trap_ne 1644 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1646 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1648 : 48 > pha ;use stack to load status 1649 : 28 > plp 164a : a282 ldx #$82 164c : 08 php 164d : ec1802 cpx abs1+1 ;test result trap_ne 1650 : d0fe > bne * ;failed not equal (non zero) 1652 : 68 pla ;load status eor_flag 0 1653 : 4930 > eor #0|fao ;invert expected flags + always on bits 1655 : cd1d02 cmp fLDx+1 ;test flags trap_ne 1658 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 165a : a900 > lda #0 ;allow test to change I-flag (no mask) > 165c : 48 > pha ;use stack to load status 165d : 28 > plp 165e : a241 ldx #$41 1660 : 08 php 1661 : ec1902 cpx abs1+2 ;test result trap_ne 1664 : d0fe > bne * ;failed not equal (non zero) 1666 : 68 pla ;load status eor_flag 0 1667 : 4930 > eor #0|fao ;invert expected flags + always on bits 1669 : cd1e02 cmp fLDx+2 ;test flags trap_ne 166c : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 166e : a900 > lda #0 ;allow test to change I-flag (no mask) > 1670 : 48 > pha ;use stack to load status 1671 : 28 > plp 1672 : a200 ldx #0 1674 : 08 php 1675 : ec1a02 cpx abs1+3 ;test result trap_ne 1678 : d0fe > bne * ;failed not equal (non zero) 167a : 68 pla ;load status eor_flag 0 167b : 4930 > eor #0|fao ;invert expected flags + always on bits 167d : cd1f02 cmp fLDx+3 ;test flags trap_ne 1680 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1682 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1684 : 48 > pha ;use stack to load status 1685 : 28 > plp 1686 : a2c3 ldx #$c3 1688 : 08 php 1689 : ec1702 cpx abs1 ;test result trap_ne 168c : d0fe > bne * ;failed not equal (non zero) 168e : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 168f : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1691 : cd1c02 cmp fLDx ;test flags trap_ne 1694 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1696 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1698 : 48 > pha ;use stack to load status 1699 : 28 > plp 169a : a282 ldx #$82 169c : 08 php 169d : ec1802 cpx abs1+1 ;test result trap_ne 16a0 : d0fe > bne * ;failed not equal (non zero) 16a2 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 16a3 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 16a5 : cd1d02 cmp fLDx+1 ;test flags trap_ne 16a8 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 16aa : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 16ac : 48 > pha ;use stack to load status 16ad : 28 > plp 16ae : a241 ldx #$41 16b0 : 08 php 16b1 : ec1902 cpx abs1+2 ;test result trap_ne 16b4 : d0fe > bne * ;failed not equal (non zero) 16b6 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 16b7 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 16b9 : cd1e02 cmp fLDx+2 ;test flags trap_ne 16bc : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 16be : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 16c0 : 48 > pha ;use stack to load status 16c1 : 28 > plp 16c2 : a200 ldx #0 16c4 : 08 php 16c5 : ec1a02 cpx abs1+3 ;test result trap_ne 16c8 : d0fe > bne * ;failed not equal (non zero) 16ca : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 16cb : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 16cd : cd1f02 cmp fLDx+3 ;test flags trap_ne 16d0 : d0fe > bne * ;failed not equal (non zero) 16d2 : a200 ldx #0 16d4 : a502 lda zpt 16d6 : 49c3 eor #$c3 16d8 : c509 cmp zp1 trap_ne ;store to zp data 16da : d0fe > bne * ;failed not equal (non zero) 16dc : 8602 stx zpt ;clear 16de : ad0302 lda abst 16e1 : 49c3 eor #$c3 16e3 : cd1702 cmp abs1 trap_ne ;store to abs data 16e6 : d0fe > bne * ;failed not equal (non zero) 16e8 : 8e0302 stx abst ;clear 16eb : a503 lda zpt+1 16ed : 49c3 eor #$c3 16ef : c50a cmp zp1+1 trap_ne ;store to zp data 16f1 : d0fe > bne * ;failed not equal (non zero) 16f3 : 8603 stx zpt+1 ;clear 16f5 : ad0402 lda abst+1 16f8 : 49c3 eor #$c3 16fa : cd1802 cmp abs1+1 trap_ne ;store to abs data 16fd : d0fe > bne * ;failed not equal (non zero) 16ff : 8e0402 stx abst+1 ;clear 1702 : a504 lda zpt+2 1704 : 49c3 eor #$c3 1706 : c50b cmp zp1+2 trap_ne ;store to zp data 1708 : d0fe > bne * ;failed not equal (non zero) 170a : 8604 stx zpt+2 ;clear 170c : ad0502 lda abst+2 170f : 49c3 eor #$c3 1711 : cd1902 cmp abs1+2 trap_ne ;store to abs data 1714 : d0fe > bne * ;failed not equal (non zero) 1716 : 8e0502 stx abst+2 ;clear 1719 : a505 lda zpt+3 171b : 49c3 eor #$c3 171d : c50c cmp zp1+3 trap_ne ;store to zp data 171f : d0fe > bne * ;failed not equal (non zero) 1721 : 8605 stx zpt+3 ;clear 1723 : ad0602 lda abst+3 1726 : 49c3 eor #$c3 1728 : cd1a02 cmp abs1+3 trap_ne ;store to abs data 172b : d0fe > bne * ;failed not equal (non zero) 172d : 8e0602 stx abst+3 ;clear next_test 1730 : ad0002 > lda test_case ;previous test 1733 : c913 > cmp #test_num > trap_ne ;test is out of sequence 1735 : d0fe > bne * ;failed not equal (non zero) > 0014 = >test_num = test_num + 1 1737 : a914 > lda #test_num ;*** next tests' number 1739 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; LDY / STY - zp / abs / # set_stat 0 > load_flag 0 173c : a900 > lda #0 ;allow test to change I-flag (no mask) > 173e : 48 > pha ;use stack to load status 173f : 28 > plp 1740 : a409 ldy zp1 1742 : 08 php ;test stores do not alter flags 1743 : 98 tya 1744 : 49c3 eor #$c3 1746 : a8 tay 1747 : 28 plp 1748 : 8c0302 sty abst 174b : 08 php ;flags after load/store sequence 174c : 49c3 eor #$c3 174e : a8 tay 174f : c0c3 cpy #$c3 ;test result trap_ne 1751 : d0fe > bne * ;failed not equal (non zero) 1753 : 68 pla ;load status eor_flag 0 1754 : 4930 > eor #0|fao ;invert expected flags + always on bits 1756 : cd1c02 cmp fLDx ;test flags trap_ne 1759 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 175b : a900 > lda #0 ;allow test to change I-flag (no mask) > 175d : 48 > pha ;use stack to load status 175e : 28 > plp 175f : a40a ldy zp1+1 1761 : 08 php ;test stores do not alter flags 1762 : 98 tya 1763 : 49c3 eor #$c3 1765 : a8 tay 1766 : 28 plp 1767 : 8c0402 sty abst+1 176a : 08 php ;flags after load/store sequence 176b : 49c3 eor #$c3 176d : a8 tay 176e : c082 cpy #$82 ;test result trap_ne 1770 : d0fe > bne * ;failed not equal (non zero) 1772 : 68 pla ;load status eor_flag 0 1773 : 4930 > eor #0|fao ;invert expected flags + always on bits 1775 : cd1d02 cmp fLDx+1 ;test flags trap_ne 1778 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 177a : a900 > lda #0 ;allow test to change I-flag (no mask) > 177c : 48 > pha ;use stack to load status 177d : 28 > plp 177e : a40b ldy zp1+2 1780 : 08 php ;test stores do not alter flags 1781 : 98 tya 1782 : 49c3 eor #$c3 1784 : a8 tay 1785 : 28 plp 1786 : 8c0502 sty abst+2 1789 : 08 php ;flags after load/store sequence 178a : 49c3 eor #$c3 178c : a8 tay 178d : c041 cpy #$41 ;test result trap_ne 178f : d0fe > bne * ;failed not equal (non zero) 1791 : 68 pla ;load status eor_flag 0 1792 : 4930 > eor #0|fao ;invert expected flags + always on bits 1794 : cd1e02 cmp fLDx+2 ;test flags trap_ne 1797 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1799 : a900 > lda #0 ;allow test to change I-flag (no mask) > 179b : 48 > pha ;use stack to load status 179c : 28 > plp 179d : a40c ldy zp1+3 179f : 08 php ;test stores do not alter flags 17a0 : 98 tya 17a1 : 49c3 eor #$c3 17a3 : a8 tay 17a4 : 28 plp 17a5 : 8c0602 sty abst+3 17a8 : 08 php ;flags after load/store sequence 17a9 : 49c3 eor #$c3 17ab : a8 tay 17ac : c000 cpy #0 ;test result trap_ne 17ae : d0fe > bne * ;failed not equal (non zero) 17b0 : 68 pla ;load status eor_flag 0 17b1 : 4930 > eor #0|fao ;invert expected flags + always on bits 17b3 : cd1f02 cmp fLDx+3 ;test flags trap_ne 17b6 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 17b8 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 17ba : 48 > pha ;use stack to load status 17bb : 28 > plp 17bc : a409 ldy zp1 17be : 08 php ;test stores do not alter flags 17bf : 98 tya 17c0 : 49c3 eor #$c3 17c2 : a8 tay 17c3 : 28 plp 17c4 : 8c0302 sty abst 17c7 : 08 php ;flags after load/store sequence 17c8 : 49c3 eor #$c3 17ca : a8 tay 17cb : c0c3 cpy #$c3 ;test result trap_ne 17cd : d0fe > bne * ;failed not equal (non zero) 17cf : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 17d0 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 17d2 : cd1c02 cmp fLDx ;test flags trap_ne 17d5 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 17d7 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 17d9 : 48 > pha ;use stack to load status 17da : 28 > plp 17db : a40a ldy zp1+1 17dd : 08 php ;test stores do not alter flags 17de : 98 tya 17df : 49c3 eor #$c3 17e1 : a8 tay 17e2 : 28 plp 17e3 : 8c0402 sty abst+1 17e6 : 08 php ;flags after load/store sequence 17e7 : 49c3 eor #$c3 17e9 : a8 tay 17ea : c082 cpy #$82 ;test result trap_ne 17ec : d0fe > bne * ;failed not equal (non zero) 17ee : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 17ef : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 17f1 : cd1d02 cmp fLDx+1 ;test flags trap_ne 17f4 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 17f6 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 17f8 : 48 > pha ;use stack to load status 17f9 : 28 > plp 17fa : a40b ldy zp1+2 17fc : 08 php ;test stores do not alter flags 17fd : 98 tya 17fe : 49c3 eor #$c3 1800 : a8 tay 1801 : 28 plp 1802 : 8c0502 sty abst+2 1805 : 08 php ;flags after load/store sequence 1806 : 49c3 eor #$c3 1808 : a8 tay 1809 : c041 cpy #$41 ;test result trap_ne 180b : d0fe > bne * ;failed not equal (non zero) 180d : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 180e : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1810 : cd1e02 cmp fLDx+2 ;test flags trap_ne 1813 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1815 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1817 : 48 > pha ;use stack to load status 1818 : 28 > plp 1819 : a40c ldy zp1+3 181b : 08 php ;test stores do not alter flags 181c : 98 tya 181d : 49c3 eor #$c3 181f : a8 tay 1820 : 28 plp 1821 : 8c0602 sty abst+3 1824 : 08 php ;flags after load/store sequence 1825 : 49c3 eor #$c3 1827 : a8 tay 1828 : c000 cpy #0 ;test result trap_ne 182a : d0fe > bne * ;failed not equal (non zero) 182c : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 182d : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 182f : cd1f02 cmp fLDx+3 ;test flags trap_ne 1832 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1834 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1836 : 48 > pha ;use stack to load status 1837 : 28 > plp 1838 : ac1702 ldy abs1 183b : 08 php ;test stores do not alter flags 183c : 98 tya 183d : 49c3 eor #$c3 183f : a8 tay 1840 : 28 plp 1841 : 8402 sty zpt 1843 : 08 php ;flags after load/store sequence 1844 : 49c3 eor #$c3 1846 : a8 tay 1847 : c409 cpy zp1 ;test result trap_ne 1849 : d0fe > bne * ;failed not equal (non zero) 184b : 68 pla ;load status eor_flag 0 184c : 4930 > eor #0|fao ;invert expected flags + always on bits 184e : cd1c02 cmp fLDx ;test flags trap_ne 1851 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1853 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1855 : 48 > pha ;use stack to load status 1856 : 28 > plp 1857 : ac1802 ldy abs1+1 185a : 08 php ;test stores do not alter flags 185b : 98 tya 185c : 49c3 eor #$c3 185e : a8 tay 185f : 28 plp 1860 : 8403 sty zpt+1 1862 : 08 php ;flags after load/store sequence 1863 : 49c3 eor #$c3 1865 : a8 tay 1866 : c40a cpy zp1+1 ;test result trap_ne 1868 : d0fe > bne * ;failed not equal (non zero) 186a : 68 pla ;load status eor_flag 0 186b : 4930 > eor #0|fao ;invert expected flags + always on bits 186d : cd1d02 cmp fLDx+1 ;test flags trap_ne 1870 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1872 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1874 : 48 > pha ;use stack to load status 1875 : 28 > plp 1876 : ac1902 ldy abs1+2 1879 : 08 php ;test stores do not alter flags 187a : 98 tya 187b : 49c3 eor #$c3 187d : a8 tay 187e : 28 plp 187f : 8404 sty zpt+2 1881 : 08 php ;flags after load/store sequence 1882 : 49c3 eor #$c3 1884 : a8 tay 1885 : c40b cpy zp1+2 ;test result trap_ne 1887 : d0fe > bne * ;failed not equal (non zero) 1889 : 68 pla ;load status eor_flag 0 188a : 4930 > eor #0|fao ;invert expected flags + always on bits 188c : cd1e02 cmp fLDx+2 ;test flags trap_ne 188f : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1891 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1893 : 48 > pha ;use stack to load status 1894 : 28 > plp 1895 : ac1a02 ldy abs1+3 1898 : 08 php ;test stores do not alter flags 1899 : 98 tya 189a : 49c3 eor #$c3 189c : a8 tay 189d : 28 plp 189e : 8405 sty zpt+3 18a0 : 08 php ;flags after load/store sequence 18a1 : 49c3 eor #$c3 18a3 : a8 tay 18a4 : c40c cpy zp1+3 ;test result trap_ne 18a6 : d0fe > bne * ;failed not equal (non zero) 18a8 : 68 pla ;load status eor_flag 0 18a9 : 4930 > eor #0|fao ;invert expected flags + always on bits 18ab : cd1f02 cmp fLDx+3 ;test flags trap_ne 18ae : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 18b0 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 18b2 : 48 > pha ;use stack to load status 18b3 : 28 > plp 18b4 : ac1702 ldy abs1 18b7 : 08 php ;test stores do not alter flags 18b8 : 98 tya 18b9 : 49c3 eor #$c3 18bb : a8 tay 18bc : 28 plp 18bd : 8402 sty zpt 18bf : 08 php ;flags after load/store sequence 18c0 : 49c3 eor #$c3 18c2 : a8 tay 18c3 : c509 cmp zp1 ;test result trap_ne 18c5 : d0fe > bne * ;failed not equal (non zero) 18c7 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 18c8 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 18ca : cd1c02 cmp fLDx ;test flags trap_ne 18cd : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 18cf : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 18d1 : 48 > pha ;use stack to load status 18d2 : 28 > plp 18d3 : ac1802 ldy abs1+1 18d6 : 08 php ;test stores do not alter flags 18d7 : 98 tya 18d8 : 49c3 eor #$c3 18da : a8 tay 18db : 28 plp 18dc : 8403 sty zpt+1 18de : 08 php ;flags after load/store sequence 18df : 49c3 eor #$c3 18e1 : a8 tay 18e2 : c50a cmp zp1+1 ;test result trap_ne 18e4 : d0fe > bne * ;failed not equal (non zero) 18e6 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 18e7 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 18e9 : cd1d02 cmp fLDx+1 ;test flags trap_ne 18ec : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 18ee : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 18f0 : 48 > pha ;use stack to load status 18f1 : 28 > plp 18f2 : ac1902 ldy abs1+2 18f5 : 08 php ;test stores do not alter flags 18f6 : 98 tya 18f7 : 49c3 eor #$c3 18f9 : a8 tay 18fa : 28 plp 18fb : 8404 sty zpt+2 18fd : 08 php ;flags after load/store sequence 18fe : 49c3 eor #$c3 1900 : a8 tay 1901 : c50b cmp zp1+2 ;test result trap_ne 1903 : d0fe > bne * ;failed not equal (non zero) 1905 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1906 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1908 : cd1e02 cmp fLDx+2 ;test flags trap_ne 190b : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 190d : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 190f : 48 > pha ;use stack to load status 1910 : 28 > plp 1911 : ac1a02 ldy abs1+3 1914 : 08 php ;test stores do not alter flags 1915 : 98 tya 1916 : 49c3 eor #$c3 1918 : a8 tay 1919 : 28 plp 191a : 8405 sty zpt+3 191c : 08 php ;flags after load/store sequence 191d : 49c3 eor #$c3 191f : a8 tay 1920 : c50c cmp zp1+3 ;test result trap_ne 1922 : d0fe > bne * ;failed not equal (non zero) 1924 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1925 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1927 : cd1f02 cmp fLDx+3 ;test flags trap_ne 192a : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 192c : a900 > lda #0 ;allow test to change I-flag (no mask) > 192e : 48 > pha ;use stack to load status 192f : 28 > plp 1930 : a0c3 ldy #$c3 1932 : 08 php 1933 : cc1702 cpy abs1 ;test result trap_ne 1936 : d0fe > bne * ;failed not equal (non zero) 1938 : 68 pla ;load status eor_flag 0 1939 : 4930 > eor #0|fao ;invert expected flags + always on bits 193b : cd1c02 cmp fLDx ;test flags trap_ne 193e : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1940 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1942 : 48 > pha ;use stack to load status 1943 : 28 > plp 1944 : a082 ldy #$82 1946 : 08 php 1947 : cc1802 cpy abs1+1 ;test result trap_ne 194a : d0fe > bne * ;failed not equal (non zero) 194c : 68 pla ;load status eor_flag 0 194d : 4930 > eor #0|fao ;invert expected flags + always on bits 194f : cd1d02 cmp fLDx+1 ;test flags trap_ne 1952 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1954 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1956 : 48 > pha ;use stack to load status 1957 : 28 > plp 1958 : a041 ldy #$41 195a : 08 php 195b : cc1902 cpy abs1+2 ;test result trap_ne 195e : d0fe > bne * ;failed not equal (non zero) 1960 : 68 pla ;load status eor_flag 0 1961 : 4930 > eor #0|fao ;invert expected flags + always on bits 1963 : cd1e02 cmp fLDx+2 ;test flags trap_ne 1966 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1968 : a900 > lda #0 ;allow test to change I-flag (no mask) > 196a : 48 > pha ;use stack to load status 196b : 28 > plp 196c : a000 ldy #0 196e : 08 php 196f : cc1a02 cpy abs1+3 ;test result trap_ne 1972 : d0fe > bne * ;failed not equal (non zero) 1974 : 68 pla ;load status eor_flag 0 1975 : 4930 > eor #0|fao ;invert expected flags + always on bits 1977 : cd1f02 cmp fLDx+3 ;test flags trap_ne 197a : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 197c : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 197e : 48 > pha ;use stack to load status 197f : 28 > plp 1980 : a0c3 ldy #$c3 1982 : 08 php 1983 : cc1702 cpy abs1 ;test result trap_ne 1986 : d0fe > bne * ;failed not equal (non zero) 1988 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1989 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 198b : cd1c02 cmp fLDx ;test flags trap_ne 198e : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1990 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1992 : 48 > pha ;use stack to load status 1993 : 28 > plp 1994 : a082 ldy #$82 1996 : 08 php 1997 : cc1802 cpy abs1+1 ;test result trap_ne 199a : d0fe > bne * ;failed not equal (non zero) 199c : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 199d : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 199f : cd1d02 cmp fLDx+1 ;test flags trap_ne 19a2 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 19a4 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 19a6 : 48 > pha ;use stack to load status 19a7 : 28 > plp 19a8 : a041 ldy #$41 19aa : 08 php 19ab : cc1902 cpy abs1+2 ;test result trap_ne 19ae : d0fe > bne * ;failed not equal (non zero) 19b0 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 19b1 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 19b3 : cd1e02 cmp fLDx+2 ;test flags trap_ne 19b6 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 19b8 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 19ba : 48 > pha ;use stack to load status 19bb : 28 > plp 19bc : a000 ldy #0 19be : 08 php 19bf : cc1a02 cpy abs1+3 ;test result trap_ne 19c2 : d0fe > bne * ;failed not equal (non zero) 19c4 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 19c5 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 19c7 : cd1f02 cmp fLDx+3 ;test flags trap_ne 19ca : d0fe > bne * ;failed not equal (non zero) 19cc : a000 ldy #0 19ce : a502 lda zpt 19d0 : 49c3 eor #$c3 19d2 : c509 cmp zp1 trap_ne ;store to zp data 19d4 : d0fe > bne * ;failed not equal (non zero) 19d6 : 8402 sty zpt ;clear 19d8 : ad0302 lda abst 19db : 49c3 eor #$c3 19dd : cd1702 cmp abs1 trap_ne ;store to abs data 19e0 : d0fe > bne * ;failed not equal (non zero) 19e2 : 8c0302 sty abst ;clear 19e5 : a503 lda zpt+1 19e7 : 49c3 eor #$c3 19e9 : c50a cmp zp1+1 trap_ne ;store to zp+1 data 19eb : d0fe > bne * ;failed not equal (non zero) 19ed : 8403 sty zpt+1 ;clear 19ef : ad0402 lda abst+1 19f2 : 49c3 eor #$c3 19f4 : cd1802 cmp abs1+1 trap_ne ;store to abs+1 data 19f7 : d0fe > bne * ;failed not equal (non zero) 19f9 : 8c0402 sty abst+1 ;clear 19fc : a504 lda zpt+2 19fe : 49c3 eor #$c3 1a00 : c50b cmp zp1+2 trap_ne ;store to zp+2 data 1a02 : d0fe > bne * ;failed not equal (non zero) 1a04 : 8404 sty zpt+2 ;clear 1a06 : ad0502 lda abst+2 1a09 : 49c3 eor #$c3 1a0b : cd1902 cmp abs1+2 trap_ne ;store to abs+2 data 1a0e : d0fe > bne * ;failed not equal (non zero) 1a10 : 8c0502 sty abst+2 ;clear 1a13 : a505 lda zpt+3 1a15 : 49c3 eor #$c3 1a17 : c50c cmp zp1+3 trap_ne ;store to zp+3 data 1a19 : d0fe > bne * ;failed not equal (non zero) 1a1b : 8405 sty zpt+3 ;clear 1a1d : ad0602 lda abst+3 1a20 : 49c3 eor #$c3 1a22 : cd1a02 cmp abs1+3 trap_ne ;store to abs+3 data 1a25 : d0fe > bne * ;failed not equal (non zero) 1a27 : 8c0602 sty abst+3 ;clear next_test 1a2a : ad0002 > lda test_case ;previous test 1a2d : c914 > cmp #test_num > trap_ne ;test is out of sequence 1a2f : d0fe > bne * ;failed not equal (non zero) > 0015 = >test_num = test_num + 1 1a31 : a915 > lda #test_num ;*** next tests' number 1a33 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; testing load / store accumulator LDA / STA all addressing modes ; LDA / STA - zp,x / abs,x 1a36 : a203 ldx #3 1a38 : tldax set_stat 0 > load_flag 0 1a38 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1a3a : 48 > pha ;use stack to load status 1a3b : 28 > plp 1a3c : b509 lda zp1,x 1a3e : 08 php ;test stores do not alter flags 1a3f : 49c3 eor #$c3 1a41 : 28 plp 1a42 : 9d0302 sta abst,x 1a45 : 08 php ;flags after load/store sequence 1a46 : 49c3 eor #$c3 1a48 : dd1702 cmp abs1,x ;test result trap_ne 1a4b : d0fe > bne * ;failed not equal (non zero) 1a4d : 68 pla ;load status eor_flag 0 1a4e : 4930 > eor #0|fao ;invert expected flags + always on bits 1a50 : dd1c02 cmp fLDx,x ;test flags trap_ne 1a53 : d0fe > bne * ;failed not equal (non zero) 1a55 : ca dex 1a56 : 10e0 bpl tldax 1a58 : a203 ldx #3 1a5a : tldax1 set_stat $ff > load_flag $ff 1a5a : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1a5c : 48 > pha ;use stack to load status 1a5d : 28 > plp 1a5e : b509 lda zp1,x 1a60 : 08 php ;test stores do not alter flags 1a61 : 49c3 eor #$c3 1a63 : 28 plp 1a64 : 9d0302 sta abst,x 1a67 : 08 php ;flags after load/store sequence 1a68 : 49c3 eor #$c3 1a6a : dd1702 cmp abs1,x ;test result trap_ne 1a6d : d0fe > bne * ;failed not equal (non zero) 1a6f : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1a70 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1a72 : dd1c02 cmp fLDx,x ;test flags trap_ne 1a75 : d0fe > bne * ;failed not equal (non zero) 1a77 : ca dex 1a78 : 10e0 bpl tldax1 1a7a : a203 ldx #3 1a7c : tldax2 set_stat 0 > load_flag 0 1a7c : a900 > lda #0 ;allow test to change I-flag (no mask) > 1a7e : 48 > pha ;use stack to load status 1a7f : 28 > plp 1a80 : bd1702 lda abs1,x 1a83 : 08 php ;test stores do not alter flags 1a84 : 49c3 eor #$c3 1a86 : 28 plp 1a87 : 9502 sta zpt,x 1a89 : 08 php ;flags after load/store sequence 1a8a : 49c3 eor #$c3 1a8c : d509 cmp zp1,x ;test result trap_ne 1a8e : d0fe > bne * ;failed not equal (non zero) 1a90 : 68 pla ;load status eor_flag 0 1a91 : 4930 > eor #0|fao ;invert expected flags + always on bits 1a93 : dd1c02 cmp fLDx,x ;test flags trap_ne 1a96 : d0fe > bne * ;failed not equal (non zero) 1a98 : ca dex 1a99 : 10e1 bpl tldax2 1a9b : a203 ldx #3 1a9d : tldax3 set_stat $ff > load_flag $ff 1a9d : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1a9f : 48 > pha ;use stack to load status 1aa0 : 28 > plp 1aa1 : bd1702 lda abs1,x 1aa4 : 08 php ;test stores do not alter flags 1aa5 : 49c3 eor #$c3 1aa7 : 28 plp 1aa8 : 9502 sta zpt,x 1aaa : 08 php ;flags after load/store sequence 1aab : 49c3 eor #$c3 1aad : d509 cmp zp1,x ;test result trap_ne 1aaf : d0fe > bne * ;failed not equal (non zero) 1ab1 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1ab2 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1ab4 : dd1c02 cmp fLDx,x ;test flags trap_ne 1ab7 : d0fe > bne * ;failed not equal (non zero) 1ab9 : ca dex 1aba : 10e1 bpl tldax3 1abc : a203 ldx #3 ;testing store result 1abe : a000 ldy #0 1ac0 : b502 tstax lda zpt,x 1ac2 : 49c3 eor #$c3 1ac4 : d509 cmp zp1,x trap_ne ;store to zp,x data 1ac6 : d0fe > bne * ;failed not equal (non zero) 1ac8 : 9402 sty zpt,x ;clear 1aca : bd0302 lda abst,x 1acd : 49c3 eor #$c3 1acf : dd1702 cmp abs1,x trap_ne ;store to abs,x data 1ad2 : d0fe > bne * ;failed not equal (non zero) 1ad4 : 8a txa 1ad5 : 9d0302 sta abst,x ;clear 1ad8 : ca dex 1ad9 : 10e5 bpl tstax next_test 1adb : ad0002 > lda test_case ;previous test 1ade : c915 > cmp #test_num > trap_ne ;test is out of sequence 1ae0 : d0fe > bne * ;failed not equal (non zero) > 0016 = >test_num = test_num + 1 1ae2 : a916 > lda #test_num ;*** next tests' number 1ae4 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; LDA / STA - (zp),y / abs,y / (zp,x) 1ae7 : a003 ldy #3 1ae9 : tlday set_stat 0 > load_flag 0 1ae9 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1aeb : 48 > pha ;use stack to load status 1aec : 28 > plp 1aed : b11a lda (ind1),y 1aef : 08 php ;test stores do not alter flags 1af0 : 49c3 eor #$c3 1af2 : 28 plp 1af3 : 990302 sta abst,y 1af6 : 08 php ;flags after load/store sequence 1af7 : 49c3 eor #$c3 1af9 : d91702 cmp abs1,y ;test result trap_ne 1afc : d0fe > bne * ;failed not equal (non zero) 1afe : 68 pla ;load status eor_flag 0 1aff : 4930 > eor #0|fao ;invert expected flags + always on bits 1b01 : d91c02 cmp fLDx,y ;test flags trap_ne 1b04 : d0fe > bne * ;failed not equal (non zero) 1b06 : 88 dey 1b07 : 10e0 bpl tlday 1b09 : a003 ldy #3 1b0b : tlday1 set_stat $ff > load_flag $ff 1b0b : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1b0d : 48 > pha ;use stack to load status 1b0e : 28 > plp 1b0f : b11a lda (ind1),y 1b11 : 08 php ;test stores do not alter flags 1b12 : 49c3 eor #$c3 1b14 : 28 plp 1b15 : 990302 sta abst,y 1b18 : 08 php ;flags after load/store sequence 1b19 : 49c3 eor #$c3 1b1b : d91702 cmp abs1,y ;test result trap_ne 1b1e : d0fe > bne * ;failed not equal (non zero) 1b20 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1b21 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1b23 : d91c02 cmp fLDx,y ;test flags trap_ne 1b26 : d0fe > bne * ;failed not equal (non zero) 1b28 : 88 dey 1b29 : 10e0 bpl tlday1 1b2b : a003 ldy #3 ;testing store result 1b2d : a200 ldx #0 1b2f : b90302 tstay lda abst,y 1b32 : 49c3 eor #$c3 1b34 : d91702 cmp abs1,y trap_ne ;store to abs data 1b37 : d0fe > bne * ;failed not equal (non zero) 1b39 : 8a txa 1b3a : 990302 sta abst,y ;clear 1b3d : 88 dey 1b3e : 10ef bpl tstay 1b40 : a003 ldy #3 1b42 : tlday2 set_stat 0 > load_flag 0 1b42 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1b44 : 48 > pha ;use stack to load status 1b45 : 28 > plp 1b46 : b91702 lda abs1,y 1b49 : 08 php ;test stores do not alter flags 1b4a : 49c3 eor #$c3 1b4c : 28 plp 1b4d : 9126 sta (indt),y 1b4f : 08 php ;flags after load/store sequence 1b50 : 49c3 eor #$c3 1b52 : d11a cmp (ind1),y ;test result trap_ne 1b54 : d0fe > bne * ;failed not equal (non zero) 1b56 : 68 pla ;load status eor_flag 0 1b57 : 4930 > eor #0|fao ;invert expected flags + always on bits 1b59 : d91c02 cmp fLDx,y ;test flags trap_ne 1b5c : d0fe > bne * ;failed not equal (non zero) 1b5e : 88 dey 1b5f : 10e1 bpl tlday2 1b61 : a003 ldy #3 1b63 : tlday3 set_stat $ff > load_flag $ff 1b63 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1b65 : 48 > pha ;use stack to load status 1b66 : 28 > plp 1b67 : b91702 lda abs1,y 1b6a : 08 php ;test stores do not alter flags 1b6b : 49c3 eor #$c3 1b6d : 28 plp 1b6e : 9126 sta (indt),y 1b70 : 08 php ;flags after load/store sequence 1b71 : 49c3 eor #$c3 1b73 : d11a cmp (ind1),y ;test result trap_ne 1b75 : d0fe > bne * ;failed not equal (non zero) 1b77 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1b78 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1b7a : d91c02 cmp fLDx,y ;test flags trap_ne 1b7d : d0fe > bne * ;failed not equal (non zero) 1b7f : 88 dey 1b80 : 10e1 bpl tlday3 1b82 : a003 ldy #3 ;testing store result 1b84 : a200 ldx #0 1b86 : b90302 tstay1 lda abst,y 1b89 : 49c3 eor #$c3 1b8b : d91702 cmp abs1,y trap_ne ;store to abs data 1b8e : d0fe > bne * ;failed not equal (non zero) 1b90 : 8a txa 1b91 : 990302 sta abst,y ;clear 1b94 : 88 dey 1b95 : 10ef bpl tstay1 1b97 : a206 ldx #6 1b99 : a003 ldy #3 1b9b : tldax4 set_stat 0 > load_flag 0 1b9b : a900 > lda #0 ;allow test to change I-flag (no mask) > 1b9d : 48 > pha ;use stack to load status 1b9e : 28 > plp 1b9f : a11a lda (ind1,x) 1ba1 : 08 php ;test stores do not alter flags 1ba2 : 49c3 eor #$c3 1ba4 : 28 plp 1ba5 : 8126 sta (indt,x) 1ba7 : 08 php ;flags after load/store sequence 1ba8 : 49c3 eor #$c3 1baa : d91702 cmp abs1,y ;test result trap_ne 1bad : d0fe > bne * ;failed not equal (non zero) 1baf : 68 pla ;load status eor_flag 0 1bb0 : 4930 > eor #0|fao ;invert expected flags + always on bits 1bb2 : d91c02 cmp fLDx,y ;test flags trap_ne 1bb5 : d0fe > bne * ;failed not equal (non zero) 1bb7 : ca dex 1bb8 : ca dex 1bb9 : 88 dey 1bba : 10df bpl tldax4 1bbc : a206 ldx #6 1bbe : a003 ldy #3 1bc0 : tldax5 set_stat $ff > load_flag $ff 1bc0 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1bc2 : 48 > pha ;use stack to load status 1bc3 : 28 > plp 1bc4 : a11a lda (ind1,x) 1bc6 : 08 php ;test stores do not alter flags 1bc7 : 49c3 eor #$c3 1bc9 : 28 plp 1bca : 8126 sta (indt,x) 1bcc : 08 php ;flags after load/store sequence 1bcd : 49c3 eor #$c3 1bcf : d91702 cmp abs1,y ;test result trap_ne 1bd2 : d0fe > bne * ;failed not equal (non zero) 1bd4 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1bd5 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1bd7 : d91c02 cmp fLDx,y ;test flags trap_ne 1bda : d0fe > bne * ;failed not equal (non zero) 1bdc : ca dex 1bdd : ca dex 1bde : 88 dey 1bdf : 10df bpl tldax5 1be1 : a003 ldy #3 ;testing store result 1be3 : a200 ldx #0 1be5 : b90302 tstay2 lda abst,y 1be8 : 49c3 eor #$c3 1bea : d91702 cmp abs1,y trap_ne ;store to abs data 1bed : d0fe > bne * ;failed not equal (non zero) 1bef : 8a txa 1bf0 : 990302 sta abst,y ;clear 1bf3 : 88 dey 1bf4 : 10ef bpl tstay2 next_test 1bf6 : ad0002 > lda test_case ;previous test 1bf9 : c916 > cmp #test_num > trap_ne ;test is out of sequence 1bfb : d0fe > bne * ;failed not equal (non zero) > 0017 = >test_num = test_num + 1 1bfd : a917 > lda #test_num ;*** next tests' number 1bff : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; indexed wraparound test (only zp should wrap) 1c02 : a2fd ldx #3+$fa 1c04 : b50f tldax6 lda zp1-$fa&$ff,x ;wrap on indexed zp 1c06 : 9d0901 sta abst-$fa,x ;no STX abs,x! 1c09 : ca dex 1c0a : e0fa cpx #$fa 1c0c : b0f6 bcs tldax6 1c0e : a2fd ldx #3+$fa 1c10 : bd1d01 tldax7 lda abs1-$fa,x ;no wrap on indexed abs 1c13 : 9508 sta zpt-$fa&$ff,x 1c15 : ca dex 1c16 : e0fa cpx #$fa 1c18 : b0f6 bcs tldax7 1c1a : a203 ldx #3 ;testing wraparound result 1c1c : a000 ldy #0 1c1e : b502 tstax1 lda zpt,x 1c20 : d509 cmp zp1,x trap_ne ;store to zp,x data 1c22 : d0fe > bne * ;failed not equal (non zero) 1c24 : 9402 sty zpt,x ;clear 1c26 : bd0302 lda abst,x 1c29 : dd1702 cmp abs1,x trap_ne ;store to abs,x data 1c2c : d0fe > bne * ;failed not equal (non zero) 1c2e : 8a txa 1c2f : 9d0302 sta abst,x ;clear 1c32 : ca dex 1c33 : 10e9 bpl tstax1 1c35 : a0fb ldy #3+$f8 1c37 : a2fe ldx #6+$f8 1c39 : a122 tlday4 lda (ind1-$f8&$ff,x) ;wrap on indexed zp indirect 1c3b : 990b01 sta abst-$f8,y 1c3e : ca dex 1c3f : ca dex 1c40 : 88 dey 1c41 : c0f8 cpy #$f8 1c43 : b0f4 bcs tlday4 1c45 : a003 ldy #3 ;testing wraparound result 1c47 : a200 ldx #0 1c49 : b90302 tstay4 lda abst,y 1c4c : d91702 cmp abs1,y trap_ne ;store to abs data 1c4f : d0fe > bne * ;failed not equal (non zero) 1c51 : 8a txa 1c52 : 990302 sta abst,y ;clear 1c55 : 88 dey 1c56 : 10f1 bpl tstay4 1c58 : a0fb ldy #3+$f8 1c5a : b91f01 tlday5 lda abs1-$f8,y ;no wrap on indexed abs 1c5d : 912e sta (inwt),y 1c5f : 88 dey 1c60 : c0f8 cpy #$f8 1c62 : b0f6 bcs tlday5 1c64 : a003 ldy #3 ;testing wraparound result 1c66 : a200 ldx #0 1c68 : b90302 tstay5 lda abst,y 1c6b : d91702 cmp abs1,y trap_ne ;store to abs data 1c6e : d0fe > bne * ;failed not equal (non zero) 1c70 : 8a txa 1c71 : 990302 sta abst,y ;clear 1c74 : 88 dey 1c75 : 10f1 bpl tstay5 1c77 : a0fb ldy #3+$f8 1c79 : a2fe ldx #6+$f8 1c7b : b124 tlday6 lda (inw1),y ;no wrap on zp indirect indexed 1c7d : 812e sta (indt-$f8&$ff,x) 1c7f : ca dex 1c80 : ca dex 1c81 : 88 dey 1c82 : c0f8 cpy #$f8 1c84 : b0f5 bcs tlday6 1c86 : a003 ldy #3 ;testing wraparound result 1c88 : a200 ldx #0 1c8a : b90302 tstay6 lda abst,y 1c8d : d91702 cmp abs1,y trap_ne ;store to abs data 1c90 : d0fe > bne * ;failed not equal (non zero) 1c92 : 8a txa 1c93 : 990302 sta abst,y ;clear 1c96 : 88 dey 1c97 : 10f1 bpl tstay6 next_test 1c99 : ad0002 > lda test_case ;previous test 1c9c : c917 > cmp #test_num > trap_ne ;test is out of sequence 1c9e : d0fe > bne * ;failed not equal (non zero) > 0018 = >test_num = test_num + 1 1ca0 : a918 > lda #test_num ;*** next tests' number 1ca2 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; LDA / STA - zp / abs / # set_stat 0 > load_flag 0 1ca5 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1ca7 : 48 > pha ;use stack to load status 1ca8 : 28 > plp 1ca9 : a509 lda zp1 1cab : 08 php ;test stores do not alter flags 1cac : 49c3 eor #$c3 1cae : 28 plp 1caf : 8d0302 sta abst 1cb2 : 08 php ;flags after load/store sequence 1cb3 : 49c3 eor #$c3 1cb5 : c9c3 cmp #$c3 ;test result trap_ne 1cb7 : d0fe > bne * ;failed not equal (non zero) 1cb9 : 68 pla ;load status eor_flag 0 1cba : 4930 > eor #0|fao ;invert expected flags + always on bits 1cbc : cd1c02 cmp fLDx ;test flags trap_ne 1cbf : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1cc1 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1cc3 : 48 > pha ;use stack to load status 1cc4 : 28 > plp 1cc5 : a50a lda zp1+1 1cc7 : 08 php ;test stores do not alter flags 1cc8 : 49c3 eor #$c3 1cca : 28 plp 1ccb : 8d0402 sta abst+1 1cce : 08 php ;flags after load/store sequence 1ccf : 49c3 eor #$c3 1cd1 : c982 cmp #$82 ;test result trap_ne 1cd3 : d0fe > bne * ;failed not equal (non zero) 1cd5 : 68 pla ;load status eor_flag 0 1cd6 : 4930 > eor #0|fao ;invert expected flags + always on bits 1cd8 : cd1d02 cmp fLDx+1 ;test flags trap_ne 1cdb : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1cdd : a900 > lda #0 ;allow test to change I-flag (no mask) > 1cdf : 48 > pha ;use stack to load status 1ce0 : 28 > plp 1ce1 : a50b lda zp1+2 1ce3 : 08 php ;test stores do not alter flags 1ce4 : 49c3 eor #$c3 1ce6 : 28 plp 1ce7 : 8d0502 sta abst+2 1cea : 08 php ;flags after load/store sequence 1ceb : 49c3 eor #$c3 1ced : c941 cmp #$41 ;test result trap_ne 1cef : d0fe > bne * ;failed not equal (non zero) 1cf1 : 68 pla ;load status eor_flag 0 1cf2 : 4930 > eor #0|fao ;invert expected flags + always on bits 1cf4 : cd1e02 cmp fLDx+2 ;test flags trap_ne 1cf7 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1cf9 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1cfb : 48 > pha ;use stack to load status 1cfc : 28 > plp 1cfd : a50c lda zp1+3 1cff : 08 php ;test stores do not alter flags 1d00 : 49c3 eor #$c3 1d02 : 28 plp 1d03 : 8d0602 sta abst+3 1d06 : 08 php ;flags after load/store sequence 1d07 : 49c3 eor #$c3 1d09 : c900 cmp #0 ;test result trap_ne 1d0b : d0fe > bne * ;failed not equal (non zero) 1d0d : 68 pla ;load status eor_flag 0 1d0e : 4930 > eor #0|fao ;invert expected flags + always on bits 1d10 : cd1f02 cmp fLDx+3 ;test flags trap_ne 1d13 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1d15 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1d17 : 48 > pha ;use stack to load status 1d18 : 28 > plp 1d19 : a509 lda zp1 1d1b : 08 php ;test stores do not alter flags 1d1c : 49c3 eor #$c3 1d1e : 28 plp 1d1f : 8d0302 sta abst 1d22 : 08 php ;flags after load/store sequence 1d23 : 49c3 eor #$c3 1d25 : c9c3 cmp #$c3 ;test result trap_ne 1d27 : d0fe > bne * ;failed not equal (non zero) 1d29 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1d2a : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1d2c : cd1c02 cmp fLDx ;test flags trap_ne 1d2f : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1d31 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1d33 : 48 > pha ;use stack to load status 1d34 : 28 > plp 1d35 : a50a lda zp1+1 1d37 : 08 php ;test stores do not alter flags 1d38 : 49c3 eor #$c3 1d3a : 28 plp 1d3b : 8d0402 sta abst+1 1d3e : 08 php ;flags after load/store sequence 1d3f : 49c3 eor #$c3 1d41 : c982 cmp #$82 ;test result trap_ne 1d43 : d0fe > bne * ;failed not equal (non zero) 1d45 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1d46 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1d48 : cd1d02 cmp fLDx+1 ;test flags trap_ne 1d4b : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1d4d : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1d4f : 48 > pha ;use stack to load status 1d50 : 28 > plp 1d51 : a50b lda zp1+2 1d53 : 08 php ;test stores do not alter flags 1d54 : 49c3 eor #$c3 1d56 : 28 plp 1d57 : 8d0502 sta abst+2 1d5a : 08 php ;flags after load/store sequence 1d5b : 49c3 eor #$c3 1d5d : c941 cmp #$41 ;test result trap_ne 1d5f : d0fe > bne * ;failed not equal (non zero) 1d61 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1d62 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1d64 : cd1e02 cmp fLDx+2 ;test flags trap_ne 1d67 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1d69 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1d6b : 48 > pha ;use stack to load status 1d6c : 28 > plp 1d6d : a50c lda zp1+3 1d6f : 08 php ;test stores do not alter flags 1d70 : 49c3 eor #$c3 1d72 : 28 plp 1d73 : 8d0602 sta abst+3 1d76 : 08 php ;flags after load/store sequence 1d77 : 49c3 eor #$c3 1d79 : c900 cmp #0 ;test result trap_ne 1d7b : d0fe > bne * ;failed not equal (non zero) 1d7d : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1d7e : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1d80 : cd1f02 cmp fLDx+3 ;test flags trap_ne 1d83 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1d85 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1d87 : 48 > pha ;use stack to load status 1d88 : 28 > plp 1d89 : ad1702 lda abs1 1d8c : 08 php ;test stores do not alter flags 1d8d : 49c3 eor #$c3 1d8f : 28 plp 1d90 : 8502 sta zpt 1d92 : 08 php ;flags after load/store sequence 1d93 : 49c3 eor #$c3 1d95 : c509 cmp zp1 ;test result trap_ne 1d97 : d0fe > bne * ;failed not equal (non zero) 1d99 : 68 pla ;load status eor_flag 0 1d9a : 4930 > eor #0|fao ;invert expected flags + always on bits 1d9c : cd1c02 cmp fLDx ;test flags trap_ne 1d9f : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1da1 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1da3 : 48 > pha ;use stack to load status 1da4 : 28 > plp 1da5 : ad1802 lda abs1+1 1da8 : 08 php ;test stores do not alter flags 1da9 : 49c3 eor #$c3 1dab : 28 plp 1dac : 8503 sta zpt+1 1dae : 08 php ;flags after load/store sequence 1daf : 49c3 eor #$c3 1db1 : c50a cmp zp1+1 ;test result trap_ne 1db3 : d0fe > bne * ;failed not equal (non zero) 1db5 : 68 pla ;load status eor_flag 0 1db6 : 4930 > eor #0|fao ;invert expected flags + always on bits 1db8 : cd1d02 cmp fLDx+1 ;test flags trap_ne 1dbb : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1dbd : a900 > lda #0 ;allow test to change I-flag (no mask) > 1dbf : 48 > pha ;use stack to load status 1dc0 : 28 > plp 1dc1 : ad1902 lda abs1+2 1dc4 : 08 php ;test stores do not alter flags 1dc5 : 49c3 eor #$c3 1dc7 : 28 plp 1dc8 : 8504 sta zpt+2 1dca : 08 php ;flags after load/store sequence 1dcb : 49c3 eor #$c3 1dcd : c50b cmp zp1+2 ;test result trap_ne 1dcf : d0fe > bne * ;failed not equal (non zero) 1dd1 : 68 pla ;load status eor_flag 0 1dd2 : 4930 > eor #0|fao ;invert expected flags + always on bits 1dd4 : cd1e02 cmp fLDx+2 ;test flags trap_ne 1dd7 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1dd9 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1ddb : 48 > pha ;use stack to load status 1ddc : 28 > plp 1ddd : ad1a02 lda abs1+3 1de0 : 08 php ;test stores do not alter flags 1de1 : 49c3 eor #$c3 1de3 : 28 plp 1de4 : 8505 sta zpt+3 1de6 : 08 php ;flags after load/store sequence 1de7 : 49c3 eor #$c3 1de9 : c50c cmp zp1+3 ;test result trap_ne 1deb : d0fe > bne * ;failed not equal (non zero) 1ded : 68 pla ;load status eor_flag 0 1dee : 4930 > eor #0|fao ;invert expected flags + always on bits 1df0 : cd1f02 cmp fLDx+3 ;test flags trap_ne 1df3 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1df5 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1df7 : 48 > pha ;use stack to load status 1df8 : 28 > plp 1df9 : ad1702 lda abs1 1dfc : 08 php ;test stores do not alter flags 1dfd : 49c3 eor #$c3 1dff : 28 plp 1e00 : 8502 sta zpt 1e02 : 08 php ;flags after load/store sequence 1e03 : 49c3 eor #$c3 1e05 : c509 cmp zp1 ;test result trap_ne 1e07 : d0fe > bne * ;failed not equal (non zero) 1e09 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1e0a : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1e0c : cd1c02 cmp fLDx ;test flags trap_ne 1e0f : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1e11 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1e13 : 48 > pha ;use stack to load status 1e14 : 28 > plp 1e15 : ad1802 lda abs1+1 1e18 : 08 php ;test stores do not alter flags 1e19 : 49c3 eor #$c3 1e1b : 28 plp 1e1c : 8503 sta zpt+1 1e1e : 08 php ;flags after load/store sequence 1e1f : 49c3 eor #$c3 1e21 : c50a cmp zp1+1 ;test result trap_ne 1e23 : d0fe > bne * ;failed not equal (non zero) 1e25 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1e26 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1e28 : cd1d02 cmp fLDx+1 ;test flags trap_ne 1e2b : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1e2d : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1e2f : 48 > pha ;use stack to load status 1e30 : 28 > plp 1e31 : ad1902 lda abs1+2 1e34 : 08 php ;test stores do not alter flags 1e35 : 49c3 eor #$c3 1e37 : 28 plp 1e38 : 8504 sta zpt+2 1e3a : 08 php ;flags after load/store sequence 1e3b : 49c3 eor #$c3 1e3d : c50b cmp zp1+2 ;test result trap_ne 1e3f : d0fe > bne * ;failed not equal (non zero) 1e41 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1e42 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1e44 : cd1e02 cmp fLDx+2 ;test flags trap_ne 1e47 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1e49 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1e4b : 48 > pha ;use stack to load status 1e4c : 28 > plp 1e4d : ad1a02 lda abs1+3 1e50 : 08 php ;test stores do not alter flags 1e51 : 49c3 eor #$c3 1e53 : 28 plp 1e54 : 8505 sta zpt+3 1e56 : 08 php ;flags after load/store sequence 1e57 : 49c3 eor #$c3 1e59 : c50c cmp zp1+3 ;test result trap_ne 1e5b : d0fe > bne * ;failed not equal (non zero) 1e5d : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1e5e : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1e60 : cd1f02 cmp fLDx+3 ;test flags trap_ne 1e63 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1e65 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1e67 : 48 > pha ;use stack to load status 1e68 : 28 > plp 1e69 : a9c3 lda #$c3 1e6b : 08 php 1e6c : cd1702 cmp abs1 ;test result trap_ne 1e6f : d0fe > bne * ;failed not equal (non zero) 1e71 : 68 pla ;load status eor_flag 0 1e72 : 4930 > eor #0|fao ;invert expected flags + always on bits 1e74 : cd1c02 cmp fLDx ;test flags trap_ne 1e77 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1e79 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1e7b : 48 > pha ;use stack to load status 1e7c : 28 > plp 1e7d : a982 lda #$82 1e7f : 08 php 1e80 : cd1802 cmp abs1+1 ;test result trap_ne 1e83 : d0fe > bne * ;failed not equal (non zero) 1e85 : 68 pla ;load status eor_flag 0 1e86 : 4930 > eor #0|fao ;invert expected flags + always on bits 1e88 : cd1d02 cmp fLDx+1 ;test flags trap_ne 1e8b : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1e8d : a900 > lda #0 ;allow test to change I-flag (no mask) > 1e8f : 48 > pha ;use stack to load status 1e90 : 28 > plp 1e91 : a941 lda #$41 1e93 : 08 php 1e94 : cd1902 cmp abs1+2 ;test result trap_ne 1e97 : d0fe > bne * ;failed not equal (non zero) 1e99 : 68 pla ;load status eor_flag 0 1e9a : 4930 > eor #0|fao ;invert expected flags + always on bits 1e9c : cd1e02 cmp fLDx+2 ;test flags trap_ne 1e9f : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1ea1 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1ea3 : 48 > pha ;use stack to load status 1ea4 : 28 > plp 1ea5 : a900 lda #0 1ea7 : 08 php 1ea8 : cd1a02 cmp abs1+3 ;test result trap_ne 1eab : d0fe > bne * ;failed not equal (non zero) 1ead : 68 pla ;load status eor_flag 0 1eae : 4930 > eor #0|fao ;invert expected flags + always on bits 1eb0 : cd1f02 cmp fLDx+3 ;test flags trap_ne 1eb3 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1eb5 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1eb7 : 48 > pha ;use stack to load status 1eb8 : 28 > plp 1eb9 : a9c3 lda #$c3 1ebb : 08 php 1ebc : cd1702 cmp abs1 ;test result trap_ne 1ebf : d0fe > bne * ;failed not equal (non zero) 1ec1 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1ec2 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1ec4 : cd1c02 cmp fLDx ;test flags trap_ne 1ec7 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1ec9 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1ecb : 48 > pha ;use stack to load status 1ecc : 28 > plp 1ecd : a982 lda #$82 1ecf : 08 php 1ed0 : cd1802 cmp abs1+1 ;test result trap_ne 1ed3 : d0fe > bne * ;failed not equal (non zero) 1ed5 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1ed6 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1ed8 : cd1d02 cmp fLDx+1 ;test flags trap_ne 1edb : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1edd : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1edf : 48 > pha ;use stack to load status 1ee0 : 28 > plp 1ee1 : a941 lda #$41 1ee3 : 08 php 1ee4 : cd1902 cmp abs1+2 ;test result trap_ne 1ee7 : d0fe > bne * ;failed not equal (non zero) 1ee9 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1eea : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1eec : cd1e02 cmp fLDx+2 ;test flags trap_ne 1eef : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1ef1 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1ef3 : 48 > pha ;use stack to load status 1ef4 : 28 > plp 1ef5 : a900 lda #0 1ef7 : 08 php 1ef8 : cd1a02 cmp abs1+3 ;test result trap_ne 1efb : d0fe > bne * ;failed not equal (non zero) 1efd : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1efe : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1f00 : cd1f02 cmp fLDx+3 ;test flags trap_ne 1f03 : d0fe > bne * ;failed not equal (non zero) 1f05 : a200 ldx #0 1f07 : a502 lda zpt 1f09 : 49c3 eor #$c3 1f0b : c509 cmp zp1 trap_ne ;store to zp data 1f0d : d0fe > bne * ;failed not equal (non zero) 1f0f : 8602 stx zpt ;clear 1f11 : ad0302 lda abst 1f14 : 49c3 eor #$c3 1f16 : cd1702 cmp abs1 trap_ne ;store to abs data 1f19 : d0fe > bne * ;failed not equal (non zero) 1f1b : 8e0302 stx abst ;clear 1f1e : a503 lda zpt+1 1f20 : 49c3 eor #$c3 1f22 : c50a cmp zp1+1 trap_ne ;store to zp data 1f24 : d0fe > bne * ;failed not equal (non zero) 1f26 : 8603 stx zpt+1 ;clear 1f28 : ad0402 lda abst+1 1f2b : 49c3 eor #$c3 1f2d : cd1802 cmp abs1+1 trap_ne ;store to abs data 1f30 : d0fe > bne * ;failed not equal (non zero) 1f32 : 8e0402 stx abst+1 ;clear 1f35 : a504 lda zpt+2 1f37 : 49c3 eor #$c3 1f39 : c50b cmp zp1+2 trap_ne ;store to zp data 1f3b : d0fe > bne * ;failed not equal (non zero) 1f3d : 8604 stx zpt+2 ;clear 1f3f : ad0502 lda abst+2 1f42 : 49c3 eor #$c3 1f44 : cd1902 cmp abs1+2 trap_ne ;store to abs data 1f47 : d0fe > bne * ;failed not equal (non zero) 1f49 : 8e0502 stx abst+2 ;clear 1f4c : a505 lda zpt+3 1f4e : 49c3 eor #$c3 1f50 : c50c cmp zp1+3 trap_ne ;store to zp data 1f52 : d0fe > bne * ;failed not equal (non zero) 1f54 : 8605 stx zpt+3 ;clear 1f56 : ad0602 lda abst+3 1f59 : 49c3 eor #$c3 1f5b : cd1a02 cmp abs1+3 trap_ne ;store to abs data 1f5e : d0fe > bne * ;failed not equal (non zero) 1f60 : 8e0602 stx abst+3 ;clear next_test 1f63 : ad0002 > lda test_case ;previous test 1f66 : c918 > cmp #test_num > trap_ne ;test is out of sequence 1f68 : d0fe > bne * ;failed not equal (non zero) > 0019 = >test_num = test_num + 1 1f6a : a919 > lda #test_num ;*** next tests' number 1f6c : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; testing bit test & compares BIT CPX CPY CMP all addressing modes ; BIT - zp / abs set_a $ff,0 > load_flag 0 1f6f : a900 > lda #0 ;allow test to change I-flag (no mask) > 1f71 : 48 > pha ;use stack to load status 1f72 : a9ff > lda #$ff ;precharge accu 1f74 : 28 > plp 1f75 : 240c bit zp1+3 ;00 - should set Z / clear NV tst_a $ff,fz 1f77 : 08 > php ;save flags 1f78 : c9ff > cmp #$ff ;test result > trap_ne 1f7a : d0fe > bne * ;failed not equal (non zero) > 1f7c : 68 > pla ;load status 1f7d : 48 > pha > cmp_flag fz 1f7e : c932 > cmp #(fz|fao)&m8 ;expected flags + always on bits > > trap_ne 1f80 : d0fe > bne * ;failed not equal (non zero) > 1f82 : 28 > plp ;restore status set_a 1,0 > load_flag 0 1f83 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1f85 : 48 > pha ;use stack to load status 1f86 : a901 > lda #1 ;precharge accu 1f88 : 28 > plp 1f89 : 240b bit zp1+2 ;41 - should set V (M6) / clear NZ tst_a 1,fv 1f8b : 08 > php ;save flags 1f8c : c901 > cmp #1 ;test result > trap_ne 1f8e : d0fe > bne * ;failed not equal (non zero) > 1f90 : 68 > pla ;load status 1f91 : 48 > pha > cmp_flag fv 1f92 : c970 > cmp #(fv|fao)&m8 ;expected flags + always on bits > > trap_ne 1f94 : d0fe > bne * ;failed not equal (non zero) > 1f96 : 28 > plp ;restore status set_a 1,0 > load_flag 0 1f97 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1f99 : 48 > pha ;use stack to load status 1f9a : a901 > lda #1 ;precharge accu 1f9c : 28 > plp 1f9d : 240a bit zp1+1 ;82 - should set N (M7) & Z / clear V tst_a 1,fnz 1f9f : 08 > php ;save flags 1fa0 : c901 > cmp #1 ;test result > trap_ne 1fa2 : d0fe > bne * ;failed not equal (non zero) > 1fa4 : 68 > pla ;load status 1fa5 : 48 > pha > cmp_flag fnz 1fa6 : c9b2 > cmp #(fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 1fa8 : d0fe > bne * ;failed not equal (non zero) > 1faa : 28 > plp ;restore status set_a 1,0 > load_flag 0 1fab : a900 > lda #0 ;allow test to change I-flag (no mask) > 1fad : 48 > pha ;use stack to load status 1fae : a901 > lda #1 ;precharge accu 1fb0 : 28 > plp 1fb1 : 2409 bit zp1 ;c3 - should set N (M7) & V (M6) / clear Z tst_a 1,fnv 1fb3 : 08 > php ;save flags 1fb4 : c901 > cmp #1 ;test result > trap_ne 1fb6 : d0fe > bne * ;failed not equal (non zero) > 1fb8 : 68 > pla ;load status 1fb9 : 48 > pha > cmp_flag fnv 1fba : c9f0 > cmp #(fnv|fao)&m8 ;expected flags + always on bits > > trap_ne 1fbc : d0fe > bne * ;failed not equal (non zero) > 1fbe : 28 > plp ;restore status set_a $ff,$ff > load_flag $ff 1fbf : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1fc1 : 48 > pha ;use stack to load status 1fc2 : a9ff > lda #$ff ;precharge accu 1fc4 : 28 > plp 1fc5 : 240c bit zp1+3 ;00 - should set Z / clear NV tst_a $ff,~fnv 1fc7 : 08 > php ;save flags 1fc8 : c9ff > cmp #$ff ;test result > trap_ne 1fca : d0fe > bne * ;failed not equal (non zero) > 1fcc : 68 > pla ;load status 1fcd : 48 > pha > cmp_flag ~fnv 1fce : c93f > cmp #(~fnv|fao)&m8 ;expected flags + always on bits > > trap_ne 1fd0 : d0fe > bne * ;failed not equal (non zero) > 1fd2 : 28 > plp ;restore status set_a 1,$ff > load_flag $ff 1fd3 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1fd5 : 48 > pha ;use stack to load status 1fd6 : a901 > lda #1 ;precharge accu 1fd8 : 28 > plp 1fd9 : 240b bit zp1+2 ;41 - should set V (M6) / clear NZ tst_a 1,~fnz 1fdb : 08 > php ;save flags 1fdc : c901 > cmp #1 ;test result > trap_ne 1fde : d0fe > bne * ;failed not equal (non zero) > 1fe0 : 68 > pla ;load status 1fe1 : 48 > pha > cmp_flag ~fnz 1fe2 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 1fe4 : d0fe > bne * ;failed not equal (non zero) > 1fe6 : 28 > plp ;restore status set_a 1,$ff > load_flag $ff 1fe7 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1fe9 : 48 > pha ;use stack to load status 1fea : a901 > lda #1 ;precharge accu 1fec : 28 > plp 1fed : 240a bit zp1+1 ;82 - should set N (M7) & Z / clear V tst_a 1,~fv 1fef : 08 > php ;save flags 1ff0 : c901 > cmp #1 ;test result > trap_ne 1ff2 : d0fe > bne * ;failed not equal (non zero) > 1ff4 : 68 > pla ;load status 1ff5 : 48 > pha > cmp_flag ~fv 1ff6 : c9bf > cmp #(~fv|fao)&m8 ;expected flags + always on bits > > trap_ne 1ff8 : d0fe > bne * ;failed not equal (non zero) > 1ffa : 28 > plp ;restore status set_a 1,$ff > load_flag $ff 1ffb : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1ffd : 48 > pha ;use stack to load status 1ffe : a901 > lda #1 ;precharge accu 2000 : 28 > plp 2001 : 2409 bit zp1 ;c3 - should set N (M7) & V (M6) / clear Z tst_a 1,~fz 2003 : 08 > php ;save flags 2004 : c901 > cmp #1 ;test result > trap_ne 2006 : d0fe > bne * ;failed not equal (non zero) > 2008 : 68 > pla ;load status 2009 : 48 > pha > cmp_flag ~fz 200a : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits > > trap_ne 200c : d0fe > bne * ;failed not equal (non zero) > 200e : 28 > plp ;restore status set_a $ff,0 > load_flag 0 200f : a900 > lda #0 ;allow test to change I-flag (no mask) > 2011 : 48 > pha ;use stack to load status 2012 : a9ff > lda #$ff ;precharge accu 2014 : 28 > plp 2015 : 2c1a02 bit abs1+3 ;00 - should set Z / clear NV tst_a $ff,fz 2018 : 08 > php ;save flags 2019 : c9ff > cmp #$ff ;test result > trap_ne 201b : d0fe > bne * ;failed not equal (non zero) > 201d : 68 > pla ;load status 201e : 48 > pha > cmp_flag fz 201f : c932 > cmp #(fz|fao)&m8 ;expected flags + always on bits > > trap_ne 2021 : d0fe > bne * ;failed not equal (non zero) > 2023 : 28 > plp ;restore status set_a 1,0 > load_flag 0 2024 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2026 : 48 > pha ;use stack to load status 2027 : a901 > lda #1 ;precharge accu 2029 : 28 > plp 202a : 2c1902 bit abs1+2 ;41 - should set V (M6) / clear NZ tst_a 1,fv 202d : 08 > php ;save flags 202e : c901 > cmp #1 ;test result > trap_ne 2030 : d0fe > bne * ;failed not equal (non zero) > 2032 : 68 > pla ;load status 2033 : 48 > pha > cmp_flag fv 2034 : c970 > cmp #(fv|fao)&m8 ;expected flags + always on bits > > trap_ne 2036 : d0fe > bne * ;failed not equal (non zero) > 2038 : 28 > plp ;restore status set_a 1,0 > load_flag 0 2039 : a900 > lda #0 ;allow test to change I-flag (no mask) > 203b : 48 > pha ;use stack to load status 203c : a901 > lda #1 ;precharge accu 203e : 28 > plp 203f : 2c1802 bit abs1+1 ;82 - should set N (M7) & Z / clear V tst_a 1,fnz 2042 : 08 > php ;save flags 2043 : c901 > cmp #1 ;test result > trap_ne 2045 : d0fe > bne * ;failed not equal (non zero) > 2047 : 68 > pla ;load status 2048 : 48 > pha > cmp_flag fnz 2049 : c9b2 > cmp #(fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 204b : d0fe > bne * ;failed not equal (non zero) > 204d : 28 > plp ;restore status set_a 1,0 > load_flag 0 204e : a900 > lda #0 ;allow test to change I-flag (no mask) > 2050 : 48 > pha ;use stack to load status 2051 : a901 > lda #1 ;precharge accu 2053 : 28 > plp 2054 : 2c1702 bit abs1 ;c3 - should set N (M7) & V (M6) / clear Z tst_a 1,fnv 2057 : 08 > php ;save flags 2058 : c901 > cmp #1 ;test result > trap_ne 205a : d0fe > bne * ;failed not equal (non zero) > 205c : 68 > pla ;load status 205d : 48 > pha > cmp_flag fnv 205e : c9f0 > cmp #(fnv|fao)&m8 ;expected flags + always on bits > > trap_ne 2060 : d0fe > bne * ;failed not equal (non zero) > 2062 : 28 > plp ;restore status set_a $ff,$ff > load_flag $ff 2063 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2065 : 48 > pha ;use stack to load status 2066 : a9ff > lda #$ff ;precharge accu 2068 : 28 > plp 2069 : 2c1a02 bit abs1+3 ;00 - should set Z / clear NV tst_a $ff,~fnv 206c : 08 > php ;save flags 206d : c9ff > cmp #$ff ;test result > trap_ne 206f : d0fe > bne * ;failed not equal (non zero) > 2071 : 68 > pla ;load status 2072 : 48 > pha > cmp_flag ~fnv 2073 : c93f > cmp #(~fnv|fao)&m8 ;expected flags + always on bits > > trap_ne 2075 : d0fe > bne * ;failed not equal (non zero) > 2077 : 28 > plp ;restore status set_a 1,$ff > load_flag $ff 2078 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 207a : 48 > pha ;use stack to load status 207b : a901 > lda #1 ;precharge accu 207d : 28 > plp 207e : 2c1902 bit abs1+2 ;41 - should set V (M6) / clear NZ tst_a 1,~fnz 2081 : 08 > php ;save flags 2082 : c901 > cmp #1 ;test result > trap_ne 2084 : d0fe > bne * ;failed not equal (non zero) > 2086 : 68 > pla ;load status 2087 : 48 > pha > cmp_flag ~fnz 2088 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 208a : d0fe > bne * ;failed not equal (non zero) > 208c : 28 > plp ;restore status set_a 1,$ff > load_flag $ff 208d : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 208f : 48 > pha ;use stack to load status 2090 : a901 > lda #1 ;precharge accu 2092 : 28 > plp 2093 : 2c1802 bit abs1+1 ;82 - should set N (M7) & Z / clear V tst_a 1,~fv 2096 : 08 > php ;save flags 2097 : c901 > cmp #1 ;test result > trap_ne 2099 : d0fe > bne * ;failed not equal (non zero) > 209b : 68 > pla ;load status 209c : 48 > pha > cmp_flag ~fv 209d : c9bf > cmp #(~fv|fao)&m8 ;expected flags + always on bits > > trap_ne 209f : d0fe > bne * ;failed not equal (non zero) > 20a1 : 28 > plp ;restore status set_a 1,$ff > load_flag $ff 20a2 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 20a4 : 48 > pha ;use stack to load status 20a5 : a901 > lda #1 ;precharge accu 20a7 : 28 > plp 20a8 : 2c1702 bit abs1 ;c3 - should set N (M7) & V (M6) / clear Z tst_a 1,~fz 20ab : 08 > php ;save flags 20ac : c901 > cmp #1 ;test result > trap_ne 20ae : d0fe > bne * ;failed not equal (non zero) > 20b0 : 68 > pla ;load status 20b1 : 48 > pha > cmp_flag ~fz 20b2 : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits > > trap_ne 20b4 : d0fe > bne * ;failed not equal (non zero) > 20b6 : 28 > plp ;restore status next_test 20b7 : ad0002 > lda test_case ;previous test 20ba : c919 > cmp #test_num > trap_ne ;test is out of sequence 20bc : d0fe > bne * ;failed not equal (non zero) > 001a = >test_num = test_num + 1 20be : a91a > lda #test_num ;*** next tests' number 20c0 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; CPX - zp / abs / # set_x $80,0 > load_flag 0 20c3 : a900 > lda #0 ;allow test to change I-flag (no mask) > 20c5 : 48 > pha ;use stack to load status 20c6 : a280 > ldx #$80 ;precharge index x 20c8 : 28 > plp 20c9 : e40d cpx zp7f tst_stat fc 20cb : 08 > php ;save status 20cc : 68 > pla ;use stack to retrieve status 20cd : 48 > pha > cmp_flag fc 20ce : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits > > trap_ne 20d0 : d0fe > bne * ;failed not equal (non zero) > 20d2 : 28 > plp ;restore status 20d3 : ca dex 20d4 : e40d cpx zp7f tst_stat fzc 20d6 : 08 > php ;save status 20d7 : 68 > pla ;use stack to retrieve status 20d8 : 48 > pha > cmp_flag fzc 20d9 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 20db : d0fe > bne * ;failed not equal (non zero) > 20dd : 28 > plp ;restore status 20de : ca dex 20df : e40d cpx zp7f tst_x $7e,fn 20e1 : 08 > php ;save flags 20e2 : e07e > cpx #$7e ;test result > trap_ne 20e4 : d0fe > bne * ;failed not equal (non zero) > 20e6 : 68 > pla ;load status 20e7 : 48 > pha > cmp_flag fn 20e8 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 20ea : d0fe > bne * ;failed not equal (non zero) > 20ec : 28 > plp ;restore status set_x $80,$ff > load_flag $ff 20ed : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 20ef : 48 > pha ;use stack to load status 20f0 : a280 > ldx #$80 ;precharge index x 20f2 : 28 > plp 20f3 : e40d cpx zp7f tst_stat ~fnz 20f5 : 08 > php ;save status 20f6 : 68 > pla ;use stack to retrieve status 20f7 : 48 > pha > cmp_flag ~fnz 20f8 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 20fa : d0fe > bne * ;failed not equal (non zero) > 20fc : 28 > plp ;restore status 20fd : ca dex 20fe : e40d cpx zp7f tst_stat ~fn 2100 : 08 > php ;save status 2101 : 68 > pla ;use stack to retrieve status 2102 : 48 > pha > cmp_flag ~fn 2103 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits > > trap_ne 2105 : d0fe > bne * ;failed not equal (non zero) > 2107 : 28 > plp ;restore status 2108 : ca dex 2109 : e40d cpx zp7f tst_x $7e,~fzc 210b : 08 > php ;save flags 210c : e07e > cpx #$7e ;test result > trap_ne 210e : d0fe > bne * ;failed not equal (non zero) > 2110 : 68 > pla ;load status 2111 : 48 > pha > cmp_flag ~fzc 2112 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 2114 : d0fe > bne * ;failed not equal (non zero) > 2116 : 28 > plp ;restore status set_x $80,0 > load_flag 0 2117 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2119 : 48 > pha ;use stack to load status 211a : a280 > ldx #$80 ;precharge index x 211c : 28 > plp 211d : ec1b02 cpx abs7f tst_stat fc 2120 : 08 > php ;save status 2121 : 68 > pla ;use stack to retrieve status 2122 : 48 > pha > cmp_flag fc 2123 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits > > trap_ne 2125 : d0fe > bne * ;failed not equal (non zero) > 2127 : 28 > plp ;restore status 2128 : ca dex 2129 : ec1b02 cpx abs7f tst_stat fzc 212c : 08 > php ;save status 212d : 68 > pla ;use stack to retrieve status 212e : 48 > pha > cmp_flag fzc 212f : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 2131 : d0fe > bne * ;failed not equal (non zero) > 2133 : 28 > plp ;restore status 2134 : ca dex 2135 : ec1b02 cpx abs7f tst_x $7e,fn 2138 : 08 > php ;save flags 2139 : e07e > cpx #$7e ;test result > trap_ne 213b : d0fe > bne * ;failed not equal (non zero) > 213d : 68 > pla ;load status 213e : 48 > pha > cmp_flag fn 213f : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 2141 : d0fe > bne * ;failed not equal (non zero) > 2143 : 28 > plp ;restore status set_x $80,$ff > load_flag $ff 2144 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2146 : 48 > pha ;use stack to load status 2147 : a280 > ldx #$80 ;precharge index x 2149 : 28 > plp 214a : ec1b02 cpx abs7f tst_stat ~fnz 214d : 08 > php ;save status 214e : 68 > pla ;use stack to retrieve status 214f : 48 > pha > cmp_flag ~fnz 2150 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 2152 : d0fe > bne * ;failed not equal (non zero) > 2154 : 28 > plp ;restore status 2155 : ca dex 2156 : ec1b02 cpx abs7f tst_stat ~fn 2159 : 08 > php ;save status 215a : 68 > pla ;use stack to retrieve status 215b : 48 > pha > cmp_flag ~fn 215c : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits > > trap_ne 215e : d0fe > bne * ;failed not equal (non zero) > 2160 : 28 > plp ;restore status 2161 : ca dex 2162 : ec1b02 cpx abs7f tst_x $7e,~fzc 2165 : 08 > php ;save flags 2166 : e07e > cpx #$7e ;test result > trap_ne 2168 : d0fe > bne * ;failed not equal (non zero) > 216a : 68 > pla ;load status 216b : 48 > pha > cmp_flag ~fzc 216c : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 216e : d0fe > bne * ;failed not equal (non zero) > 2170 : 28 > plp ;restore status set_x $80,0 > load_flag 0 2171 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2173 : 48 > pha ;use stack to load status 2174 : a280 > ldx #$80 ;precharge index x 2176 : 28 > plp 2177 : e07f cpx #$7f tst_stat fc 2179 : 08 > php ;save status 217a : 68 > pla ;use stack to retrieve status 217b : 48 > pha > cmp_flag fc 217c : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits > > trap_ne 217e : d0fe > bne * ;failed not equal (non zero) > 2180 : 28 > plp ;restore status 2181 : ca dex 2182 : e07f cpx #$7f tst_stat fzc 2184 : 08 > php ;save status 2185 : 68 > pla ;use stack to retrieve status 2186 : 48 > pha > cmp_flag fzc 2187 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 2189 : d0fe > bne * ;failed not equal (non zero) > 218b : 28 > plp ;restore status 218c : ca dex 218d : e07f cpx #$7f tst_x $7e,fn 218f : 08 > php ;save flags 2190 : e07e > cpx #$7e ;test result > trap_ne 2192 : d0fe > bne * ;failed not equal (non zero) > 2194 : 68 > pla ;load status 2195 : 48 > pha > cmp_flag fn 2196 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 2198 : d0fe > bne * ;failed not equal (non zero) > 219a : 28 > plp ;restore status set_x $80,$ff > load_flag $ff 219b : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 219d : 48 > pha ;use stack to load status 219e : a280 > ldx #$80 ;precharge index x 21a0 : 28 > plp 21a1 : e07f cpx #$7f tst_stat ~fnz 21a3 : 08 > php ;save status 21a4 : 68 > pla ;use stack to retrieve status 21a5 : 48 > pha > cmp_flag ~fnz 21a6 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 21a8 : d0fe > bne * ;failed not equal (non zero) > 21aa : 28 > plp ;restore status 21ab : ca dex 21ac : e07f cpx #$7f tst_stat ~fn 21ae : 08 > php ;save status 21af : 68 > pla ;use stack to retrieve status 21b0 : 48 > pha > cmp_flag ~fn 21b1 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits > > trap_ne 21b3 : d0fe > bne * ;failed not equal (non zero) > 21b5 : 28 > plp ;restore status 21b6 : ca dex 21b7 : e07f cpx #$7f tst_x $7e,~fzc 21b9 : 08 > php ;save flags 21ba : e07e > cpx #$7e ;test result > trap_ne 21bc : d0fe > bne * ;failed not equal (non zero) > 21be : 68 > pla ;load status 21bf : 48 > pha > cmp_flag ~fzc 21c0 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 21c2 : d0fe > bne * ;failed not equal (non zero) > 21c4 : 28 > plp ;restore status next_test 21c5 : ad0002 > lda test_case ;previous test 21c8 : c91a > cmp #test_num > trap_ne ;test is out of sequence 21ca : d0fe > bne * ;failed not equal (non zero) > 001b = >test_num = test_num + 1 21cc : a91b > lda #test_num ;*** next tests' number 21ce : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; CPY - zp / abs / # set_y $80,0 > load_flag 0 21d1 : a900 > lda #0 ;allow test to change I-flag (no mask) > 21d3 : 48 > pha ;use stack to load status 21d4 : a080 > ldy #$80 ;precharge index y 21d6 : 28 > plp 21d7 : c40d cpy zp7f tst_stat fc 21d9 : 08 > php ;save status 21da : 68 > pla ;use stack to retrieve status 21db : 48 > pha > cmp_flag fc 21dc : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits > > trap_ne 21de : d0fe > bne * ;failed not equal (non zero) > 21e0 : 28 > plp ;restore status 21e1 : 88 dey 21e2 : c40d cpy zp7f tst_stat fzc 21e4 : 08 > php ;save status 21e5 : 68 > pla ;use stack to retrieve status 21e6 : 48 > pha > cmp_flag fzc 21e7 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 21e9 : d0fe > bne * ;failed not equal (non zero) > 21eb : 28 > plp ;restore status 21ec : 88 dey 21ed : c40d cpy zp7f tst_y $7e,fn 21ef : 08 > php ;save flags 21f0 : c07e > cpy #$7e ;test result > trap_ne 21f2 : d0fe > bne * ;failed not equal (non zero) > 21f4 : 68 > pla ;load status 21f5 : 48 > pha > cmp_flag fn 21f6 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 21f8 : d0fe > bne * ;failed not equal (non zero) > 21fa : 28 > plp ;restore status set_y $80,$ff > load_flag $ff 21fb : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 21fd : 48 > pha ;use stack to load status 21fe : a080 > ldy #$80 ;precharge index y 2200 : 28 > plp 2201 : c40d cpy zp7f tst_stat ~fnz 2203 : 08 > php ;save status 2204 : 68 > pla ;use stack to retrieve status 2205 : 48 > pha > cmp_flag ~fnz 2206 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 2208 : d0fe > bne * ;failed not equal (non zero) > 220a : 28 > plp ;restore status 220b : 88 dey 220c : c40d cpy zp7f tst_stat ~fn 220e : 08 > php ;save status 220f : 68 > pla ;use stack to retrieve status 2210 : 48 > pha > cmp_flag ~fn 2211 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits > > trap_ne 2213 : d0fe > bne * ;failed not equal (non zero) > 2215 : 28 > plp ;restore status 2216 : 88 dey 2217 : c40d cpy zp7f tst_y $7e,~fzc 2219 : 08 > php ;save flags 221a : c07e > cpy #$7e ;test result > trap_ne 221c : d0fe > bne * ;failed not equal (non zero) > 221e : 68 > pla ;load status 221f : 48 > pha > cmp_flag ~fzc 2220 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 2222 : d0fe > bne * ;failed not equal (non zero) > 2224 : 28 > plp ;restore status set_y $80,0 > load_flag 0 2225 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2227 : 48 > pha ;use stack to load status 2228 : a080 > ldy #$80 ;precharge index y 222a : 28 > plp 222b : cc1b02 cpy abs7f tst_stat fc 222e : 08 > php ;save status 222f : 68 > pla ;use stack to retrieve status 2230 : 48 > pha > cmp_flag fc 2231 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits > > trap_ne 2233 : d0fe > bne * ;failed not equal (non zero) > 2235 : 28 > plp ;restore status 2236 : 88 dey 2237 : cc1b02 cpy abs7f tst_stat fzc 223a : 08 > php ;save status 223b : 68 > pla ;use stack to retrieve status 223c : 48 > pha > cmp_flag fzc 223d : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 223f : d0fe > bne * ;failed not equal (non zero) > 2241 : 28 > plp ;restore status 2242 : 88 dey 2243 : cc1b02 cpy abs7f tst_y $7e,fn 2246 : 08 > php ;save flags 2247 : c07e > cpy #$7e ;test result > trap_ne 2249 : d0fe > bne * ;failed not equal (non zero) > 224b : 68 > pla ;load status 224c : 48 > pha > cmp_flag fn 224d : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 224f : d0fe > bne * ;failed not equal (non zero) > 2251 : 28 > plp ;restore status set_y $80,$ff > load_flag $ff 2252 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2254 : 48 > pha ;use stack to load status 2255 : a080 > ldy #$80 ;precharge index y 2257 : 28 > plp 2258 : cc1b02 cpy abs7f tst_stat ~fnz 225b : 08 > php ;save status 225c : 68 > pla ;use stack to retrieve status 225d : 48 > pha > cmp_flag ~fnz 225e : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 2260 : d0fe > bne * ;failed not equal (non zero) > 2262 : 28 > plp ;restore status 2263 : 88 dey 2264 : cc1b02 cpy abs7f tst_stat ~fn 2267 : 08 > php ;save status 2268 : 68 > pla ;use stack to retrieve status 2269 : 48 > pha > cmp_flag ~fn 226a : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits > > trap_ne 226c : d0fe > bne * ;failed not equal (non zero) > 226e : 28 > plp ;restore status 226f : 88 dey 2270 : cc1b02 cpy abs7f tst_y $7e,~fzc 2273 : 08 > php ;save flags 2274 : c07e > cpy #$7e ;test result > trap_ne 2276 : d0fe > bne * ;failed not equal (non zero) > 2278 : 68 > pla ;load status 2279 : 48 > pha > cmp_flag ~fzc 227a : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 227c : d0fe > bne * ;failed not equal (non zero) > 227e : 28 > plp ;restore status set_y $80,0 > load_flag 0 227f : a900 > lda #0 ;allow test to change I-flag (no mask) > 2281 : 48 > pha ;use stack to load status 2282 : a080 > ldy #$80 ;precharge index y 2284 : 28 > plp 2285 : c07f cpy #$7f tst_stat fc 2287 : 08 > php ;save status 2288 : 68 > pla ;use stack to retrieve status 2289 : 48 > pha > cmp_flag fc 228a : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits > > trap_ne 228c : d0fe > bne * ;failed not equal (non zero) > 228e : 28 > plp ;restore status 228f : 88 dey 2290 : c07f cpy #$7f tst_stat fzc 2292 : 08 > php ;save status 2293 : 68 > pla ;use stack to retrieve status 2294 : 48 > pha > cmp_flag fzc 2295 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 2297 : d0fe > bne * ;failed not equal (non zero) > 2299 : 28 > plp ;restore status 229a : 88 dey 229b : c07f cpy #$7f tst_y $7e,fn 229d : 08 > php ;save flags 229e : c07e > cpy #$7e ;test result > trap_ne 22a0 : d0fe > bne * ;failed not equal (non zero) > 22a2 : 68 > pla ;load status 22a3 : 48 > pha > cmp_flag fn 22a4 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 22a6 : d0fe > bne * ;failed not equal (non zero) > 22a8 : 28 > plp ;restore status set_y $80,$ff > load_flag $ff 22a9 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 22ab : 48 > pha ;use stack to load status 22ac : a080 > ldy #$80 ;precharge index y 22ae : 28 > plp 22af : c07f cpy #$7f tst_stat ~fnz 22b1 : 08 > php ;save status 22b2 : 68 > pla ;use stack to retrieve status 22b3 : 48 > pha > cmp_flag ~fnz 22b4 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 22b6 : d0fe > bne * ;failed not equal (non zero) > 22b8 : 28 > plp ;restore status 22b9 : 88 dey 22ba : c07f cpy #$7f tst_stat ~fn 22bc : 08 > php ;save status 22bd : 68 > pla ;use stack to retrieve status 22be : 48 > pha > cmp_flag ~fn 22bf : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits > > trap_ne 22c1 : d0fe > bne * ;failed not equal (non zero) > 22c3 : 28 > plp ;restore status 22c4 : 88 dey 22c5 : c07f cpy #$7f tst_y $7e,~fzc 22c7 : 08 > php ;save flags 22c8 : c07e > cpy #$7e ;test result > trap_ne 22ca : d0fe > bne * ;failed not equal (non zero) > 22cc : 68 > pla ;load status 22cd : 48 > pha > cmp_flag ~fzc 22ce : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 22d0 : d0fe > bne * ;failed not equal (non zero) > 22d2 : 28 > plp ;restore status next_test 22d3 : ad0002 > lda test_case ;previous test 22d6 : c91b > cmp #test_num > trap_ne ;test is out of sequence 22d8 : d0fe > bne * ;failed not equal (non zero) > 001c = >test_num = test_num + 1 22da : a91c > lda #test_num ;*** next tests' number 22dc : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; CMP - zp / abs / # set_a $80,0 > load_flag 0 22df : a900 > lda #0 ;allow test to change I-flag (no mask) > 22e1 : 48 > pha ;use stack to load status 22e2 : a980 > lda #$80 ;precharge accu 22e4 : 28 > plp 22e5 : c50d cmp zp7f tst_a $80,fc 22e7 : 08 > php ;save flags 22e8 : c980 > cmp #$80 ;test result > trap_ne 22ea : d0fe > bne * ;failed not equal (non zero) > 22ec : 68 > pla ;load status 22ed : 48 > pha > cmp_flag fc 22ee : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits > > trap_ne 22f0 : d0fe > bne * ;failed not equal (non zero) > 22f2 : 28 > plp ;restore status set_a $7f,0 > load_flag 0 22f3 : a900 > lda #0 ;allow test to change I-flag (no mask) > 22f5 : 48 > pha ;use stack to load status 22f6 : a97f > lda #$7f ;precharge accu 22f8 : 28 > plp 22f9 : c50d cmp zp7f tst_a $7f,fzc 22fb : 08 > php ;save flags 22fc : c97f > cmp #$7f ;test result > trap_ne 22fe : d0fe > bne * ;failed not equal (non zero) > 2300 : 68 > pla ;load status 2301 : 48 > pha > cmp_flag fzc 2302 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 2304 : d0fe > bne * ;failed not equal (non zero) > 2306 : 28 > plp ;restore status set_a $7e,0 > load_flag 0 2307 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2309 : 48 > pha ;use stack to load status 230a : a97e > lda #$7e ;precharge accu 230c : 28 > plp 230d : c50d cmp zp7f tst_a $7e,fn 230f : 08 > php ;save flags 2310 : c97e > cmp #$7e ;test result > trap_ne 2312 : d0fe > bne * ;failed not equal (non zero) > 2314 : 68 > pla ;load status 2315 : 48 > pha > cmp_flag fn 2316 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 2318 : d0fe > bne * ;failed not equal (non zero) > 231a : 28 > plp ;restore status set_a $80,$ff > load_flag $ff 231b : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 231d : 48 > pha ;use stack to load status 231e : a980 > lda #$80 ;precharge accu 2320 : 28 > plp 2321 : c50d cmp zp7f tst_a $80,~fnz 2323 : 08 > php ;save flags 2324 : c980 > cmp #$80 ;test result > trap_ne 2326 : d0fe > bne * ;failed not equal (non zero) > 2328 : 68 > pla ;load status 2329 : 48 > pha > cmp_flag ~fnz 232a : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 232c : d0fe > bne * ;failed not equal (non zero) > 232e : 28 > plp ;restore status set_a $7f,$ff > load_flag $ff 232f : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2331 : 48 > pha ;use stack to load status 2332 : a97f > lda #$7f ;precharge accu 2334 : 28 > plp 2335 : c50d cmp zp7f tst_a $7f,~fn 2337 : 08 > php ;save flags 2338 : c97f > cmp #$7f ;test result > trap_ne 233a : d0fe > bne * ;failed not equal (non zero) > 233c : 68 > pla ;load status 233d : 48 > pha > cmp_flag ~fn 233e : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits > > trap_ne 2340 : d0fe > bne * ;failed not equal (non zero) > 2342 : 28 > plp ;restore status set_a $7e,$ff > load_flag $ff 2343 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2345 : 48 > pha ;use stack to load status 2346 : a97e > lda #$7e ;precharge accu 2348 : 28 > plp 2349 : c50d cmp zp7f tst_a $7e,~fzc 234b : 08 > php ;save flags 234c : c97e > cmp #$7e ;test result > trap_ne 234e : d0fe > bne * ;failed not equal (non zero) > 2350 : 68 > pla ;load status 2351 : 48 > pha > cmp_flag ~fzc 2352 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 2354 : d0fe > bne * ;failed not equal (non zero) > 2356 : 28 > plp ;restore status set_a $80,0 > load_flag 0 2357 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2359 : 48 > pha ;use stack to load status 235a : a980 > lda #$80 ;precharge accu 235c : 28 > plp 235d : cd1b02 cmp abs7f tst_a $80,fc 2360 : 08 > php ;save flags 2361 : c980 > cmp #$80 ;test result > trap_ne 2363 : d0fe > bne * ;failed not equal (non zero) > 2365 : 68 > pla ;load status 2366 : 48 > pha > cmp_flag fc 2367 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits > > trap_ne 2369 : d0fe > bne * ;failed not equal (non zero) > 236b : 28 > plp ;restore status set_a $7f,0 > load_flag 0 236c : a900 > lda #0 ;allow test to change I-flag (no mask) > 236e : 48 > pha ;use stack to load status 236f : a97f > lda #$7f ;precharge accu 2371 : 28 > plp 2372 : cd1b02 cmp abs7f tst_a $7f,fzc 2375 : 08 > php ;save flags 2376 : c97f > cmp #$7f ;test result > trap_ne 2378 : d0fe > bne * ;failed not equal (non zero) > 237a : 68 > pla ;load status 237b : 48 > pha > cmp_flag fzc 237c : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 237e : d0fe > bne * ;failed not equal (non zero) > 2380 : 28 > plp ;restore status set_a $7e,0 > load_flag 0 2381 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2383 : 48 > pha ;use stack to load status 2384 : a97e > lda #$7e ;precharge accu 2386 : 28 > plp 2387 : cd1b02 cmp abs7f tst_a $7e,fn 238a : 08 > php ;save flags 238b : c97e > cmp #$7e ;test result > trap_ne 238d : d0fe > bne * ;failed not equal (non zero) > 238f : 68 > pla ;load status 2390 : 48 > pha > cmp_flag fn 2391 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 2393 : d0fe > bne * ;failed not equal (non zero) > 2395 : 28 > plp ;restore status set_a $80,$ff > load_flag $ff 2396 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2398 : 48 > pha ;use stack to load status 2399 : a980 > lda #$80 ;precharge accu 239b : 28 > plp 239c : cd1b02 cmp abs7f tst_a $80,~fnz 239f : 08 > php ;save flags 23a0 : c980 > cmp #$80 ;test result > trap_ne 23a2 : d0fe > bne * ;failed not equal (non zero) > 23a4 : 68 > pla ;load status 23a5 : 48 > pha > cmp_flag ~fnz 23a6 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 23a8 : d0fe > bne * ;failed not equal (non zero) > 23aa : 28 > plp ;restore status set_a $7f,$ff > load_flag $ff 23ab : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 23ad : 48 > pha ;use stack to load status 23ae : a97f > lda #$7f ;precharge accu 23b0 : 28 > plp 23b1 : cd1b02 cmp abs7f tst_a $7f,~fn 23b4 : 08 > php ;save flags 23b5 : c97f > cmp #$7f ;test result > trap_ne 23b7 : d0fe > bne * ;failed not equal (non zero) > 23b9 : 68 > pla ;load status 23ba : 48 > pha > cmp_flag ~fn 23bb : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits > > trap_ne 23bd : d0fe > bne * ;failed not equal (non zero) > 23bf : 28 > plp ;restore status set_a $7e,$ff > load_flag $ff 23c0 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 23c2 : 48 > pha ;use stack to load status 23c3 : a97e > lda #$7e ;precharge accu 23c5 : 28 > plp 23c6 : cd1b02 cmp abs7f tst_a $7e,~fzc 23c9 : 08 > php ;save flags 23ca : c97e > cmp #$7e ;test result > trap_ne 23cc : d0fe > bne * ;failed not equal (non zero) > 23ce : 68 > pla ;load status 23cf : 48 > pha > cmp_flag ~fzc 23d0 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 23d2 : d0fe > bne * ;failed not equal (non zero) > 23d4 : 28 > plp ;restore status set_a $80,0 > load_flag 0 23d5 : a900 > lda #0 ;allow test to change I-flag (no mask) > 23d7 : 48 > pha ;use stack to load status 23d8 : a980 > lda #$80 ;precharge accu 23da : 28 > plp 23db : c97f cmp #$7f tst_a $80,fc 23dd : 08 > php ;save flags 23de : c980 > cmp #$80 ;test result > trap_ne 23e0 : d0fe > bne * ;failed not equal (non zero) > 23e2 : 68 > pla ;load status 23e3 : 48 > pha > cmp_flag fc 23e4 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits > > trap_ne 23e6 : d0fe > bne * ;failed not equal (non zero) > 23e8 : 28 > plp ;restore status set_a $7f,0 > load_flag 0 23e9 : a900 > lda #0 ;allow test to change I-flag (no mask) > 23eb : 48 > pha ;use stack to load status 23ec : a97f > lda #$7f ;precharge accu 23ee : 28 > plp 23ef : c97f cmp #$7f tst_a $7f,fzc 23f1 : 08 > php ;save flags 23f2 : c97f > cmp #$7f ;test result > trap_ne 23f4 : d0fe > bne * ;failed not equal (non zero) > 23f6 : 68 > pla ;load status 23f7 : 48 > pha > cmp_flag fzc 23f8 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 23fa : d0fe > bne * ;failed not equal (non zero) > 23fc : 28 > plp ;restore status set_a $7e,0 > load_flag 0 23fd : a900 > lda #0 ;allow test to change I-flag (no mask) > 23ff : 48 > pha ;use stack to load status 2400 : a97e > lda #$7e ;precharge accu 2402 : 28 > plp 2403 : c97f cmp #$7f tst_a $7e,fn 2405 : 08 > php ;save flags 2406 : c97e > cmp #$7e ;test result > trap_ne 2408 : d0fe > bne * ;failed not equal (non zero) > 240a : 68 > pla ;load status 240b : 48 > pha > cmp_flag fn 240c : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 240e : d0fe > bne * ;failed not equal (non zero) > 2410 : 28 > plp ;restore status set_a $80,$ff > load_flag $ff 2411 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2413 : 48 > pha ;use stack to load status 2414 : a980 > lda #$80 ;precharge accu 2416 : 28 > plp 2417 : c97f cmp #$7f tst_a $80,~fnz 2419 : 08 > php ;save flags 241a : c980 > cmp #$80 ;test result > trap_ne 241c : d0fe > bne * ;failed not equal (non zero) > 241e : 68 > pla ;load status 241f : 48 > pha > cmp_flag ~fnz 2420 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 2422 : d0fe > bne * ;failed not equal (non zero) > 2424 : 28 > plp ;restore status set_a $7f,$ff > load_flag $ff 2425 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2427 : 48 > pha ;use stack to load status 2428 : a97f > lda #$7f ;precharge accu 242a : 28 > plp 242b : c97f cmp #$7f tst_a $7f,~fn 242d : 08 > php ;save flags 242e : c97f > cmp #$7f ;test result > trap_ne 2430 : d0fe > bne * ;failed not equal (non zero) > 2432 : 68 > pla ;load status 2433 : 48 > pha > cmp_flag ~fn 2434 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits > > trap_ne 2436 : d0fe > bne * ;failed not equal (non zero) > 2438 : 28 > plp ;restore status set_a $7e,$ff > load_flag $ff 2439 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 243b : 48 > pha ;use stack to load status 243c : a97e > lda #$7e ;precharge accu 243e : 28 > plp 243f : c97f cmp #$7f tst_a $7e,~fzc 2441 : 08 > php ;save flags 2442 : c97e > cmp #$7e ;test result > trap_ne 2444 : d0fe > bne * ;failed not equal (non zero) > 2446 : 68 > pla ;load status 2447 : 48 > pha > cmp_flag ~fzc 2448 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 244a : d0fe > bne * ;failed not equal (non zero) > 244c : 28 > plp ;restore status 244d : a204 ldx #4 ;with indexing by X set_a $80,0 > load_flag 0 244f : a900 > lda #0 ;allow test to change I-flag (no mask) > 2451 : 48 > pha ;use stack to load status 2452 : a980 > lda #$80 ;precharge accu 2454 : 28 > plp 2455 : d509 cmp zp1,x tst_a $80,fc 2457 : 08 > php ;save flags 2458 : c980 > cmp #$80 ;test result > trap_ne 245a : d0fe > bne * ;failed not equal (non zero) > 245c : 68 > pla ;load status 245d : 48 > pha > cmp_flag fc 245e : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits > > trap_ne 2460 : d0fe > bne * ;failed not equal (non zero) > 2462 : 28 > plp ;restore status set_a $7f,0 > load_flag 0 2463 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2465 : 48 > pha ;use stack to load status 2466 : a97f > lda #$7f ;precharge accu 2468 : 28 > plp 2469 : d509 cmp zp1,x tst_a $7f,fzc 246b : 08 > php ;save flags 246c : c97f > cmp #$7f ;test result > trap_ne 246e : d0fe > bne * ;failed not equal (non zero) > 2470 : 68 > pla ;load status 2471 : 48 > pha > cmp_flag fzc 2472 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 2474 : d0fe > bne * ;failed not equal (non zero) > 2476 : 28 > plp ;restore status set_a $7e,0 > load_flag 0 2477 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2479 : 48 > pha ;use stack to load status 247a : a97e > lda #$7e ;precharge accu 247c : 28 > plp 247d : d509 cmp zp1,x tst_a $7e,fn 247f : 08 > php ;save flags 2480 : c97e > cmp #$7e ;test result > trap_ne 2482 : d0fe > bne * ;failed not equal (non zero) > 2484 : 68 > pla ;load status 2485 : 48 > pha > cmp_flag fn 2486 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 2488 : d0fe > bne * ;failed not equal (non zero) > 248a : 28 > plp ;restore status set_a $80,$ff > load_flag $ff 248b : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 248d : 48 > pha ;use stack to load status 248e : a980 > lda #$80 ;precharge accu 2490 : 28 > plp 2491 : d509 cmp zp1,x tst_a $80,~fnz 2493 : 08 > php ;save flags 2494 : c980 > cmp #$80 ;test result > trap_ne 2496 : d0fe > bne * ;failed not equal (non zero) > 2498 : 68 > pla ;load status 2499 : 48 > pha > cmp_flag ~fnz 249a : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 249c : d0fe > bne * ;failed not equal (non zero) > 249e : 28 > plp ;restore status set_a $7f,$ff > load_flag $ff 249f : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 24a1 : 48 > pha ;use stack to load status 24a2 : a97f > lda #$7f ;precharge accu 24a4 : 28 > plp 24a5 : d509 cmp zp1,x tst_a $7f,~fn 24a7 : 08 > php ;save flags 24a8 : c97f > cmp #$7f ;test result > trap_ne 24aa : d0fe > bne * ;failed not equal (non zero) > 24ac : 68 > pla ;load status 24ad : 48 > pha > cmp_flag ~fn 24ae : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits > > trap_ne 24b0 : d0fe > bne * ;failed not equal (non zero) > 24b2 : 28 > plp ;restore status set_a $7e,$ff > load_flag $ff 24b3 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 24b5 : 48 > pha ;use stack to load status 24b6 : a97e > lda #$7e ;precharge accu 24b8 : 28 > plp 24b9 : d509 cmp zp1,x tst_a $7e,~fzc 24bb : 08 > php ;save flags 24bc : c97e > cmp #$7e ;test result > trap_ne 24be : d0fe > bne * ;failed not equal (non zero) > 24c0 : 68 > pla ;load status 24c1 : 48 > pha > cmp_flag ~fzc 24c2 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 24c4 : d0fe > bne * ;failed not equal (non zero) > 24c6 : 28 > plp ;restore status set_a $80,0 > load_flag 0 24c7 : a900 > lda #0 ;allow test to change I-flag (no mask) > 24c9 : 48 > pha ;use stack to load status 24ca : a980 > lda #$80 ;precharge accu 24cc : 28 > plp 24cd : dd1702 cmp abs1,x tst_a $80,fc 24d0 : 08 > php ;save flags 24d1 : c980 > cmp #$80 ;test result > trap_ne 24d3 : d0fe > bne * ;failed not equal (non zero) > 24d5 : 68 > pla ;load status 24d6 : 48 > pha > cmp_flag fc 24d7 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits > > trap_ne 24d9 : d0fe > bne * ;failed not equal (non zero) > 24db : 28 > plp ;restore status set_a $7f,0 > load_flag 0 24dc : a900 > lda #0 ;allow test to change I-flag (no mask) > 24de : 48 > pha ;use stack to load status 24df : a97f > lda #$7f ;precharge accu 24e1 : 28 > plp 24e2 : dd1702 cmp abs1,x tst_a $7f,fzc 24e5 : 08 > php ;save flags 24e6 : c97f > cmp #$7f ;test result > trap_ne 24e8 : d0fe > bne * ;failed not equal (non zero) > 24ea : 68 > pla ;load status 24eb : 48 > pha > cmp_flag fzc 24ec : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 24ee : d0fe > bne * ;failed not equal (non zero) > 24f0 : 28 > plp ;restore status set_a $7e,0 > load_flag 0 24f1 : a900 > lda #0 ;allow test to change I-flag (no mask) > 24f3 : 48 > pha ;use stack to load status 24f4 : a97e > lda #$7e ;precharge accu 24f6 : 28 > plp 24f7 : dd1702 cmp abs1,x tst_a $7e,fn 24fa : 08 > php ;save flags 24fb : c97e > cmp #$7e ;test result > trap_ne 24fd : d0fe > bne * ;failed not equal (non zero) > 24ff : 68 > pla ;load status 2500 : 48 > pha > cmp_flag fn 2501 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 2503 : d0fe > bne * ;failed not equal (non zero) > 2505 : 28 > plp ;restore status set_a $80,$ff > load_flag $ff 2506 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2508 : 48 > pha ;use stack to load status 2509 : a980 > lda #$80 ;precharge accu 250b : 28 > plp 250c : dd1702 cmp abs1,x tst_a $80,~fnz 250f : 08 > php ;save flags 2510 : c980 > cmp #$80 ;test result > trap_ne 2512 : d0fe > bne * ;failed not equal (non zero) > 2514 : 68 > pla ;load status 2515 : 48 > pha > cmp_flag ~fnz 2516 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 2518 : d0fe > bne * ;failed not equal (non zero) > 251a : 28 > plp ;restore status set_a $7f,$ff > load_flag $ff 251b : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 251d : 48 > pha ;use stack to load status 251e : a97f > lda #$7f ;precharge accu 2520 : 28 > plp 2521 : dd1702 cmp abs1,x tst_a $7f,~fn 2524 : 08 > php ;save flags 2525 : c97f > cmp #$7f ;test result > trap_ne 2527 : d0fe > bne * ;failed not equal (non zero) > 2529 : 68 > pla ;load status 252a : 48 > pha > cmp_flag ~fn 252b : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits > > trap_ne 252d : d0fe > bne * ;failed not equal (non zero) > 252f : 28 > plp ;restore status set_a $7e,$ff > load_flag $ff 2530 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2532 : 48 > pha ;use stack to load status 2533 : a97e > lda #$7e ;precharge accu 2535 : 28 > plp 2536 : dd1702 cmp abs1,x tst_a $7e,~fzc 2539 : 08 > php ;save flags 253a : c97e > cmp #$7e ;test result > trap_ne 253c : d0fe > bne * ;failed not equal (non zero) > 253e : 68 > pla ;load status 253f : 48 > pha > cmp_flag ~fzc 2540 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 2542 : d0fe > bne * ;failed not equal (non zero) > 2544 : 28 > plp ;restore status 2545 : a004 ldy #4 ;with indexing by Y 2547 : a208 ldx #8 ;with indexed indirect set_a $80,0 > load_flag 0 2549 : a900 > lda #0 ;allow test to change I-flag (no mask) > 254b : 48 > pha ;use stack to load status 254c : a980 > lda #$80 ;precharge accu 254e : 28 > plp 254f : d91702 cmp abs1,y tst_a $80,fc 2552 : 08 > php ;save flags 2553 : c980 > cmp #$80 ;test result > trap_ne 2555 : d0fe > bne * ;failed not equal (non zero) > 2557 : 68 > pla ;load status 2558 : 48 > pha > cmp_flag fc 2559 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits > > trap_ne 255b : d0fe > bne * ;failed not equal (non zero) > 255d : 28 > plp ;restore status set_a $7f,0 > load_flag 0 255e : a900 > lda #0 ;allow test to change I-flag (no mask) > 2560 : 48 > pha ;use stack to load status 2561 : a97f > lda #$7f ;precharge accu 2563 : 28 > plp 2564 : d91702 cmp abs1,y tst_a $7f,fzc 2567 : 08 > php ;save flags 2568 : c97f > cmp #$7f ;test result > trap_ne 256a : d0fe > bne * ;failed not equal (non zero) > 256c : 68 > pla ;load status 256d : 48 > pha > cmp_flag fzc 256e : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 2570 : d0fe > bne * ;failed not equal (non zero) > 2572 : 28 > plp ;restore status set_a $7e,0 > load_flag 0 2573 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2575 : 48 > pha ;use stack to load status 2576 : a97e > lda #$7e ;precharge accu 2578 : 28 > plp 2579 : d91702 cmp abs1,y tst_a $7e,fn 257c : 08 > php ;save flags 257d : c97e > cmp #$7e ;test result > trap_ne 257f : d0fe > bne * ;failed not equal (non zero) > 2581 : 68 > pla ;load status 2582 : 48 > pha > cmp_flag fn 2583 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 2585 : d0fe > bne * ;failed not equal (non zero) > 2587 : 28 > plp ;restore status set_a $80,$ff > load_flag $ff 2588 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 258a : 48 > pha ;use stack to load status 258b : a980 > lda #$80 ;precharge accu 258d : 28 > plp 258e : d91702 cmp abs1,y tst_a $80,~fnz 2591 : 08 > php ;save flags 2592 : c980 > cmp #$80 ;test result > trap_ne 2594 : d0fe > bne * ;failed not equal (non zero) > 2596 : 68 > pla ;load status 2597 : 48 > pha > cmp_flag ~fnz 2598 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 259a : d0fe > bne * ;failed not equal (non zero) > 259c : 28 > plp ;restore status set_a $7f,$ff > load_flag $ff 259d : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 259f : 48 > pha ;use stack to load status 25a0 : a97f > lda #$7f ;precharge accu 25a2 : 28 > plp 25a3 : d91702 cmp abs1,y tst_a $7f,~fn 25a6 : 08 > php ;save flags 25a7 : c97f > cmp #$7f ;test result > trap_ne 25a9 : d0fe > bne * ;failed not equal (non zero) > 25ab : 68 > pla ;load status 25ac : 48 > pha > cmp_flag ~fn 25ad : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits > > trap_ne 25af : d0fe > bne * ;failed not equal (non zero) > 25b1 : 28 > plp ;restore status set_a $7e,$ff > load_flag $ff 25b2 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 25b4 : 48 > pha ;use stack to load status 25b5 : a97e > lda #$7e ;precharge accu 25b7 : 28 > plp 25b8 : d91702 cmp abs1,y tst_a $7e,~fzc 25bb : 08 > php ;save flags 25bc : c97e > cmp #$7e ;test result > trap_ne 25be : d0fe > bne * ;failed not equal (non zero) > 25c0 : 68 > pla ;load status 25c1 : 48 > pha > cmp_flag ~fzc 25c2 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 25c4 : d0fe > bne * ;failed not equal (non zero) > 25c6 : 28 > plp ;restore status set_a $80,0 > load_flag 0 25c7 : a900 > lda #0 ;allow test to change I-flag (no mask) > 25c9 : 48 > pha ;use stack to load status 25ca : a980 > lda #$80 ;precharge accu 25cc : 28 > plp 25cd : c11a cmp (ind1,x) tst_a $80,fc 25cf : 08 > php ;save flags 25d0 : c980 > cmp #$80 ;test result > trap_ne 25d2 : d0fe > bne * ;failed not equal (non zero) > 25d4 : 68 > pla ;load status 25d5 : 48 > pha > cmp_flag fc 25d6 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits > > trap_ne 25d8 : d0fe > bne * ;failed not equal (non zero) > 25da : 28 > plp ;restore status set_a $7f,0 > load_flag 0 25db : a900 > lda #0 ;allow test to change I-flag (no mask) > 25dd : 48 > pha ;use stack to load status 25de : a97f > lda #$7f ;precharge accu 25e0 : 28 > plp 25e1 : c11a cmp (ind1,x) tst_a $7f,fzc 25e3 : 08 > php ;save flags 25e4 : c97f > cmp #$7f ;test result > trap_ne 25e6 : d0fe > bne * ;failed not equal (non zero) > 25e8 : 68 > pla ;load status 25e9 : 48 > pha > cmp_flag fzc 25ea : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 25ec : d0fe > bne * ;failed not equal (non zero) > 25ee : 28 > plp ;restore status set_a $7e,0 > load_flag 0 25ef : a900 > lda #0 ;allow test to change I-flag (no mask) > 25f1 : 48 > pha ;use stack to load status 25f2 : a97e > lda #$7e ;precharge accu 25f4 : 28 > plp 25f5 : c11a cmp (ind1,x) tst_a $7e,fn 25f7 : 08 > php ;save flags 25f8 : c97e > cmp #$7e ;test result > trap_ne 25fa : d0fe > bne * ;failed not equal (non zero) > 25fc : 68 > pla ;load status 25fd : 48 > pha > cmp_flag fn 25fe : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 2600 : d0fe > bne * ;failed not equal (non zero) > 2602 : 28 > plp ;restore status set_a $80,$ff > load_flag $ff 2603 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2605 : 48 > pha ;use stack to load status 2606 : a980 > lda #$80 ;precharge accu 2608 : 28 > plp 2609 : c11a cmp (ind1,x) tst_a $80,~fnz 260b : 08 > php ;save flags 260c : c980 > cmp #$80 ;test result > trap_ne 260e : d0fe > bne * ;failed not equal (non zero) > 2610 : 68 > pla ;load status 2611 : 48 > pha > cmp_flag ~fnz 2612 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 2614 : d0fe > bne * ;failed not equal (non zero) > 2616 : 28 > plp ;restore status set_a $7f,$ff > load_flag $ff 2617 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2619 : 48 > pha ;use stack to load status 261a : a97f > lda #$7f ;precharge accu 261c : 28 > plp 261d : c11a cmp (ind1,x) tst_a $7f,~fn 261f : 08 > php ;save flags 2620 : c97f > cmp #$7f ;test result > trap_ne 2622 : d0fe > bne * ;failed not equal (non zero) > 2624 : 68 > pla ;load status 2625 : 48 > pha > cmp_flag ~fn 2626 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits > > trap_ne 2628 : d0fe > bne * ;failed not equal (non zero) > 262a : 28 > plp ;restore status set_a $7e,$ff > load_flag $ff 262b : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 262d : 48 > pha ;use stack to load status 262e : a97e > lda #$7e ;precharge accu 2630 : 28 > plp 2631 : c11a cmp (ind1,x) tst_a $7e,~fzc 2633 : 08 > php ;save flags 2634 : c97e > cmp #$7e ;test result > trap_ne 2636 : d0fe > bne * ;failed not equal (non zero) > 2638 : 68 > pla ;load status 2639 : 48 > pha > cmp_flag ~fzc 263a : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 263c : d0fe > bne * ;failed not equal (non zero) > 263e : 28 > plp ;restore status set_a $80,0 > load_flag 0 263f : a900 > lda #0 ;allow test to change I-flag (no mask) > 2641 : 48 > pha ;use stack to load status 2642 : a980 > lda #$80 ;precharge accu 2644 : 28 > plp 2645 : d11a cmp (ind1),y tst_a $80,fc 2647 : 08 > php ;save flags 2648 : c980 > cmp #$80 ;test result > trap_ne 264a : d0fe > bne * ;failed not equal (non zero) > 264c : 68 > pla ;load status 264d : 48 > pha > cmp_flag fc 264e : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits > > trap_ne 2650 : d0fe > bne * ;failed not equal (non zero) > 2652 : 28 > plp ;restore status set_a $7f,0 > load_flag 0 2653 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2655 : 48 > pha ;use stack to load status 2656 : a97f > lda #$7f ;precharge accu 2658 : 28 > plp 2659 : d11a cmp (ind1),y tst_a $7f,fzc 265b : 08 > php ;save flags 265c : c97f > cmp #$7f ;test result > trap_ne 265e : d0fe > bne * ;failed not equal (non zero) > 2660 : 68 > pla ;load status 2661 : 48 > pha > cmp_flag fzc 2662 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 2664 : d0fe > bne * ;failed not equal (non zero) > 2666 : 28 > plp ;restore status set_a $7e,0 > load_flag 0 2667 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2669 : 48 > pha ;use stack to load status 266a : a97e > lda #$7e ;precharge accu 266c : 28 > plp 266d : d11a cmp (ind1),y tst_a $7e,fn 266f : 08 > php ;save flags 2670 : c97e > cmp #$7e ;test result > trap_ne 2672 : d0fe > bne * ;failed not equal (non zero) > 2674 : 68 > pla ;load status 2675 : 48 > pha > cmp_flag fn 2676 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 2678 : d0fe > bne * ;failed not equal (non zero) > 267a : 28 > plp ;restore status set_a $80,$ff > load_flag $ff 267b : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 267d : 48 > pha ;use stack to load status 267e : a980 > lda #$80 ;precharge accu 2680 : 28 > plp 2681 : d11a cmp (ind1),y tst_a $80,~fnz 2683 : 08 > php ;save flags 2684 : c980 > cmp #$80 ;test result > trap_ne 2686 : d0fe > bne * ;failed not equal (non zero) > 2688 : 68 > pla ;load status 2689 : 48 > pha > cmp_flag ~fnz 268a : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 268c : d0fe > bne * ;failed not equal (non zero) > 268e : 28 > plp ;restore status set_a $7f,$ff > load_flag $ff 268f : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2691 : 48 > pha ;use stack to load status 2692 : a97f > lda #$7f ;precharge accu 2694 : 28 > plp 2695 : d11a cmp (ind1),y tst_a $7f,~fn 2697 : 08 > php ;save flags 2698 : c97f > cmp #$7f ;test result > trap_ne 269a : d0fe > bne * ;failed not equal (non zero) > 269c : 68 > pla ;load status 269d : 48 > pha > cmp_flag ~fn 269e : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits > > trap_ne 26a0 : d0fe > bne * ;failed not equal (non zero) > 26a2 : 28 > plp ;restore status set_a $7e,$ff > load_flag $ff 26a3 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 26a5 : 48 > pha ;use stack to load status 26a6 : a97e > lda #$7e ;precharge accu 26a8 : 28 > plp 26a9 : d11a cmp (ind1),y tst_a $7e,~fzc 26ab : 08 > php ;save flags 26ac : c97e > cmp #$7e ;test result > trap_ne 26ae : d0fe > bne * ;failed not equal (non zero) > 26b0 : 68 > pla ;load status 26b1 : 48 > pha > cmp_flag ~fzc 26b2 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 26b4 : d0fe > bne * ;failed not equal (non zero) > 26b6 : 28 > plp ;restore status next_test 26b7 : ad0002 > lda test_case ;previous test 26ba : c91c > cmp #test_num > trap_ne ;test is out of sequence 26bc : d0fe > bne * ;failed not equal (non zero) > 001d = >test_num = test_num + 1 26be : a91d > lda #test_num ;*** next tests' number 26c0 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; testing shifts - ASL LSR ROL ROR all addressing modes ; shifts - accumulator 26c3 : a203 ldx #3 26c5 : tasl set_ax zp1,0 > load_flag 0 26c5 : a900 > lda #0 ;allow test to change I-flag (no mask) > 26c7 : 48 > pha ;use stack to load status 26c8 : b509 > lda zp1,x ;precharge accu 26ca : 28 > plp 26cb : 0a asl a tst_ax rASL,fASL,0 26cc : 08 > php ;save flags 26cd : dd2002 > cmp rASL,x ;test result > trap_ne 26d0 : d0fe > bne * ;failed not equal (non zero) > 26d2 : 68 > pla ;load status > eor_flag 0 26d3 : 4930 > eor #0|fao ;invert expected flags + always on bits > 26d5 : dd3002 > cmp fASL,x ;test flags > trap_ne ; 26d8 : d0fe > bne * ;failed not equal (non zero) > 26da : ca dex 26db : 10e8 bpl tasl 26dd : a203 ldx #3 26df : tasl1 set_ax zp1,$ff > load_flag $ff 26df : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 26e1 : 48 > pha ;use stack to load status 26e2 : b509 > lda zp1,x ;precharge accu 26e4 : 28 > plp 26e5 : 0a asl a tst_ax rASL,fASL,$ff-fnzc 26e6 : 08 > php ;save flags 26e7 : dd2002 > cmp rASL,x ;test result > trap_ne 26ea : d0fe > bne * ;failed not equal (non zero) > 26ec : 68 > pla ;load status > eor_flag $ff-fnzc 26ed : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 26ef : dd3002 > cmp fASL,x ;test flags > trap_ne ; 26f2 : d0fe > bne * ;failed not equal (non zero) > 26f4 : ca dex 26f5 : 10e8 bpl tasl1 26f7 : a203 ldx #3 26f9 : tlsr set_ax zp1,0 > load_flag 0 26f9 : a900 > lda #0 ;allow test to change I-flag (no mask) > 26fb : 48 > pha ;use stack to load status 26fc : b509 > lda zp1,x ;precharge accu 26fe : 28 > plp 26ff : 4a lsr a tst_ax rLSR,fLSR,0 2700 : 08 > php ;save flags 2701 : dd2802 > cmp rLSR,x ;test result > trap_ne 2704 : d0fe > bne * ;failed not equal (non zero) > 2706 : 68 > pla ;load status > eor_flag 0 2707 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2709 : dd3802 > cmp fLSR,x ;test flags > trap_ne ; 270c : d0fe > bne * ;failed not equal (non zero) > 270e : ca dex 270f : 10e8 bpl tlsr 2711 : a203 ldx #3 2713 : tlsr1 set_ax zp1,$ff > load_flag $ff 2713 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2715 : 48 > pha ;use stack to load status 2716 : b509 > lda zp1,x ;precharge accu 2718 : 28 > plp 2719 : 4a lsr a tst_ax rLSR,fLSR,$ff-fnzc 271a : 08 > php ;save flags 271b : dd2802 > cmp rLSR,x ;test result > trap_ne 271e : d0fe > bne * ;failed not equal (non zero) > 2720 : 68 > pla ;load status > eor_flag $ff-fnzc 2721 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2723 : dd3802 > cmp fLSR,x ;test flags > trap_ne ; 2726 : d0fe > bne * ;failed not equal (non zero) > 2728 : ca dex 2729 : 10e8 bpl tlsr1 272b : a203 ldx #3 272d : trol set_ax zp1,0 > load_flag 0 272d : a900 > lda #0 ;allow test to change I-flag (no mask) > 272f : 48 > pha ;use stack to load status 2730 : b509 > lda zp1,x ;precharge accu 2732 : 28 > plp 2733 : 2a rol a tst_ax rROL,fROL,0 2734 : 08 > php ;save flags 2735 : dd2002 > cmp rROL,x ;test result > trap_ne 2738 : d0fe > bne * ;failed not equal (non zero) > 273a : 68 > pla ;load status > eor_flag 0 273b : 4930 > eor #0|fao ;invert expected flags + always on bits > 273d : dd3002 > cmp fROL,x ;test flags > trap_ne ; 2740 : d0fe > bne * ;failed not equal (non zero) > 2742 : ca dex 2743 : 10e8 bpl trol 2745 : a203 ldx #3 2747 : trol1 set_ax zp1,$ff-fc > load_flag $ff-fc 2747 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) > 2749 : 48 > pha ;use stack to load status 274a : b509 > lda zp1,x ;precharge accu 274c : 28 > plp 274d : 2a rol a tst_ax rROL,fROL,$ff-fnzc 274e : 08 > php ;save flags 274f : dd2002 > cmp rROL,x ;test result > trap_ne 2752 : d0fe > bne * ;failed not equal (non zero) > 2754 : 68 > pla ;load status > eor_flag $ff-fnzc 2755 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2757 : dd3002 > cmp fROL,x ;test flags > trap_ne ; 275a : d0fe > bne * ;failed not equal (non zero) > 275c : ca dex 275d : 10e8 bpl trol1 275f : a203 ldx #3 2761 : trolc set_ax zp1,fc > load_flag fc 2761 : a901 > lda #fc ;allow test to change I-flag (no mask) > 2763 : 48 > pha ;use stack to load status 2764 : b509 > lda zp1,x ;precharge accu 2766 : 28 > plp 2767 : 2a rol a tst_ax rROLc,fROLc,0 2768 : 08 > php ;save flags 2769 : dd2402 > cmp rROLc,x ;test result > trap_ne 276c : d0fe > bne * ;failed not equal (non zero) > 276e : 68 > pla ;load status > eor_flag 0 276f : 4930 > eor #0|fao ;invert expected flags + always on bits > 2771 : dd3402 > cmp fROLc,x ;test flags > trap_ne ; 2774 : d0fe > bne * ;failed not equal (non zero) > 2776 : ca dex 2777 : 10e8 bpl trolc 2779 : a203 ldx #3 277b : trolc1 set_ax zp1,$ff > load_flag $ff 277b : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 277d : 48 > pha ;use stack to load status 277e : b509 > lda zp1,x ;precharge accu 2780 : 28 > plp 2781 : 2a rol a tst_ax rROLc,fROLc,$ff-fnzc 2782 : 08 > php ;save flags 2783 : dd2402 > cmp rROLc,x ;test result > trap_ne 2786 : d0fe > bne * ;failed not equal (non zero) > 2788 : 68 > pla ;load status > eor_flag $ff-fnzc 2789 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 278b : dd3402 > cmp fROLc,x ;test flags > trap_ne ; 278e : d0fe > bne * ;failed not equal (non zero) > 2790 : ca dex 2791 : 10e8 bpl trolc1 2793 : a203 ldx #3 2795 : tror set_ax zp1,0 > load_flag 0 2795 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2797 : 48 > pha ;use stack to load status 2798 : b509 > lda zp1,x ;precharge accu 279a : 28 > plp 279b : 6a ror a tst_ax rROR,fROR,0 279c : 08 > php ;save flags 279d : dd2802 > cmp rROR,x ;test result > trap_ne 27a0 : d0fe > bne * ;failed not equal (non zero) > 27a2 : 68 > pla ;load status > eor_flag 0 27a3 : 4930 > eor #0|fao ;invert expected flags + always on bits > 27a5 : dd3802 > cmp fROR,x ;test flags > trap_ne ; 27a8 : d0fe > bne * ;failed not equal (non zero) > 27aa : ca dex 27ab : 10e8 bpl tror 27ad : a203 ldx #3 27af : tror1 set_ax zp1,$ff-fc > load_flag $ff-fc 27af : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) > 27b1 : 48 > pha ;use stack to load status 27b2 : b509 > lda zp1,x ;precharge accu 27b4 : 28 > plp 27b5 : 6a ror a tst_ax rROR,fROR,$ff-fnzc 27b6 : 08 > php ;save flags 27b7 : dd2802 > cmp rROR,x ;test result > trap_ne 27ba : d0fe > bne * ;failed not equal (non zero) > 27bc : 68 > pla ;load status > eor_flag $ff-fnzc 27bd : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 27bf : dd3802 > cmp fROR,x ;test flags > trap_ne ; 27c2 : d0fe > bne * ;failed not equal (non zero) > 27c4 : ca dex 27c5 : 10e8 bpl tror1 27c7 : a203 ldx #3 27c9 : trorc set_ax zp1,fc > load_flag fc 27c9 : a901 > lda #fc ;allow test to change I-flag (no mask) > 27cb : 48 > pha ;use stack to load status 27cc : b509 > lda zp1,x ;precharge accu 27ce : 28 > plp 27cf : 6a ror a tst_ax rRORc,fRORc,0 27d0 : 08 > php ;save flags 27d1 : dd2c02 > cmp rRORc,x ;test result > trap_ne 27d4 : d0fe > bne * ;failed not equal (non zero) > 27d6 : 68 > pla ;load status > eor_flag 0 27d7 : 4930 > eor #0|fao ;invert expected flags + always on bits > 27d9 : dd3c02 > cmp fRORc,x ;test flags > trap_ne ; 27dc : d0fe > bne * ;failed not equal (non zero) > 27de : ca dex 27df : 10e8 bpl trorc 27e1 : a203 ldx #3 27e3 : trorc1 set_ax zp1,$ff > load_flag $ff 27e3 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 27e5 : 48 > pha ;use stack to load status 27e6 : b509 > lda zp1,x ;precharge accu 27e8 : 28 > plp 27e9 : 6a ror a tst_ax rRORc,fRORc,$ff-fnzc 27ea : 08 > php ;save flags 27eb : dd2c02 > cmp rRORc,x ;test result > trap_ne 27ee : d0fe > bne * ;failed not equal (non zero) > 27f0 : 68 > pla ;load status > eor_flag $ff-fnzc 27f1 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 27f3 : dd3c02 > cmp fRORc,x ;test flags > trap_ne ; 27f6 : d0fe > bne * ;failed not equal (non zero) > 27f8 : ca dex 27f9 : 10e8 bpl trorc1 next_test 27fb : ad0002 > lda test_case ;previous test 27fe : c91d > cmp #test_num > trap_ne ;test is out of sequence 2800 : d0fe > bne * ;failed not equal (non zero) > 001e = >test_num = test_num + 1 2802 : a91e > lda #test_num ;*** next tests' number 2804 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; shifts - zeropage 2807 : a203 ldx #3 2809 : tasl2 set_z zp1,0 > load_flag 0 2809 : a900 > lda #0 ;allow test to change I-flag (no mask) > 280b : 48 > pha ;use stack to load status 280c : b509 > lda zp1,x ;load to zeropage 280e : 8502 > sta zpt 2810 : 28 > plp 2811 : 0602 asl zpt tst_z rASL,fASL,0 2813 : 08 > php ;save flags 2814 : a502 > lda zpt 2816 : dd2002 > cmp rASL,x ;test result > trap_ne 2819 : d0fe > bne * ;failed not equal (non zero) > 281b : 68 > pla ;load status > eor_flag 0 281c : 4930 > eor #0|fao ;invert expected flags + always on bits > 281e : dd3002 > cmp fASL,x ;test flags > trap_ne 2821 : d0fe > bne * ;failed not equal (non zero) > 2823 : ca dex 2824 : 10e3 bpl tasl2 2826 : a203 ldx #3 2828 : tasl3 set_z zp1,$ff > load_flag $ff 2828 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 282a : 48 > pha ;use stack to load status 282b : b509 > lda zp1,x ;load to zeropage 282d : 8502 > sta zpt 282f : 28 > plp 2830 : 0602 asl zpt tst_z rASL,fASL,$ff-fnzc 2832 : 08 > php ;save flags 2833 : a502 > lda zpt 2835 : dd2002 > cmp rASL,x ;test result > trap_ne 2838 : d0fe > bne * ;failed not equal (non zero) > 283a : 68 > pla ;load status > eor_flag $ff-fnzc 283b : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 283d : dd3002 > cmp fASL,x ;test flags > trap_ne 2840 : d0fe > bne * ;failed not equal (non zero) > 2842 : ca dex 2843 : 10e3 bpl tasl3 2845 : a203 ldx #3 2847 : tlsr2 set_z zp1,0 > load_flag 0 2847 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2849 : 48 > pha ;use stack to load status 284a : b509 > lda zp1,x ;load to zeropage 284c : 8502 > sta zpt 284e : 28 > plp 284f : 4602 lsr zpt tst_z rLSR,fLSR,0 2851 : 08 > php ;save flags 2852 : a502 > lda zpt 2854 : dd2802 > cmp rLSR,x ;test result > trap_ne 2857 : d0fe > bne * ;failed not equal (non zero) > 2859 : 68 > pla ;load status > eor_flag 0 285a : 4930 > eor #0|fao ;invert expected flags + always on bits > 285c : dd3802 > cmp fLSR,x ;test flags > trap_ne 285f : d0fe > bne * ;failed not equal (non zero) > 2861 : ca dex 2862 : 10e3 bpl tlsr2 2864 : a203 ldx #3 2866 : tlsr3 set_z zp1,$ff > load_flag $ff 2866 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2868 : 48 > pha ;use stack to load status 2869 : b509 > lda zp1,x ;load to zeropage 286b : 8502 > sta zpt 286d : 28 > plp 286e : 4602 lsr zpt tst_z rLSR,fLSR,$ff-fnzc 2870 : 08 > php ;save flags 2871 : a502 > lda zpt 2873 : dd2802 > cmp rLSR,x ;test result > trap_ne 2876 : d0fe > bne * ;failed not equal (non zero) > 2878 : 68 > pla ;load status > eor_flag $ff-fnzc 2879 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 287b : dd3802 > cmp fLSR,x ;test flags > trap_ne 287e : d0fe > bne * ;failed not equal (non zero) > 2880 : ca dex 2881 : 10e3 bpl tlsr3 2883 : a203 ldx #3 2885 : trol2 set_z zp1,0 > load_flag 0 2885 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2887 : 48 > pha ;use stack to load status 2888 : b509 > lda zp1,x ;load to zeropage 288a : 8502 > sta zpt 288c : 28 > plp 288d : 2602 rol zpt tst_z rROL,fROL,0 288f : 08 > php ;save flags 2890 : a502 > lda zpt 2892 : dd2002 > cmp rROL,x ;test result > trap_ne 2895 : d0fe > bne * ;failed not equal (non zero) > 2897 : 68 > pla ;load status > eor_flag 0 2898 : 4930 > eor #0|fao ;invert expected flags + always on bits > 289a : dd3002 > cmp fROL,x ;test flags > trap_ne 289d : d0fe > bne * ;failed not equal (non zero) > 289f : ca dex 28a0 : 10e3 bpl trol2 28a2 : a203 ldx #3 28a4 : trol3 set_z zp1,$ff-fc > load_flag $ff-fc 28a4 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) > 28a6 : 48 > pha ;use stack to load status 28a7 : b509 > lda zp1,x ;load to zeropage 28a9 : 8502 > sta zpt 28ab : 28 > plp 28ac : 2602 rol zpt tst_z rROL,fROL,$ff-fnzc 28ae : 08 > php ;save flags 28af : a502 > lda zpt 28b1 : dd2002 > cmp rROL,x ;test result > trap_ne 28b4 : d0fe > bne * ;failed not equal (non zero) > 28b6 : 68 > pla ;load status > eor_flag $ff-fnzc 28b7 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 28b9 : dd3002 > cmp fROL,x ;test flags > trap_ne 28bc : d0fe > bne * ;failed not equal (non zero) > 28be : ca dex 28bf : 10e3 bpl trol3 28c1 : a203 ldx #3 28c3 : trolc2 set_z zp1,fc > load_flag fc 28c3 : a901 > lda #fc ;allow test to change I-flag (no mask) > 28c5 : 48 > pha ;use stack to load status 28c6 : b509 > lda zp1,x ;load to zeropage 28c8 : 8502 > sta zpt 28ca : 28 > plp 28cb : 2602 rol zpt tst_z rROLc,fROLc,0 28cd : 08 > php ;save flags 28ce : a502 > lda zpt 28d0 : dd2402 > cmp rROLc,x ;test result > trap_ne 28d3 : d0fe > bne * ;failed not equal (non zero) > 28d5 : 68 > pla ;load status > eor_flag 0 28d6 : 4930 > eor #0|fao ;invert expected flags + always on bits > 28d8 : dd3402 > cmp fROLc,x ;test flags > trap_ne 28db : d0fe > bne * ;failed not equal (non zero) > 28dd : ca dex 28de : 10e3 bpl trolc2 28e0 : a203 ldx #3 28e2 : trolc3 set_z zp1,$ff > load_flag $ff 28e2 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 28e4 : 48 > pha ;use stack to load status 28e5 : b509 > lda zp1,x ;load to zeropage 28e7 : 8502 > sta zpt 28e9 : 28 > plp 28ea : 2602 rol zpt tst_z rROLc,fROLc,$ff-fnzc 28ec : 08 > php ;save flags 28ed : a502 > lda zpt 28ef : dd2402 > cmp rROLc,x ;test result > trap_ne 28f2 : d0fe > bne * ;failed not equal (non zero) > 28f4 : 68 > pla ;load status > eor_flag $ff-fnzc 28f5 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 28f7 : dd3402 > cmp fROLc,x ;test flags > trap_ne 28fa : d0fe > bne * ;failed not equal (non zero) > 28fc : ca dex 28fd : 10e3 bpl trolc3 28ff : a203 ldx #3 2901 : tror2 set_z zp1,0 > load_flag 0 2901 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2903 : 48 > pha ;use stack to load status 2904 : b509 > lda zp1,x ;load to zeropage 2906 : 8502 > sta zpt 2908 : 28 > plp 2909 : 6602 ror zpt tst_z rROR,fROR,0 290b : 08 > php ;save flags 290c : a502 > lda zpt 290e : dd2802 > cmp rROR,x ;test result > trap_ne 2911 : d0fe > bne * ;failed not equal (non zero) > 2913 : 68 > pla ;load status > eor_flag 0 2914 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2916 : dd3802 > cmp fROR,x ;test flags > trap_ne 2919 : d0fe > bne * ;failed not equal (non zero) > 291b : ca dex 291c : 10e3 bpl tror2 291e : a203 ldx #3 2920 : tror3 set_z zp1,$ff-fc > load_flag $ff-fc 2920 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) > 2922 : 48 > pha ;use stack to load status 2923 : b509 > lda zp1,x ;load to zeropage 2925 : 8502 > sta zpt 2927 : 28 > plp 2928 : 6602 ror zpt tst_z rROR,fROR,$ff-fnzc 292a : 08 > php ;save flags 292b : a502 > lda zpt 292d : dd2802 > cmp rROR,x ;test result > trap_ne 2930 : d0fe > bne * ;failed not equal (non zero) > 2932 : 68 > pla ;load status > eor_flag $ff-fnzc 2933 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2935 : dd3802 > cmp fROR,x ;test flags > trap_ne 2938 : d0fe > bne * ;failed not equal (non zero) > 293a : ca dex 293b : 10e3 bpl tror3 293d : a203 ldx #3 293f : trorc2 set_z zp1,fc > load_flag fc 293f : a901 > lda #fc ;allow test to change I-flag (no mask) > 2941 : 48 > pha ;use stack to load status 2942 : b509 > lda zp1,x ;load to zeropage 2944 : 8502 > sta zpt 2946 : 28 > plp 2947 : 6602 ror zpt tst_z rRORc,fRORc,0 2949 : 08 > php ;save flags 294a : a502 > lda zpt 294c : dd2c02 > cmp rRORc,x ;test result > trap_ne 294f : d0fe > bne * ;failed not equal (non zero) > 2951 : 68 > pla ;load status > eor_flag 0 2952 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2954 : dd3c02 > cmp fRORc,x ;test flags > trap_ne 2957 : d0fe > bne * ;failed not equal (non zero) > 2959 : ca dex 295a : 10e3 bpl trorc2 295c : a203 ldx #3 295e : trorc3 set_z zp1,$ff > load_flag $ff 295e : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2960 : 48 > pha ;use stack to load status 2961 : b509 > lda zp1,x ;load to zeropage 2963 : 8502 > sta zpt 2965 : 28 > plp 2966 : 6602 ror zpt tst_z rRORc,fRORc,$ff-fnzc 2968 : 08 > php ;save flags 2969 : a502 > lda zpt 296b : dd2c02 > cmp rRORc,x ;test result > trap_ne 296e : d0fe > bne * ;failed not equal (non zero) > 2970 : 68 > pla ;load status > eor_flag $ff-fnzc 2971 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2973 : dd3c02 > cmp fRORc,x ;test flags > trap_ne 2976 : d0fe > bne * ;failed not equal (non zero) > 2978 : ca dex 2979 : 10e3 bpl trorc3 next_test 297b : ad0002 > lda test_case ;previous test 297e : c91e > cmp #test_num > trap_ne ;test is out of sequence 2980 : d0fe > bne * ;failed not equal (non zero) > 001f = >test_num = test_num + 1 2982 : a91f > lda #test_num ;*** next tests' number 2984 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; shifts - absolute 2987 : a203 ldx #3 2989 : tasl4 set_abs zp1,0 > load_flag 0 2989 : a900 > lda #0 ;allow test to change I-flag (no mask) > 298b : 48 > pha ;use stack to load status 298c : b509 > lda zp1,x ;load to memory 298e : 8d0302 > sta abst 2991 : 28 > plp 2992 : 0e0302 asl abst tst_abs rASL,fASL,0 2995 : 08 > php ;save flags 2996 : ad0302 > lda abst 2999 : dd2002 > cmp rASL,x ;test result > trap_ne 299c : d0fe > bne * ;failed not equal (non zero) > 299e : 68 > pla ;load status > eor_flag 0 299f : 4930 > eor #0|fao ;invert expected flags + always on bits > 29a1 : dd3002 > cmp fASL,x ;test flags > trap_ne 29a4 : d0fe > bne * ;failed not equal (non zero) > 29a6 : ca dex 29a7 : 10e0 bpl tasl4 29a9 : a203 ldx #3 29ab : tasl5 set_abs zp1,$ff > load_flag $ff 29ab : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 29ad : 48 > pha ;use stack to load status 29ae : b509 > lda zp1,x ;load to memory 29b0 : 8d0302 > sta abst 29b3 : 28 > plp 29b4 : 0e0302 asl abst tst_abs rASL,fASL,$ff-fnzc 29b7 : 08 > php ;save flags 29b8 : ad0302 > lda abst 29bb : dd2002 > cmp rASL,x ;test result > trap_ne 29be : d0fe > bne * ;failed not equal (non zero) > 29c0 : 68 > pla ;load status > eor_flag $ff-fnzc 29c1 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 29c3 : dd3002 > cmp fASL,x ;test flags > trap_ne 29c6 : d0fe > bne * ;failed not equal (non zero) > 29c8 : ca dex 29c9 : 10e0 bpl tasl5 29cb : a203 ldx #3 29cd : tlsr4 set_abs zp1,0 > load_flag 0 29cd : a900 > lda #0 ;allow test to change I-flag (no mask) > 29cf : 48 > pha ;use stack to load status 29d0 : b509 > lda zp1,x ;load to memory 29d2 : 8d0302 > sta abst 29d5 : 28 > plp 29d6 : 4e0302 lsr abst tst_abs rLSR,fLSR,0 29d9 : 08 > php ;save flags 29da : ad0302 > lda abst 29dd : dd2802 > cmp rLSR,x ;test result > trap_ne 29e0 : d0fe > bne * ;failed not equal (non zero) > 29e2 : 68 > pla ;load status > eor_flag 0 29e3 : 4930 > eor #0|fao ;invert expected flags + always on bits > 29e5 : dd3802 > cmp fLSR,x ;test flags > trap_ne 29e8 : d0fe > bne * ;failed not equal (non zero) > 29ea : ca dex 29eb : 10e0 bpl tlsr4 29ed : a203 ldx #3 29ef : tlsr5 set_abs zp1,$ff > load_flag $ff 29ef : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 29f1 : 48 > pha ;use stack to load status 29f2 : b509 > lda zp1,x ;load to memory 29f4 : 8d0302 > sta abst 29f7 : 28 > plp 29f8 : 4e0302 lsr abst tst_abs rLSR,fLSR,$ff-fnzc 29fb : 08 > php ;save flags 29fc : ad0302 > lda abst 29ff : dd2802 > cmp rLSR,x ;test result > trap_ne 2a02 : d0fe > bne * ;failed not equal (non zero) > 2a04 : 68 > pla ;load status > eor_flag $ff-fnzc 2a05 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2a07 : dd3802 > cmp fLSR,x ;test flags > trap_ne 2a0a : d0fe > bne * ;failed not equal (non zero) > 2a0c : ca dex 2a0d : 10e0 bpl tlsr5 2a0f : a203 ldx #3 2a11 : trol4 set_abs zp1,0 > load_flag 0 2a11 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2a13 : 48 > pha ;use stack to load status 2a14 : b509 > lda zp1,x ;load to memory 2a16 : 8d0302 > sta abst 2a19 : 28 > plp 2a1a : 2e0302 rol abst tst_abs rROL,fROL,0 2a1d : 08 > php ;save flags 2a1e : ad0302 > lda abst 2a21 : dd2002 > cmp rROL,x ;test result > trap_ne 2a24 : d0fe > bne * ;failed not equal (non zero) > 2a26 : 68 > pla ;load status > eor_flag 0 2a27 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2a29 : dd3002 > cmp fROL,x ;test flags > trap_ne 2a2c : d0fe > bne * ;failed not equal (non zero) > 2a2e : ca dex 2a2f : 10e0 bpl trol4 2a31 : a203 ldx #3 2a33 : trol5 set_abs zp1,$ff-fc > load_flag $ff-fc 2a33 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) > 2a35 : 48 > pha ;use stack to load status 2a36 : b509 > lda zp1,x ;load to memory 2a38 : 8d0302 > sta abst 2a3b : 28 > plp 2a3c : 2e0302 rol abst tst_abs rROL,fROL,$ff-fnzc 2a3f : 08 > php ;save flags 2a40 : ad0302 > lda abst 2a43 : dd2002 > cmp rROL,x ;test result > trap_ne 2a46 : d0fe > bne * ;failed not equal (non zero) > 2a48 : 68 > pla ;load status > eor_flag $ff-fnzc 2a49 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2a4b : dd3002 > cmp fROL,x ;test flags > trap_ne 2a4e : d0fe > bne * ;failed not equal (non zero) > 2a50 : ca dex 2a51 : 10e0 bpl trol5 2a53 : a203 ldx #3 2a55 : trolc4 set_abs zp1,fc > load_flag fc 2a55 : a901 > lda #fc ;allow test to change I-flag (no mask) > 2a57 : 48 > pha ;use stack to load status 2a58 : b509 > lda zp1,x ;load to memory 2a5a : 8d0302 > sta abst 2a5d : 28 > plp 2a5e : 2e0302 rol abst tst_abs rROLc,fROLc,0 2a61 : 08 > php ;save flags 2a62 : ad0302 > lda abst 2a65 : dd2402 > cmp rROLc,x ;test result > trap_ne 2a68 : d0fe > bne * ;failed not equal (non zero) > 2a6a : 68 > pla ;load status > eor_flag 0 2a6b : 4930 > eor #0|fao ;invert expected flags + always on bits > 2a6d : dd3402 > cmp fROLc,x ;test flags > trap_ne 2a70 : d0fe > bne * ;failed not equal (non zero) > 2a72 : ca dex 2a73 : 10e0 bpl trolc4 2a75 : a203 ldx #3 2a77 : trolc5 set_abs zp1,$ff > load_flag $ff 2a77 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2a79 : 48 > pha ;use stack to load status 2a7a : b509 > lda zp1,x ;load to memory 2a7c : 8d0302 > sta abst 2a7f : 28 > plp 2a80 : 2e0302 rol abst tst_abs rROLc,fROLc,$ff-fnzc 2a83 : 08 > php ;save flags 2a84 : ad0302 > lda abst 2a87 : dd2402 > cmp rROLc,x ;test result > trap_ne 2a8a : d0fe > bne * ;failed not equal (non zero) > 2a8c : 68 > pla ;load status > eor_flag $ff-fnzc 2a8d : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2a8f : dd3402 > cmp fROLc,x ;test flags > trap_ne 2a92 : d0fe > bne * ;failed not equal (non zero) > 2a94 : ca dex 2a95 : 10e0 bpl trolc5 2a97 : a203 ldx #3 2a99 : tror4 set_abs zp1,0 > load_flag 0 2a99 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2a9b : 48 > pha ;use stack to load status 2a9c : b509 > lda zp1,x ;load to memory 2a9e : 8d0302 > sta abst 2aa1 : 28 > plp 2aa2 : 6e0302 ror abst tst_abs rROR,fROR,0 2aa5 : 08 > php ;save flags 2aa6 : ad0302 > lda abst 2aa9 : dd2802 > cmp rROR,x ;test result > trap_ne 2aac : d0fe > bne * ;failed not equal (non zero) > 2aae : 68 > pla ;load status > eor_flag 0 2aaf : 4930 > eor #0|fao ;invert expected flags + always on bits > 2ab1 : dd3802 > cmp fROR,x ;test flags > trap_ne 2ab4 : d0fe > bne * ;failed not equal (non zero) > 2ab6 : ca dex 2ab7 : 10e0 bpl tror4 2ab9 : a203 ldx #3 2abb : tror5 set_abs zp1,$ff-fc > load_flag $ff-fc 2abb : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) > 2abd : 48 > pha ;use stack to load status 2abe : b509 > lda zp1,x ;load to memory 2ac0 : 8d0302 > sta abst 2ac3 : 28 > plp 2ac4 : 6e0302 ror abst tst_abs rROR,fROR,$ff-fnzc 2ac7 : 08 > php ;save flags 2ac8 : ad0302 > lda abst 2acb : dd2802 > cmp rROR,x ;test result > trap_ne 2ace : d0fe > bne * ;failed not equal (non zero) > 2ad0 : 68 > pla ;load status > eor_flag $ff-fnzc 2ad1 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2ad3 : dd3802 > cmp fROR,x ;test flags > trap_ne 2ad6 : d0fe > bne * ;failed not equal (non zero) > 2ad8 : ca dex 2ad9 : 10e0 bpl tror5 2adb : a203 ldx #3 2add : trorc4 set_abs zp1,fc > load_flag fc 2add : a901 > lda #fc ;allow test to change I-flag (no mask) > 2adf : 48 > pha ;use stack to load status 2ae0 : b509 > lda zp1,x ;load to memory 2ae2 : 8d0302 > sta abst 2ae5 : 28 > plp 2ae6 : 6e0302 ror abst tst_abs rRORc,fRORc,0 2ae9 : 08 > php ;save flags 2aea : ad0302 > lda abst 2aed : dd2c02 > cmp rRORc,x ;test result > trap_ne 2af0 : d0fe > bne * ;failed not equal (non zero) > 2af2 : 68 > pla ;load status > eor_flag 0 2af3 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2af5 : dd3c02 > cmp fRORc,x ;test flags > trap_ne 2af8 : d0fe > bne * ;failed not equal (non zero) > 2afa : ca dex 2afb : 10e0 bpl trorc4 2afd : a203 ldx #3 2aff : trorc5 set_abs zp1,$ff > load_flag $ff 2aff : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2b01 : 48 > pha ;use stack to load status 2b02 : b509 > lda zp1,x ;load to memory 2b04 : 8d0302 > sta abst 2b07 : 28 > plp 2b08 : 6e0302 ror abst tst_abs rRORc,fRORc,$ff-fnzc 2b0b : 08 > php ;save flags 2b0c : ad0302 > lda abst 2b0f : dd2c02 > cmp rRORc,x ;test result > trap_ne 2b12 : d0fe > bne * ;failed not equal (non zero) > 2b14 : 68 > pla ;load status > eor_flag $ff-fnzc 2b15 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2b17 : dd3c02 > cmp fRORc,x ;test flags > trap_ne 2b1a : d0fe > bne * ;failed not equal (non zero) > 2b1c : ca dex 2b1d : 10e0 bpl trorc5 next_test 2b1f : ad0002 > lda test_case ;previous test 2b22 : c91f > cmp #test_num > trap_ne ;test is out of sequence 2b24 : d0fe > bne * ;failed not equal (non zero) > 0020 = >test_num = test_num + 1 2b26 : a920 > lda #test_num ;*** next tests' number 2b28 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; shifts - zp indexed 2b2b : a203 ldx #3 2b2d : tasl6 set_zx zp1,0 > load_flag 0 2b2d : a900 > lda #0 ;allow test to change I-flag (no mask) > 2b2f : 48 > pha ;use stack to load status 2b30 : b509 > lda zp1,x ;load to indexed zeropage 2b32 : 9502 > sta zpt,x 2b34 : 28 > plp 2b35 : 1602 asl zpt,x tst_zx rASL,fASL,0 2b37 : 08 > php ;save flags 2b38 : b502 > lda zpt,x 2b3a : dd2002 > cmp rASL,x ;test result > trap_ne 2b3d : d0fe > bne * ;failed not equal (non zero) > 2b3f : 68 > pla ;load status > eor_flag 0 2b40 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2b42 : dd3002 > cmp fASL,x ;test flags > trap_ne 2b45 : d0fe > bne * ;failed not equal (non zero) > 2b47 : ca dex 2b48 : 10e3 bpl tasl6 2b4a : a203 ldx #3 2b4c : tasl7 set_zx zp1,$ff > load_flag $ff 2b4c : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2b4e : 48 > pha ;use stack to load status 2b4f : b509 > lda zp1,x ;load to indexed zeropage 2b51 : 9502 > sta zpt,x 2b53 : 28 > plp 2b54 : 1602 asl zpt,x tst_zx rASL,fASL,$ff-fnzc 2b56 : 08 > php ;save flags 2b57 : b502 > lda zpt,x 2b59 : dd2002 > cmp rASL,x ;test result > trap_ne 2b5c : d0fe > bne * ;failed not equal (non zero) > 2b5e : 68 > pla ;load status > eor_flag $ff-fnzc 2b5f : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2b61 : dd3002 > cmp fASL,x ;test flags > trap_ne 2b64 : d0fe > bne * ;failed not equal (non zero) > 2b66 : ca dex 2b67 : 10e3 bpl tasl7 2b69 : a203 ldx #3 2b6b : tlsr6 set_zx zp1,0 > load_flag 0 2b6b : a900 > lda #0 ;allow test to change I-flag (no mask) > 2b6d : 48 > pha ;use stack to load status 2b6e : b509 > lda zp1,x ;load to indexed zeropage 2b70 : 9502 > sta zpt,x 2b72 : 28 > plp 2b73 : 5602 lsr zpt,x tst_zx rLSR,fLSR,0 2b75 : 08 > php ;save flags 2b76 : b502 > lda zpt,x 2b78 : dd2802 > cmp rLSR,x ;test result > trap_ne 2b7b : d0fe > bne * ;failed not equal (non zero) > 2b7d : 68 > pla ;load status > eor_flag 0 2b7e : 4930 > eor #0|fao ;invert expected flags + always on bits > 2b80 : dd3802 > cmp fLSR,x ;test flags > trap_ne 2b83 : d0fe > bne * ;failed not equal (non zero) > 2b85 : ca dex 2b86 : 10e3 bpl tlsr6 2b88 : a203 ldx #3 2b8a : tlsr7 set_zx zp1,$ff > load_flag $ff 2b8a : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2b8c : 48 > pha ;use stack to load status 2b8d : b509 > lda zp1,x ;load to indexed zeropage 2b8f : 9502 > sta zpt,x 2b91 : 28 > plp 2b92 : 5602 lsr zpt,x tst_zx rLSR,fLSR,$ff-fnzc 2b94 : 08 > php ;save flags 2b95 : b502 > lda zpt,x 2b97 : dd2802 > cmp rLSR,x ;test result > trap_ne 2b9a : d0fe > bne * ;failed not equal (non zero) > 2b9c : 68 > pla ;load status > eor_flag $ff-fnzc 2b9d : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2b9f : dd3802 > cmp fLSR,x ;test flags > trap_ne 2ba2 : d0fe > bne * ;failed not equal (non zero) > 2ba4 : ca dex 2ba5 : 10e3 bpl tlsr7 2ba7 : a203 ldx #3 2ba9 : trol6 set_zx zp1,0 > load_flag 0 2ba9 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2bab : 48 > pha ;use stack to load status 2bac : b509 > lda zp1,x ;load to indexed zeropage 2bae : 9502 > sta zpt,x 2bb0 : 28 > plp 2bb1 : 3602 rol zpt,x tst_zx rROL,fROL,0 2bb3 : 08 > php ;save flags 2bb4 : b502 > lda zpt,x 2bb6 : dd2002 > cmp rROL,x ;test result > trap_ne 2bb9 : d0fe > bne * ;failed not equal (non zero) > 2bbb : 68 > pla ;load status > eor_flag 0 2bbc : 4930 > eor #0|fao ;invert expected flags + always on bits > 2bbe : dd3002 > cmp fROL,x ;test flags > trap_ne 2bc1 : d0fe > bne * ;failed not equal (non zero) > 2bc3 : ca dex 2bc4 : 10e3 bpl trol6 2bc6 : a203 ldx #3 2bc8 : trol7 set_zx zp1,$ff-fc > load_flag $ff-fc 2bc8 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) > 2bca : 48 > pha ;use stack to load status 2bcb : b509 > lda zp1,x ;load to indexed zeropage 2bcd : 9502 > sta zpt,x 2bcf : 28 > plp 2bd0 : 3602 rol zpt,x tst_zx rROL,fROL,$ff-fnzc 2bd2 : 08 > php ;save flags 2bd3 : b502 > lda zpt,x 2bd5 : dd2002 > cmp rROL,x ;test result > trap_ne 2bd8 : d0fe > bne * ;failed not equal (non zero) > 2bda : 68 > pla ;load status > eor_flag $ff-fnzc 2bdb : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2bdd : dd3002 > cmp fROL,x ;test flags > trap_ne 2be0 : d0fe > bne * ;failed not equal (non zero) > 2be2 : ca dex 2be3 : 10e3 bpl trol7 2be5 : a203 ldx #3 2be7 : trolc6 set_zx zp1,fc > load_flag fc 2be7 : a901 > lda #fc ;allow test to change I-flag (no mask) > 2be9 : 48 > pha ;use stack to load status 2bea : b509 > lda zp1,x ;load to indexed zeropage 2bec : 9502 > sta zpt,x 2bee : 28 > plp 2bef : 3602 rol zpt,x tst_zx rROLc,fROLc,0 2bf1 : 08 > php ;save flags 2bf2 : b502 > lda zpt,x 2bf4 : dd2402 > cmp rROLc,x ;test result > trap_ne 2bf7 : d0fe > bne * ;failed not equal (non zero) > 2bf9 : 68 > pla ;load status > eor_flag 0 2bfa : 4930 > eor #0|fao ;invert expected flags + always on bits > 2bfc : dd3402 > cmp fROLc,x ;test flags > trap_ne 2bff : d0fe > bne * ;failed not equal (non zero) > 2c01 : ca dex 2c02 : 10e3 bpl trolc6 2c04 : a203 ldx #3 2c06 : trolc7 set_zx zp1,$ff > load_flag $ff 2c06 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2c08 : 48 > pha ;use stack to load status 2c09 : b509 > lda zp1,x ;load to indexed zeropage 2c0b : 9502 > sta zpt,x 2c0d : 28 > plp 2c0e : 3602 rol zpt,x tst_zx rROLc,fROLc,$ff-fnzc 2c10 : 08 > php ;save flags 2c11 : b502 > lda zpt,x 2c13 : dd2402 > cmp rROLc,x ;test result > trap_ne 2c16 : d0fe > bne * ;failed not equal (non zero) > 2c18 : 68 > pla ;load status > eor_flag $ff-fnzc 2c19 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2c1b : dd3402 > cmp fROLc,x ;test flags > trap_ne 2c1e : d0fe > bne * ;failed not equal (non zero) > 2c20 : ca dex 2c21 : 10e3 bpl trolc7 2c23 : a203 ldx #3 2c25 : tror6 set_zx zp1,0 > load_flag 0 2c25 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2c27 : 48 > pha ;use stack to load status 2c28 : b509 > lda zp1,x ;load to indexed zeropage 2c2a : 9502 > sta zpt,x 2c2c : 28 > plp 2c2d : 7602 ror zpt,x tst_zx rROR,fROR,0 2c2f : 08 > php ;save flags 2c30 : b502 > lda zpt,x 2c32 : dd2802 > cmp rROR,x ;test result > trap_ne 2c35 : d0fe > bne * ;failed not equal (non zero) > 2c37 : 68 > pla ;load status > eor_flag 0 2c38 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2c3a : dd3802 > cmp fROR,x ;test flags > trap_ne 2c3d : d0fe > bne * ;failed not equal (non zero) > 2c3f : ca dex 2c40 : 10e3 bpl tror6 2c42 : a203 ldx #3 2c44 : tror7 set_zx zp1,$ff-fc > load_flag $ff-fc 2c44 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) > 2c46 : 48 > pha ;use stack to load status 2c47 : b509 > lda zp1,x ;load to indexed zeropage 2c49 : 9502 > sta zpt,x 2c4b : 28 > plp 2c4c : 7602 ror zpt,x tst_zx rROR,fROR,$ff-fnzc 2c4e : 08 > php ;save flags 2c4f : b502 > lda zpt,x 2c51 : dd2802 > cmp rROR,x ;test result > trap_ne 2c54 : d0fe > bne * ;failed not equal (non zero) > 2c56 : 68 > pla ;load status > eor_flag $ff-fnzc 2c57 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2c59 : dd3802 > cmp fROR,x ;test flags > trap_ne 2c5c : d0fe > bne * ;failed not equal (non zero) > 2c5e : ca dex 2c5f : 10e3 bpl tror7 2c61 : a203 ldx #3 2c63 : trorc6 set_zx zp1,fc > load_flag fc 2c63 : a901 > lda #fc ;allow test to change I-flag (no mask) > 2c65 : 48 > pha ;use stack to load status 2c66 : b509 > lda zp1,x ;load to indexed zeropage 2c68 : 9502 > sta zpt,x 2c6a : 28 > plp 2c6b : 7602 ror zpt,x tst_zx rRORc,fRORc,0 2c6d : 08 > php ;save flags 2c6e : b502 > lda zpt,x 2c70 : dd2c02 > cmp rRORc,x ;test result > trap_ne 2c73 : d0fe > bne * ;failed not equal (non zero) > 2c75 : 68 > pla ;load status > eor_flag 0 2c76 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2c78 : dd3c02 > cmp fRORc,x ;test flags > trap_ne 2c7b : d0fe > bne * ;failed not equal (non zero) > 2c7d : ca dex 2c7e : 10e3 bpl trorc6 2c80 : a203 ldx #3 2c82 : trorc7 set_zx zp1,$ff > load_flag $ff 2c82 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2c84 : 48 > pha ;use stack to load status 2c85 : b509 > lda zp1,x ;load to indexed zeropage 2c87 : 9502 > sta zpt,x 2c89 : 28 > plp 2c8a : 7602 ror zpt,x tst_zx rRORc,fRORc,$ff-fnzc 2c8c : 08 > php ;save flags 2c8d : b502 > lda zpt,x 2c8f : dd2c02 > cmp rRORc,x ;test result > trap_ne 2c92 : d0fe > bne * ;failed not equal (non zero) > 2c94 : 68 > pla ;load status > eor_flag $ff-fnzc 2c95 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2c97 : dd3c02 > cmp fRORc,x ;test flags > trap_ne 2c9a : d0fe > bne * ;failed not equal (non zero) > 2c9c : ca dex 2c9d : 10e3 bpl trorc7 next_test 2c9f : ad0002 > lda test_case ;previous test 2ca2 : c920 > cmp #test_num > trap_ne ;test is out of sequence 2ca4 : d0fe > bne * ;failed not equal (non zero) > 0021 = >test_num = test_num + 1 2ca6 : a921 > lda #test_num ;*** next tests' number 2ca8 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; shifts - abs indexed 2cab : a203 ldx #3 2cad : tasl8 set_absx zp1,0 > load_flag 0 2cad : a900 > lda #0 ;allow test to change I-flag (no mask) > 2caf : 48 > pha ;use stack to load status 2cb0 : b509 > lda zp1,x ;load to indexed memory 2cb2 : 9d0302 > sta abst,x 2cb5 : 28 > plp 2cb6 : 1e0302 asl abst,x tst_absx rASL,fASL,0 2cb9 : 08 > php ;save flags 2cba : bd0302 > lda abst,x 2cbd : dd2002 > cmp rASL,x ;test result > trap_ne 2cc0 : d0fe > bne * ;failed not equal (non zero) > 2cc2 : 68 > pla ;load status > eor_flag 0 2cc3 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2cc5 : dd3002 > cmp fASL,x ;test flags > trap_ne 2cc8 : d0fe > bne * ;failed not equal (non zero) > 2cca : ca dex 2ccb : 10e0 bpl tasl8 2ccd : a203 ldx #3 2ccf : tasl9 set_absx zp1,$ff > load_flag $ff 2ccf : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2cd1 : 48 > pha ;use stack to load status 2cd2 : b509 > lda zp1,x ;load to indexed memory 2cd4 : 9d0302 > sta abst,x 2cd7 : 28 > plp 2cd8 : 1e0302 asl abst,x tst_absx rASL,fASL,$ff-fnzc 2cdb : 08 > php ;save flags 2cdc : bd0302 > lda abst,x 2cdf : dd2002 > cmp rASL,x ;test result > trap_ne 2ce2 : d0fe > bne * ;failed not equal (non zero) > 2ce4 : 68 > pla ;load status > eor_flag $ff-fnzc 2ce5 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2ce7 : dd3002 > cmp fASL,x ;test flags > trap_ne 2cea : d0fe > bne * ;failed not equal (non zero) > 2cec : ca dex 2ced : 10e0 bpl tasl9 2cef : a203 ldx #3 2cf1 : tlsr8 set_absx zp1,0 > load_flag 0 2cf1 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2cf3 : 48 > pha ;use stack to load status 2cf4 : b509 > lda zp1,x ;load to indexed memory 2cf6 : 9d0302 > sta abst,x 2cf9 : 28 > plp 2cfa : 5e0302 lsr abst,x tst_absx rLSR,fLSR,0 2cfd : 08 > php ;save flags 2cfe : bd0302 > lda abst,x 2d01 : dd2802 > cmp rLSR,x ;test result > trap_ne 2d04 : d0fe > bne * ;failed not equal (non zero) > 2d06 : 68 > pla ;load status > eor_flag 0 2d07 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2d09 : dd3802 > cmp fLSR,x ;test flags > trap_ne 2d0c : d0fe > bne * ;failed not equal (non zero) > 2d0e : ca dex 2d0f : 10e0 bpl tlsr8 2d11 : a203 ldx #3 2d13 : tlsr9 set_absx zp1,$ff > load_flag $ff 2d13 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2d15 : 48 > pha ;use stack to load status 2d16 : b509 > lda zp1,x ;load to indexed memory 2d18 : 9d0302 > sta abst,x 2d1b : 28 > plp 2d1c : 5e0302 lsr abst,x tst_absx rLSR,fLSR,$ff-fnzc 2d1f : 08 > php ;save flags 2d20 : bd0302 > lda abst,x 2d23 : dd2802 > cmp rLSR,x ;test result > trap_ne 2d26 : d0fe > bne * ;failed not equal (non zero) > 2d28 : 68 > pla ;load status > eor_flag $ff-fnzc 2d29 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2d2b : dd3802 > cmp fLSR,x ;test flags > trap_ne 2d2e : d0fe > bne * ;failed not equal (non zero) > 2d30 : ca dex 2d31 : 10e0 bpl tlsr9 2d33 : a203 ldx #3 2d35 : trol8 set_absx zp1,0 > load_flag 0 2d35 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2d37 : 48 > pha ;use stack to load status 2d38 : b509 > lda zp1,x ;load to indexed memory 2d3a : 9d0302 > sta abst,x 2d3d : 28 > plp 2d3e : 3e0302 rol abst,x tst_absx rROL,fROL,0 2d41 : 08 > php ;save flags 2d42 : bd0302 > lda abst,x 2d45 : dd2002 > cmp rROL,x ;test result > trap_ne 2d48 : d0fe > bne * ;failed not equal (non zero) > 2d4a : 68 > pla ;load status > eor_flag 0 2d4b : 4930 > eor #0|fao ;invert expected flags + always on bits > 2d4d : dd3002 > cmp fROL,x ;test flags > trap_ne 2d50 : d0fe > bne * ;failed not equal (non zero) > 2d52 : ca dex 2d53 : 10e0 bpl trol8 2d55 : a203 ldx #3 2d57 : trol9 set_absx zp1,$ff-fc > load_flag $ff-fc 2d57 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) > 2d59 : 48 > pha ;use stack to load status 2d5a : b509 > lda zp1,x ;load to indexed memory 2d5c : 9d0302 > sta abst,x 2d5f : 28 > plp 2d60 : 3e0302 rol abst,x tst_absx rROL,fROL,$ff-fnzc 2d63 : 08 > php ;save flags 2d64 : bd0302 > lda abst,x 2d67 : dd2002 > cmp rROL,x ;test result > trap_ne 2d6a : d0fe > bne * ;failed not equal (non zero) > 2d6c : 68 > pla ;load status > eor_flag $ff-fnzc 2d6d : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2d6f : dd3002 > cmp fROL,x ;test flags > trap_ne 2d72 : d0fe > bne * ;failed not equal (non zero) > 2d74 : ca dex 2d75 : 10e0 bpl trol9 2d77 : a203 ldx #3 2d79 : trolc8 set_absx zp1,fc > load_flag fc 2d79 : a901 > lda #fc ;allow test to change I-flag (no mask) > 2d7b : 48 > pha ;use stack to load status 2d7c : b509 > lda zp1,x ;load to indexed memory 2d7e : 9d0302 > sta abst,x 2d81 : 28 > plp 2d82 : 3e0302 rol abst,x tst_absx rROLc,fROLc,0 2d85 : 08 > php ;save flags 2d86 : bd0302 > lda abst,x 2d89 : dd2402 > cmp rROLc,x ;test result > trap_ne 2d8c : d0fe > bne * ;failed not equal (non zero) > 2d8e : 68 > pla ;load status > eor_flag 0 2d8f : 4930 > eor #0|fao ;invert expected flags + always on bits > 2d91 : dd3402 > cmp fROLc,x ;test flags > trap_ne 2d94 : d0fe > bne * ;failed not equal (non zero) > 2d96 : ca dex 2d97 : 10e0 bpl trolc8 2d99 : a203 ldx #3 2d9b : trolc9 set_absx zp1,$ff > load_flag $ff 2d9b : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2d9d : 48 > pha ;use stack to load status 2d9e : b509 > lda zp1,x ;load to indexed memory 2da0 : 9d0302 > sta abst,x 2da3 : 28 > plp 2da4 : 3e0302 rol abst,x tst_absx rROLc,fROLc,$ff-fnzc 2da7 : 08 > php ;save flags 2da8 : bd0302 > lda abst,x 2dab : dd2402 > cmp rROLc,x ;test result > trap_ne 2dae : d0fe > bne * ;failed not equal (non zero) > 2db0 : 68 > pla ;load status > eor_flag $ff-fnzc 2db1 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2db3 : dd3402 > cmp fROLc,x ;test flags > trap_ne 2db6 : d0fe > bne * ;failed not equal (non zero) > 2db8 : ca dex 2db9 : 10e0 bpl trolc9 2dbb : a203 ldx #3 2dbd : tror8 set_absx zp1,0 > load_flag 0 2dbd : a900 > lda #0 ;allow test to change I-flag (no mask) > 2dbf : 48 > pha ;use stack to load status 2dc0 : b509 > lda zp1,x ;load to indexed memory 2dc2 : 9d0302 > sta abst,x 2dc5 : 28 > plp 2dc6 : 7e0302 ror abst,x tst_absx rROR,fROR,0 2dc9 : 08 > php ;save flags 2dca : bd0302 > lda abst,x 2dcd : dd2802 > cmp rROR,x ;test result > trap_ne 2dd0 : d0fe > bne * ;failed not equal (non zero) > 2dd2 : 68 > pla ;load status > eor_flag 0 2dd3 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2dd5 : dd3802 > cmp fROR,x ;test flags > trap_ne 2dd8 : d0fe > bne * ;failed not equal (non zero) > 2dda : ca dex 2ddb : 10e0 bpl tror8 2ddd : a203 ldx #3 2ddf : tror9 set_absx zp1,$ff-fc > load_flag $ff-fc 2ddf : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) > 2de1 : 48 > pha ;use stack to load status 2de2 : b509 > lda zp1,x ;load to indexed memory 2de4 : 9d0302 > sta abst,x 2de7 : 28 > plp 2de8 : 7e0302 ror abst,x tst_absx rROR,fROR,$ff-fnzc 2deb : 08 > php ;save flags 2dec : bd0302 > lda abst,x 2def : dd2802 > cmp rROR,x ;test result > trap_ne 2df2 : d0fe > bne * ;failed not equal (non zero) > 2df4 : 68 > pla ;load status > eor_flag $ff-fnzc 2df5 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2df7 : dd3802 > cmp fROR,x ;test flags > trap_ne 2dfa : d0fe > bne * ;failed not equal (non zero) > 2dfc : ca dex 2dfd : 10e0 bpl tror9 2dff : a203 ldx #3 2e01 : trorc8 set_absx zp1,fc > load_flag fc 2e01 : a901 > lda #fc ;allow test to change I-flag (no mask) > 2e03 : 48 > pha ;use stack to load status 2e04 : b509 > lda zp1,x ;load to indexed memory 2e06 : 9d0302 > sta abst,x 2e09 : 28 > plp 2e0a : 7e0302 ror abst,x tst_absx rRORc,fRORc,0 2e0d : 08 > php ;save flags 2e0e : bd0302 > lda abst,x 2e11 : dd2c02 > cmp rRORc,x ;test result > trap_ne 2e14 : d0fe > bne * ;failed not equal (non zero) > 2e16 : 68 > pla ;load status > eor_flag 0 2e17 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2e19 : dd3c02 > cmp fRORc,x ;test flags > trap_ne 2e1c : d0fe > bne * ;failed not equal (non zero) > 2e1e : ca dex 2e1f : 10e0 bpl trorc8 2e21 : a203 ldx #3 2e23 : trorc9 set_absx zp1,$ff > load_flag $ff 2e23 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2e25 : 48 > pha ;use stack to load status 2e26 : b509 > lda zp1,x ;load to indexed memory 2e28 : 9d0302 > sta abst,x 2e2b : 28 > plp 2e2c : 7e0302 ror abst,x tst_absx rRORc,fRORc,$ff-fnzc 2e2f : 08 > php ;save flags 2e30 : bd0302 > lda abst,x 2e33 : dd2c02 > cmp rRORc,x ;test result > trap_ne 2e36 : d0fe > bne * ;failed not equal (non zero) > 2e38 : 68 > pla ;load status > eor_flag $ff-fnzc 2e39 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2e3b : dd3c02 > cmp fRORc,x ;test flags > trap_ne 2e3e : d0fe > bne * ;failed not equal (non zero) > 2e40 : ca dex 2e41 : 10e0 bpl trorc9 next_test 2e43 : ad0002 > lda test_case ;previous test 2e46 : c921 > cmp #test_num > trap_ne ;test is out of sequence 2e48 : d0fe > bne * ;failed not equal (non zero) > 0022 = >test_num = test_num + 1 2e4a : a922 > lda #test_num ;*** next tests' number 2e4c : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; testing memory increment/decrement - INC DEC all addressing modes ; zeropage 2e4f : a200 ldx #0 2e51 : a97e lda #$7e 2e53 : 8502 sta zpt 2e55 : tinc set_stat 0 > load_flag 0 2e55 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2e57 : 48 > pha ;use stack to load status 2e58 : 28 > plp 2e59 : e602 inc zpt tst_z rINC,fINC,0 2e5b : 08 > php ;save flags 2e5c : a502 > lda zpt 2e5e : dd4002 > cmp rINC,x ;test result > trap_ne 2e61 : d0fe > bne * ;failed not equal (non zero) > 2e63 : 68 > pla ;load status > eor_flag 0 2e64 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2e66 : dd4502 > cmp fINC,x ;test flags > trap_ne 2e69 : d0fe > bne * ;failed not equal (non zero) > 2e6b : e8 inx 2e6c : e002 cpx #2 2e6e : d004 bne tinc1 2e70 : a9fe lda #$fe 2e72 : 8502 sta zpt 2e74 : e005 tinc1 cpx #5 2e76 : d0dd bne tinc 2e78 : ca dex 2e79 : e602 inc zpt 2e7b : tdec set_stat 0 > load_flag 0 2e7b : a900 > lda #0 ;allow test to change I-flag (no mask) > 2e7d : 48 > pha ;use stack to load status 2e7e : 28 > plp 2e7f : c602 dec zpt tst_z rINC,fINC,0 2e81 : 08 > php ;save flags 2e82 : a502 > lda zpt 2e84 : dd4002 > cmp rINC,x ;test result > trap_ne 2e87 : d0fe > bne * ;failed not equal (non zero) > 2e89 : 68 > pla ;load status > eor_flag 0 2e8a : 4930 > eor #0|fao ;invert expected flags + always on bits > 2e8c : dd4502 > cmp fINC,x ;test flags > trap_ne 2e8f : d0fe > bne * ;failed not equal (non zero) > 2e91 : ca dex 2e92 : 300a bmi tdec1 2e94 : e001 cpx #1 2e96 : d0e3 bne tdec 2e98 : a981 lda #$81 2e9a : 8502 sta zpt 2e9c : d0dd bne tdec 2e9e : tdec1 2e9e : a200 ldx #0 2ea0 : a97e lda #$7e 2ea2 : 8502 sta zpt 2ea4 : tinc10 set_stat $ff > load_flag $ff 2ea4 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2ea6 : 48 > pha ;use stack to load status 2ea7 : 28 > plp 2ea8 : e602 inc zpt tst_z rINC,fINC,$ff-fnz 2eaa : 08 > php ;save flags 2eab : a502 > lda zpt 2ead : dd4002 > cmp rINC,x ;test result > trap_ne 2eb0 : d0fe > bne * ;failed not equal (non zero) > 2eb2 : 68 > pla ;load status > eor_flag $ff-fnz 2eb3 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 2eb5 : dd4502 > cmp fINC,x ;test flags > trap_ne 2eb8 : d0fe > bne * ;failed not equal (non zero) > 2eba : e8 inx 2ebb : e002 cpx #2 2ebd : d004 bne tinc11 2ebf : a9fe lda #$fe 2ec1 : 8502 sta zpt 2ec3 : e005 tinc11 cpx #5 2ec5 : d0dd bne tinc10 2ec7 : ca dex 2ec8 : e602 inc zpt 2eca : tdec10 set_stat $ff > load_flag $ff 2eca : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2ecc : 48 > pha ;use stack to load status 2ecd : 28 > plp 2ece : c602 dec zpt tst_z rINC,fINC,$ff-fnz 2ed0 : 08 > php ;save flags 2ed1 : a502 > lda zpt 2ed3 : dd4002 > cmp rINC,x ;test result > trap_ne 2ed6 : d0fe > bne * ;failed not equal (non zero) > 2ed8 : 68 > pla ;load status > eor_flag $ff-fnz 2ed9 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 2edb : dd4502 > cmp fINC,x ;test flags > trap_ne 2ede : d0fe > bne * ;failed not equal (non zero) > 2ee0 : ca dex 2ee1 : 300a bmi tdec11 2ee3 : e001 cpx #1 2ee5 : d0e3 bne tdec10 2ee7 : a981 lda #$81 2ee9 : 8502 sta zpt 2eeb : d0dd bne tdec10 2eed : tdec11 next_test 2eed : ad0002 > lda test_case ;previous test 2ef0 : c922 > cmp #test_num > trap_ne ;test is out of sequence 2ef2 : d0fe > bne * ;failed not equal (non zero) > 0023 = >test_num = test_num + 1 2ef4 : a923 > lda #test_num ;*** next tests' number 2ef6 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; absolute memory 2ef9 : a200 ldx #0 2efb : a97e lda #$7e 2efd : 8d0302 sta abst 2f00 : tinc2 set_stat 0 > load_flag 0 2f00 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2f02 : 48 > pha ;use stack to load status 2f03 : 28 > plp 2f04 : ee0302 inc abst tst_abs rINC,fINC,0 2f07 : 08 > php ;save flags 2f08 : ad0302 > lda abst 2f0b : dd4002 > cmp rINC,x ;test result > trap_ne 2f0e : d0fe > bne * ;failed not equal (non zero) > 2f10 : 68 > pla ;load status > eor_flag 0 2f11 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2f13 : dd4502 > cmp fINC,x ;test flags > trap_ne 2f16 : d0fe > bne * ;failed not equal (non zero) > 2f18 : e8 inx 2f19 : e002 cpx #2 2f1b : d005 bne tinc3 2f1d : a9fe lda #$fe 2f1f : 8d0302 sta abst 2f22 : e005 tinc3 cpx #5 2f24 : d0da bne tinc2 2f26 : ca dex 2f27 : ee0302 inc abst 2f2a : tdec2 set_stat 0 > load_flag 0 2f2a : a900 > lda #0 ;allow test to change I-flag (no mask) > 2f2c : 48 > pha ;use stack to load status 2f2d : 28 > plp 2f2e : ce0302 dec abst tst_abs rINC,fINC,0 2f31 : 08 > php ;save flags 2f32 : ad0302 > lda abst 2f35 : dd4002 > cmp rINC,x ;test result > trap_ne 2f38 : d0fe > bne * ;failed not equal (non zero) > 2f3a : 68 > pla ;load status > eor_flag 0 2f3b : 4930 > eor #0|fao ;invert expected flags + always on bits > 2f3d : dd4502 > cmp fINC,x ;test flags > trap_ne 2f40 : d0fe > bne * ;failed not equal (non zero) > 2f42 : ca dex 2f43 : 300b bmi tdec3 2f45 : e001 cpx #1 2f47 : d0e1 bne tdec2 2f49 : a981 lda #$81 2f4b : 8d0302 sta abst 2f4e : d0da bne tdec2 2f50 : tdec3 2f50 : a200 ldx #0 2f52 : a97e lda #$7e 2f54 : 8d0302 sta abst 2f57 : tinc12 set_stat $ff > load_flag $ff 2f57 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2f59 : 48 > pha ;use stack to load status 2f5a : 28 > plp 2f5b : ee0302 inc abst tst_abs rINC,fINC,$ff-fnz 2f5e : 08 > php ;save flags 2f5f : ad0302 > lda abst 2f62 : dd4002 > cmp rINC,x ;test result > trap_ne 2f65 : d0fe > bne * ;failed not equal (non zero) > 2f67 : 68 > pla ;load status > eor_flag $ff-fnz 2f68 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 2f6a : dd4502 > cmp fINC,x ;test flags > trap_ne 2f6d : d0fe > bne * ;failed not equal (non zero) > 2f6f : e8 inx 2f70 : e002 cpx #2 2f72 : d005 bne tinc13 2f74 : a9fe lda #$fe 2f76 : 8d0302 sta abst 2f79 : e005 tinc13 cpx #5 2f7b : d0da bne tinc12 2f7d : ca dex 2f7e : ee0302 inc abst 2f81 : tdec12 set_stat $ff > load_flag $ff 2f81 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2f83 : 48 > pha ;use stack to load status 2f84 : 28 > plp 2f85 : ce0302 dec abst tst_abs rINC,fINC,$ff-fnz 2f88 : 08 > php ;save flags 2f89 : ad0302 > lda abst 2f8c : dd4002 > cmp rINC,x ;test result > trap_ne 2f8f : d0fe > bne * ;failed not equal (non zero) > 2f91 : 68 > pla ;load status > eor_flag $ff-fnz 2f92 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 2f94 : dd4502 > cmp fINC,x ;test flags > trap_ne 2f97 : d0fe > bne * ;failed not equal (non zero) > 2f99 : ca dex 2f9a : 300b bmi tdec13 2f9c : e001 cpx #1 2f9e : d0e1 bne tdec12 2fa0 : a981 lda #$81 2fa2 : 8d0302 sta abst 2fa5 : d0da bne tdec12 2fa7 : tdec13 next_test 2fa7 : ad0002 > lda test_case ;previous test 2faa : c923 > cmp #test_num > trap_ne ;test is out of sequence 2fac : d0fe > bne * ;failed not equal (non zero) > 0024 = >test_num = test_num + 1 2fae : a924 > lda #test_num ;*** next tests' number 2fb0 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; zeropage indexed 2fb3 : a200 ldx #0 2fb5 : a97e lda #$7e 2fb7 : 9502 tinc4 sta zpt,x set_stat 0 > load_flag 0 2fb9 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2fbb : 48 > pha ;use stack to load status 2fbc : 28 > plp 2fbd : f602 inc zpt,x tst_zx rINC,fINC,0 2fbf : 08 > php ;save flags 2fc0 : b502 > lda zpt,x 2fc2 : dd4002 > cmp rINC,x ;test result > trap_ne 2fc5 : d0fe > bne * ;failed not equal (non zero) > 2fc7 : 68 > pla ;load status > eor_flag 0 2fc8 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2fca : dd4502 > cmp fINC,x ;test flags > trap_ne 2fcd : d0fe > bne * ;failed not equal (non zero) > 2fcf : b502 lda zpt,x 2fd1 : e8 inx 2fd2 : e002 cpx #2 2fd4 : d002 bne tinc5 2fd6 : a9fe lda #$fe 2fd8 : e005 tinc5 cpx #5 2fda : d0db bne tinc4 2fdc : ca dex 2fdd : a902 lda #2 2fdf : 9502 tdec4 sta zpt,x set_stat 0 > load_flag 0 2fe1 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2fe3 : 48 > pha ;use stack to load status 2fe4 : 28 > plp 2fe5 : d602 dec zpt,x tst_zx rINC,fINC,0 2fe7 : 08 > php ;save flags 2fe8 : b502 > lda zpt,x 2fea : dd4002 > cmp rINC,x ;test result > trap_ne 2fed : d0fe > bne * ;failed not equal (non zero) > 2fef : 68 > pla ;load status > eor_flag 0 2ff0 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2ff2 : dd4502 > cmp fINC,x ;test flags > trap_ne 2ff5 : d0fe > bne * ;failed not equal (non zero) > 2ff7 : b502 lda zpt,x 2ff9 : ca dex 2ffa : 3008 bmi tdec5 2ffc : e001 cpx #1 2ffe : d0df bne tdec4 3000 : a981 lda #$81 3002 : d0db bne tdec4 3004 : tdec5 3004 : a200 ldx #0 3006 : a97e lda #$7e 3008 : 9502 tinc14 sta zpt,x set_stat $ff > load_flag $ff 300a : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 300c : 48 > pha ;use stack to load status 300d : 28 > plp 300e : f602 inc zpt,x tst_zx rINC,fINC,$ff-fnz 3010 : 08 > php ;save flags 3011 : b502 > lda zpt,x 3013 : dd4002 > cmp rINC,x ;test result > trap_ne 3016 : d0fe > bne * ;failed not equal (non zero) > 3018 : 68 > pla ;load status > eor_flag $ff-fnz 3019 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 301b : dd4502 > cmp fINC,x ;test flags > trap_ne 301e : d0fe > bne * ;failed not equal (non zero) > 3020 : b502 lda zpt,x 3022 : e8 inx 3023 : e002 cpx #2 3025 : d002 bne tinc15 3027 : a9fe lda #$fe 3029 : e005 tinc15 cpx #5 302b : d0db bne tinc14 302d : ca dex 302e : a902 lda #2 3030 : 9502 tdec14 sta zpt,x set_stat $ff > load_flag $ff 3032 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 3034 : 48 > pha ;use stack to load status 3035 : 28 > plp 3036 : d602 dec zpt,x tst_zx rINC,fINC,$ff-fnz 3038 : 08 > php ;save flags 3039 : b502 > lda zpt,x 303b : dd4002 > cmp rINC,x ;test result > trap_ne 303e : d0fe > bne * ;failed not equal (non zero) > 3040 : 68 > pla ;load status > eor_flag $ff-fnz 3041 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 3043 : dd4502 > cmp fINC,x ;test flags > trap_ne 3046 : d0fe > bne * ;failed not equal (non zero) > 3048 : b502 lda zpt,x 304a : ca dex 304b : 3008 bmi tdec15 304d : e001 cpx #1 304f : d0df bne tdec14 3051 : a981 lda #$81 3053 : d0db bne tdec14 3055 : tdec15 next_test 3055 : ad0002 > lda test_case ;previous test 3058 : c924 > cmp #test_num > trap_ne ;test is out of sequence 305a : d0fe > bne * ;failed not equal (non zero) > 0025 = >test_num = test_num + 1 305c : a925 > lda #test_num ;*** next tests' number 305e : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; memory indexed 3061 : a200 ldx #0 3063 : a97e lda #$7e 3065 : 9d0302 tinc6 sta abst,x set_stat 0 > load_flag 0 3068 : a900 > lda #0 ;allow test to change I-flag (no mask) > 306a : 48 > pha ;use stack to load status 306b : 28 > plp 306c : fe0302 inc abst,x tst_absx rINC,fINC,0 306f : 08 > php ;save flags 3070 : bd0302 > lda abst,x 3073 : dd4002 > cmp rINC,x ;test result > trap_ne 3076 : d0fe > bne * ;failed not equal (non zero) > 3078 : 68 > pla ;load status > eor_flag 0 3079 : 4930 > eor #0|fao ;invert expected flags + always on bits > 307b : dd4502 > cmp fINC,x ;test flags > trap_ne 307e : d0fe > bne * ;failed not equal (non zero) > 3080 : bd0302 lda abst,x 3083 : e8 inx 3084 : e002 cpx #2 3086 : d002 bne tinc7 3088 : a9fe lda #$fe 308a : e005 tinc7 cpx #5 308c : d0d7 bne tinc6 308e : ca dex 308f : a902 lda #2 3091 : 9d0302 tdec6 sta abst,x set_stat 0 > load_flag 0 3094 : a900 > lda #0 ;allow test to change I-flag (no mask) > 3096 : 48 > pha ;use stack to load status 3097 : 28 > plp 3098 : de0302 dec abst,x tst_absx rINC,fINC,0 309b : 08 > php ;save flags 309c : bd0302 > lda abst,x 309f : dd4002 > cmp rINC,x ;test result > trap_ne 30a2 : d0fe > bne * ;failed not equal (non zero) > 30a4 : 68 > pla ;load status > eor_flag 0 30a5 : 4930 > eor #0|fao ;invert expected flags + always on bits > 30a7 : dd4502 > cmp fINC,x ;test flags > trap_ne 30aa : d0fe > bne * ;failed not equal (non zero) > 30ac : bd0302 lda abst,x 30af : ca dex 30b0 : 3008 bmi tdec7 30b2 : e001 cpx #1 30b4 : d0db bne tdec6 30b6 : a981 lda #$81 30b8 : d0d7 bne tdec6 30ba : tdec7 30ba : a200 ldx #0 30bc : a97e lda #$7e 30be : 9d0302 tinc16 sta abst,x set_stat $ff > load_flag $ff 30c1 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 30c3 : 48 > pha ;use stack to load status 30c4 : 28 > plp 30c5 : fe0302 inc abst,x tst_absx rINC,fINC,$ff-fnz 30c8 : 08 > php ;save flags 30c9 : bd0302 > lda abst,x 30cc : dd4002 > cmp rINC,x ;test result > trap_ne 30cf : d0fe > bne * ;failed not equal (non zero) > 30d1 : 68 > pla ;load status > eor_flag $ff-fnz 30d2 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 30d4 : dd4502 > cmp fINC,x ;test flags > trap_ne 30d7 : d0fe > bne * ;failed not equal (non zero) > 30d9 : bd0302 lda abst,x 30dc : e8 inx 30dd : e002 cpx #2 30df : d002 bne tinc17 30e1 : a9fe lda #$fe 30e3 : e005 tinc17 cpx #5 30e5 : d0d7 bne tinc16 30e7 : ca dex 30e8 : a902 lda #2 30ea : 9d0302 tdec16 sta abst,x set_stat $ff > load_flag $ff 30ed : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 30ef : 48 > pha ;use stack to load status 30f0 : 28 > plp 30f1 : de0302 dec abst,x tst_absx rINC,fINC,$ff-fnz 30f4 : 08 > php ;save flags 30f5 : bd0302 > lda abst,x 30f8 : dd4002 > cmp rINC,x ;test result > trap_ne 30fb : d0fe > bne * ;failed not equal (non zero) > 30fd : 68 > pla ;load status > eor_flag $ff-fnz 30fe : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 3100 : dd4502 > cmp fINC,x ;test flags > trap_ne 3103 : d0fe > bne * ;failed not equal (non zero) > 3105 : bd0302 lda abst,x 3108 : ca dex 3109 : 3008 bmi tdec17 310b : e001 cpx #1 310d : d0db bne tdec16 310f : a981 lda #$81 3111 : d0d7 bne tdec16 3113 : tdec17 next_test 3113 : ad0002 > lda test_case ;previous test 3116 : c925 > cmp #test_num > trap_ne ;test is out of sequence 3118 : d0fe > bne * ;failed not equal (non zero) > 0026 = >test_num = test_num + 1 311a : a926 > lda #test_num ;*** next tests' number 311c : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; testing logical instructions - AND EOR ORA all addressing modes ; AND 311f : a203 ldx #3 ;immediate 3121 : b512 tand lda zpAN,x 3123 : 8d0902 sta ex_andi+1 ;set AND # operand set_ax absANa,0 > load_flag 0 3126 : a900 > lda #0 ;allow test to change I-flag (no mask) > 3128 : 48 > pha ;use stack to load status 3129 : bd5a02 > lda absANa,x ;precharge accu 312c : 28 > plp 312d : 200802 jsr ex_andi ;execute AND # in RAM tst_ax absrlo,absflo,0 3130 : 08 > php ;save flags 3131 : dd6202 > cmp absrlo,x ;test result > trap_ne 3134 : d0fe > bne * ;failed not equal (non zero) > 3136 : 68 > pla ;load status > eor_flag 0 3137 : 4930 > eor #0|fao ;invert expected flags + always on bits > 3139 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 313c : d0fe > bne * ;failed not equal (non zero) > 313e : ca dex 313f : 10e0 bpl tand 3141 : a203 ldx #3 3143 : b512 tand1 lda zpAN,x 3145 : 8d0902 sta ex_andi+1 ;set AND # operand set_ax absANa,$ff > load_flag $ff 3148 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 314a : 48 > pha ;use stack to load status 314b : bd5a02 > lda absANa,x ;precharge accu 314e : 28 > plp 314f : 200802 jsr ex_andi ;execute AND # in RAM tst_ax absrlo,absflo,$ff-fnz 3152 : 08 > php ;save flags 3153 : dd6202 > cmp absrlo,x ;test result > trap_ne 3156 : d0fe > bne * ;failed not equal (non zero) > 3158 : 68 > pla ;load status > eor_flag $ff-fnz 3159 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 315b : dd6602 > cmp absflo,x ;test flags > trap_ne ; 315e : d0fe > bne * ;failed not equal (non zero) > 3160 : ca dex 3161 : 10e0 bpl tand1 3163 : a203 ldx #3 ;zp 3165 : b512 tand2 lda zpAN,x 3167 : 8502 sta zpt set_ax absANa,0 > load_flag 0 3169 : a900 > lda #0 ;allow test to change I-flag (no mask) > 316b : 48 > pha ;use stack to load status 316c : bd5a02 > lda absANa,x ;precharge accu 316f : 28 > plp 3170 : 2502 and zpt tst_ax absrlo,absflo,0 3172 : 08 > php ;save flags 3173 : dd6202 > cmp absrlo,x ;test result > trap_ne 3176 : d0fe > bne * ;failed not equal (non zero) > 3178 : 68 > pla ;load status > eor_flag 0 3179 : 4930 > eor #0|fao ;invert expected flags + always on bits > 317b : dd6602 > cmp absflo,x ;test flags > trap_ne ; 317e : d0fe > bne * ;failed not equal (non zero) > 3180 : ca dex 3181 : 10e2 bpl tand2 3183 : a203 ldx #3 3185 : b512 tand3 lda zpAN,x 3187 : 8502 sta zpt set_ax absANa,$ff > load_flag $ff 3189 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 318b : 48 > pha ;use stack to load status 318c : bd5a02 > lda absANa,x ;precharge accu 318f : 28 > plp 3190 : 2502 and zpt tst_ax absrlo,absflo,$ff-fnz 3192 : 08 > php ;save flags 3193 : dd6202 > cmp absrlo,x ;test result > trap_ne 3196 : d0fe > bne * ;failed not equal (non zero) > 3198 : 68 > pla ;load status > eor_flag $ff-fnz 3199 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 319b : dd6602 > cmp absflo,x ;test flags > trap_ne ; 319e : d0fe > bne * ;failed not equal (non zero) > 31a0 : ca dex 31a1 : 10e2 bpl tand3 31a3 : a203 ldx #3 ;abs 31a5 : b512 tand4 lda zpAN,x 31a7 : 8d0302 sta abst set_ax absANa,0 > load_flag 0 31aa : a900 > lda #0 ;allow test to change I-flag (no mask) > 31ac : 48 > pha ;use stack to load status 31ad : bd5a02 > lda absANa,x ;precharge accu 31b0 : 28 > plp 31b1 : 2d0302 and abst tst_ax absrlo,absflo,0 31b4 : 08 > php ;save flags 31b5 : dd6202 > cmp absrlo,x ;test result > trap_ne 31b8 : d0fe > bne * ;failed not equal (non zero) > 31ba : 68 > pla ;load status > eor_flag 0 31bb : 4930 > eor #0|fao ;invert expected flags + always on bits > 31bd : dd6602 > cmp absflo,x ;test flags > trap_ne ; 31c0 : d0fe > bne * ;failed not equal (non zero) > 31c2 : ca dex 31c3 : 10e0 bpl tand4 31c5 : a203 ldx #3 31c7 : b512 tand5 lda zpAN,x 31c9 : 8d0302 sta abst set_ax absANa,$ff > load_flag $ff 31cc : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 31ce : 48 > pha ;use stack to load status 31cf : bd5a02 > lda absANa,x ;precharge accu 31d2 : 28 > plp 31d3 : 2d0302 and abst tst_ax absrlo,absflo,$ff-fnz 31d6 : 08 > php ;save flags 31d7 : dd6202 > cmp absrlo,x ;test result > trap_ne 31da : d0fe > bne * ;failed not equal (non zero) > 31dc : 68 > pla ;load status > eor_flag $ff-fnz 31dd : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 31df : dd6602 > cmp absflo,x ;test flags > trap_ne ; 31e2 : d0fe > bne * ;failed not equal (non zero) > 31e4 : ca dex 31e5 : 1002 bpl tand6 31e7 : a203 ldx #3 ;zp,x 31e9 : tand6 set_ax absANa,0 > load_flag 0 31e9 : a900 > lda #0 ;allow test to change I-flag (no mask) > 31eb : 48 > pha ;use stack to load status 31ec : bd5a02 > lda absANa,x ;precharge accu 31ef : 28 > plp 31f0 : 3512 and zpAN,x tst_ax absrlo,absflo,0 31f2 : 08 > php ;save flags 31f3 : dd6202 > cmp absrlo,x ;test result > trap_ne 31f6 : d0fe > bne * ;failed not equal (non zero) > 31f8 : 68 > pla ;load status > eor_flag 0 31f9 : 4930 > eor #0|fao ;invert expected flags + always on bits > 31fb : dd6602 > cmp absflo,x ;test flags > trap_ne ; 31fe : d0fe > bne * ;failed not equal (non zero) > 3200 : ca dex 3201 : 10e6 bpl tand6 3203 : a203 ldx #3 3205 : tand7 set_ax absANa,$ff > load_flag $ff 3205 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 3207 : 48 > pha ;use stack to load status 3208 : bd5a02 > lda absANa,x ;precharge accu 320b : 28 > plp 320c : 3512 and zpAN,x tst_ax absrlo,absflo,$ff-fnz 320e : 08 > php ;save flags 320f : dd6202 > cmp absrlo,x ;test result > trap_ne 3212 : d0fe > bne * ;failed not equal (non zero) > 3214 : 68 > pla ;load status > eor_flag $ff-fnz 3215 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 3217 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 321a : d0fe > bne * ;failed not equal (non zero) > 321c : ca dex 321d : 10e6 bpl tand7 321f : a203 ldx #3 ;abs,x 3221 : tand8 set_ax absANa,0 > load_flag 0 3221 : a900 > lda #0 ;allow test to change I-flag (no mask) > 3223 : 48 > pha ;use stack to load status 3224 : bd5a02 > lda absANa,x ;precharge accu 3227 : 28 > plp 3228 : 3d4e02 and absAN,x tst_ax absrlo,absflo,0 322b : 08 > php ;save flags 322c : dd6202 > cmp absrlo,x ;test result > trap_ne 322f : d0fe > bne * ;failed not equal (non zero) > 3231 : 68 > pla ;load status > eor_flag 0 3232 : 4930 > eor #0|fao ;invert expected flags + always on bits > 3234 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 3237 : d0fe > bne * ;failed not equal (non zero) > 3239 : ca dex 323a : 10e5 bpl tand8 323c : a203 ldx #3 323e : tand9 set_ax absANa,$ff > load_flag $ff 323e : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 3240 : 48 > pha ;use stack to load status 3241 : bd5a02 > lda absANa,x ;precharge accu 3244 : 28 > plp 3245 : 3d4e02 and absAN,x tst_ax absrlo,absflo,$ff-fnz 3248 : 08 > php ;save flags 3249 : dd6202 > cmp absrlo,x ;test result > trap_ne 324c : d0fe > bne * ;failed not equal (non zero) > 324e : 68 > pla ;load status > eor_flag $ff-fnz 324f : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 3251 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 3254 : d0fe > bne * ;failed not equal (non zero) > 3256 : ca dex 3257 : 10e5 bpl tand9 3259 : a003 ldy #3 ;abs,y 325b : tand10 set_ay absANa,0 > load_flag 0 325b : a900 > lda #0 ;allow test to change I-flag (no mask) > 325d : 48 > pha ;use stack to load status 325e : b95a02 > lda absANa,y ;precharge accu 3261 : 28 > plp 3262 : 394e02 and absAN,y tst_ay absrlo,absflo,0 3265 : 08 > php ;save flags 3266 : d96202 > cmp absrlo,y ;test result > trap_ne ; 3269 : d0fe > bne * ;failed not equal (non zero) > 326b : 68 > pla ;load status > eor_flag 0 326c : 4930 > eor #0|fao ;invert expected flags + always on bits > 326e : d96602 > cmp absflo,y ;test flags > trap_ne 3271 : d0fe > bne * ;failed not equal (non zero) > 3273 : 88 dey 3274 : 10e5 bpl tand10 3276 : a003 ldy #3 3278 : tand11 set_ay absANa,$ff > load_flag $ff 3278 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 327a : 48 > pha ;use stack to load status 327b : b95a02 > lda absANa,y ;precharge accu 327e : 28 > plp 327f : 394e02 and absAN,y tst_ay absrlo,absflo,$ff-fnz 3282 : 08 > php ;save flags 3283 : d96202 > cmp absrlo,y ;test result > trap_ne ; 3286 : d0fe > bne * ;failed not equal (non zero) > 3288 : 68 > pla ;load status > eor_flag $ff-fnz 3289 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 328b : d96602 > cmp absflo,y ;test flags > trap_ne 328e : d0fe > bne * ;failed not equal (non zero) > 3290 : 88 dey 3291 : 10e5 bpl tand11 3293 : a206 ldx #6 ;(zp,x) 3295 : a003 ldy #3 3297 : tand12 set_ay absANa,0 > load_flag 0 3297 : a900 > lda #0 ;allow test to change I-flag (no mask) > 3299 : 48 > pha ;use stack to load status 329a : b95a02 > lda absANa,y ;precharge accu 329d : 28 > plp 329e : 2130 and (indAN,x) tst_ay absrlo,absflo,0 32a0 : 08 > php ;save flags 32a1 : d96202 > cmp absrlo,y ;test result > trap_ne ; 32a4 : d0fe > bne * ;failed not equal (non zero) > 32a6 : 68 > pla ;load status > eor_flag 0 32a7 : 4930 > eor #0|fao ;invert expected flags + always on bits > 32a9 : d96602 > cmp absflo,y ;test flags > trap_ne 32ac : d0fe > bne * ;failed not equal (non zero) > 32ae : ca dex 32af : ca dex 32b0 : 88 dey 32b1 : 10e4 bpl tand12 32b3 : a206 ldx #6 32b5 : a003 ldy #3 32b7 : tand13 set_ay absANa,$ff > load_flag $ff 32b7 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 32b9 : 48 > pha ;use stack to load status 32ba : b95a02 > lda absANa,y ;precharge accu 32bd : 28 > plp 32be : 2130 and (indAN,x) tst_ay absrlo,absflo,$ff-fnz 32c0 : 08 > php ;save flags 32c1 : d96202 > cmp absrlo,y ;test result > trap_ne ; 32c4 : d0fe > bne * ;failed not equal (non zero) > 32c6 : 68 > pla ;load status > eor_flag $ff-fnz 32c7 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 32c9 : d96602 > cmp absflo,y ;test flags > trap_ne 32cc : d0fe > bne * ;failed not equal (non zero) > 32ce : ca dex 32cf : ca dex 32d0 : 88 dey 32d1 : 10e4 bpl tand13 32d3 : a003 ldy #3 ;(zp),y 32d5 : tand14 set_ay absANa,0 > load_flag 0 32d5 : a900 > lda #0 ;allow test to change I-flag (no mask) > 32d7 : 48 > pha ;use stack to load status 32d8 : b95a02 > lda absANa,y ;precharge accu 32db : 28 > plp 32dc : 3130 and (indAN),y tst_ay absrlo,absflo,0 32de : 08 > php ;save flags 32df : d96202 > cmp absrlo,y ;test result > trap_ne ; 32e2 : d0fe > bne * ;failed not equal (non zero) > 32e4 : 68 > pla ;load status > eor_flag 0 32e5 : 4930 > eor #0|fao ;invert expected flags + always on bits > 32e7 : d96602 > cmp absflo,y ;test flags > trap_ne 32ea : d0fe > bne * ;failed not equal (non zero) > 32ec : 88 dey 32ed : 10e6 bpl tand14 32ef : a003 ldy #3 32f1 : tand15 set_ay absANa,$ff > load_flag $ff 32f1 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 32f3 : 48 > pha ;use stack to load status 32f4 : b95a02 > lda absANa,y ;precharge accu 32f7 : 28 > plp 32f8 : 3130 and (indAN),y tst_ay absrlo,absflo,$ff-fnz 32fa : 08 > php ;save flags 32fb : d96202 > cmp absrlo,y ;test result > trap_ne ; 32fe : d0fe > bne * ;failed not equal (non zero) > 3300 : 68 > pla ;load status > eor_flag $ff-fnz 3301 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 3303 : d96602 > cmp absflo,y ;test flags > trap_ne 3306 : d0fe > bne * ;failed not equal (non zero) > 3308 : 88 dey 3309 : 10e6 bpl tand15 next_test 330b : ad0002 > lda test_case ;previous test 330e : c926 > cmp #test_num > trap_ne ;test is out of sequence 3310 : d0fe > bne * ;failed not equal (non zero) > 0027 = >test_num = test_num + 1 3312 : a927 > lda #test_num ;*** next tests' number 3314 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; EOR 3317 : a203 ldx #3 ;immediate - self modifying code 3319 : b516 teor lda zpEO,x 331b : 8d0c02 sta ex_eori+1 ;set EOR # operand set_ax absEOa,0 > load_flag 0 331e : a900 > lda #0 ;allow test to change I-flag (no mask) > 3320 : 48 > pha ;use stack to load status 3321 : bd5e02 > lda absEOa,x ;precharge accu 3324 : 28 > plp 3325 : 200b02 jsr ex_eori ;execute EOR # in RAM tst_ax absrlo,absflo,0 3328 : 08 > php ;save flags 3329 : dd6202 > cmp absrlo,x ;test result > trap_ne 332c : d0fe > bne * ;failed not equal (non zero) > 332e : 68 > pla ;load status > eor_flag 0 332f : 4930 > eor #0|fao ;invert expected flags + always on bits > 3331 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 3334 : d0fe > bne * ;failed not equal (non zero) > 3336 : ca dex 3337 : 10e0 bpl teor 3339 : a203 ldx #3 333b : b516 teor1 lda zpEO,x 333d : 8d0c02 sta ex_eori+1 ;set EOR # operand set_ax absEOa,$ff > load_flag $ff 3340 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 3342 : 48 > pha ;use stack to load status 3343 : bd5e02 > lda absEOa,x ;precharge accu 3346 : 28 > plp 3347 : 200b02 jsr ex_eori ;execute EOR # in RAM tst_ax absrlo,absflo,$ff-fnz 334a : 08 > php ;save flags 334b : dd6202 > cmp absrlo,x ;test result > trap_ne 334e : d0fe > bne * ;failed not equal (non zero) > 3350 : 68 > pla ;load status > eor_flag $ff-fnz 3351 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 3353 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 3356 : d0fe > bne * ;failed not equal (non zero) > 3358 : ca dex 3359 : 10e0 bpl teor1 335b : a203 ldx #3 ;zp 335d : b516 teor2 lda zpEO,x 335f : 8502 sta zpt set_ax absEOa,0 > load_flag 0 3361 : a900 > lda #0 ;allow test to change I-flag (no mask) > 3363 : 48 > pha ;use stack to load status 3364 : bd5e02 > lda absEOa,x ;precharge accu 3367 : 28 > plp 3368 : 4502 eor zpt tst_ax absrlo,absflo,0 336a : 08 > php ;save flags 336b : dd6202 > cmp absrlo,x ;test result > trap_ne 336e : d0fe > bne * ;failed not equal (non zero) > 3370 : 68 > pla ;load status > eor_flag 0 3371 : 4930 > eor #0|fao ;invert expected flags + always on bits > 3373 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 3376 : d0fe > bne * ;failed not equal (non zero) > 3378 : ca dex 3379 : 10e2 bpl teor2 337b : a203 ldx #3 337d : b516 teor3 lda zpEO,x 337f : 8502 sta zpt set_ax absEOa,$ff > load_flag $ff 3381 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 3383 : 48 > pha ;use stack to load status 3384 : bd5e02 > lda absEOa,x ;precharge accu 3387 : 28 > plp 3388 : 4502 eor zpt tst_ax absrlo,absflo,$ff-fnz 338a : 08 > php ;save flags 338b : dd6202 > cmp absrlo,x ;test result > trap_ne 338e : d0fe > bne * ;failed not equal (non zero) > 3390 : 68 > pla ;load status > eor_flag $ff-fnz 3391 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 3393 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 3396 : d0fe > bne * ;failed not equal (non zero) > 3398 : ca dex 3399 : 10e2 bpl teor3 339b : a203 ldx #3 ;abs 339d : b516 teor4 lda zpEO,x 339f : 8d0302 sta abst set_ax absEOa,0 > load_flag 0 33a2 : a900 > lda #0 ;allow test to change I-flag (no mask) > 33a4 : 48 > pha ;use stack to load status 33a5 : bd5e02 > lda absEOa,x ;precharge accu 33a8 : 28 > plp 33a9 : 4d0302 eor abst tst_ax absrlo,absflo,0 33ac : 08 > php ;save flags 33ad : dd6202 > cmp absrlo,x ;test result > trap_ne 33b0 : d0fe > bne * ;failed not equal (non zero) > 33b2 : 68 > pla ;load status > eor_flag 0 33b3 : 4930 > eor #0|fao ;invert expected flags + always on bits > 33b5 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 33b8 : d0fe > bne * ;failed not equal (non zero) > 33ba : ca dex 33bb : 10e0 bpl teor4 33bd : a203 ldx #3 33bf : b516 teor5 lda zpEO,x 33c1 : 8d0302 sta abst set_ax absEOa,$ff > load_flag $ff 33c4 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 33c6 : 48 > pha ;use stack to load status 33c7 : bd5e02 > lda absEOa,x ;precharge accu 33ca : 28 > plp 33cb : 4d0302 eor abst tst_ax absrlo,absflo,$ff-fnz 33ce : 08 > php ;save flags 33cf : dd6202 > cmp absrlo,x ;test result > trap_ne 33d2 : d0fe > bne * ;failed not equal (non zero) > 33d4 : 68 > pla ;load status > eor_flag $ff-fnz 33d5 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 33d7 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 33da : d0fe > bne * ;failed not equal (non zero) > 33dc : ca dex 33dd : 1002 bpl teor6 33df : a203 ldx #3 ;zp,x 33e1 : teor6 set_ax absEOa,0 > load_flag 0 33e1 : a900 > lda #0 ;allow test to change I-flag (no mask) > 33e3 : 48 > pha ;use stack to load status 33e4 : bd5e02 > lda absEOa,x ;precharge accu 33e7 : 28 > plp 33e8 : 5516 eor zpEO,x tst_ax absrlo,absflo,0 33ea : 08 > php ;save flags 33eb : dd6202 > cmp absrlo,x ;test result > trap_ne 33ee : d0fe > bne * ;failed not equal (non zero) > 33f0 : 68 > pla ;load status > eor_flag 0 33f1 : 4930 > eor #0|fao ;invert expected flags + always on bits > 33f3 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 33f6 : d0fe > bne * ;failed not equal (non zero) > 33f8 : ca dex 33f9 : 10e6 bpl teor6 33fb : a203 ldx #3 33fd : teor7 set_ax absEOa,$ff > load_flag $ff 33fd : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 33ff : 48 > pha ;use stack to load status 3400 : bd5e02 > lda absEOa,x ;precharge accu 3403 : 28 > plp 3404 : 5516 eor zpEO,x tst_ax absrlo,absflo,$ff-fnz 3406 : 08 > php ;save flags 3407 : dd6202 > cmp absrlo,x ;test result > trap_ne 340a : d0fe > bne * ;failed not equal (non zero) > 340c : 68 > pla ;load status > eor_flag $ff-fnz 340d : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 340f : dd6602 > cmp absflo,x ;test flags > trap_ne ; 3412 : d0fe > bne * ;failed not equal (non zero) > 3414 : ca dex 3415 : 10e6 bpl teor7 3417 : a203 ldx #3 ;abs,x 3419 : teor8 set_ax absEOa,0 > load_flag 0 3419 : a900 > lda #0 ;allow test to change I-flag (no mask) > 341b : 48 > pha ;use stack to load status 341c : bd5e02 > lda absEOa,x ;precharge accu 341f : 28 > plp 3420 : 5d5202 eor absEO,x tst_ax absrlo,absflo,0 3423 : 08 > php ;save flags 3424 : dd6202 > cmp absrlo,x ;test result > trap_ne 3427 : d0fe > bne * ;failed not equal (non zero) > 3429 : 68 > pla ;load status > eor_flag 0 342a : 4930 > eor #0|fao ;invert expected flags + always on bits > 342c : dd6602 > cmp absflo,x ;test flags > trap_ne ; 342f : d0fe > bne * ;failed not equal (non zero) > 3431 : ca dex 3432 : 10e5 bpl teor8 3434 : a203 ldx #3 3436 : teor9 set_ax absEOa,$ff > load_flag $ff 3436 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 3438 : 48 > pha ;use stack to load status 3439 : bd5e02 > lda absEOa,x ;precharge accu 343c : 28 > plp 343d : 5d5202 eor absEO,x tst_ax absrlo,absflo,$ff-fnz 3440 : 08 > php ;save flags 3441 : dd6202 > cmp absrlo,x ;test result > trap_ne 3444 : d0fe > bne * ;failed not equal (non zero) > 3446 : 68 > pla ;load status > eor_flag $ff-fnz 3447 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 3449 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 344c : d0fe > bne * ;failed not equal (non zero) > 344e : ca dex 344f : 10e5 bpl teor9 3451 : a003 ldy #3 ;abs,y 3453 : teor10 set_ay absEOa,0 > load_flag 0 3453 : a900 > lda #0 ;allow test to change I-flag (no mask) > 3455 : 48 > pha ;use stack to load status 3456 : b95e02 > lda absEOa,y ;precharge accu 3459 : 28 > plp 345a : 595202 eor absEO,y tst_ay absrlo,absflo,0 345d : 08 > php ;save flags 345e : d96202 > cmp absrlo,y ;test result > trap_ne ; 3461 : d0fe > bne * ;failed not equal (non zero) > 3463 : 68 > pla ;load status > eor_flag 0 3464 : 4930 > eor #0|fao ;invert expected flags + always on bits > 3466 : d96602 > cmp absflo,y ;test flags > trap_ne 3469 : d0fe > bne * ;failed not equal (non zero) > 346b : 88 dey 346c : 10e5 bpl teor10 346e : a003 ldy #3 3470 : teor11 set_ay absEOa,$ff > load_flag $ff 3470 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 3472 : 48 > pha ;use stack to load status 3473 : b95e02 > lda absEOa,y ;precharge accu 3476 : 28 > plp 3477 : 595202 eor absEO,y tst_ay absrlo,absflo,$ff-fnz 347a : 08 > php ;save flags 347b : d96202 > cmp absrlo,y ;test result > trap_ne ; 347e : d0fe > bne * ;failed not equal (non zero) > 3480 : 68 > pla ;load status > eor_flag $ff-fnz 3481 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 3483 : d96602 > cmp absflo,y ;test flags > trap_ne 3486 : d0fe > bne * ;failed not equal (non zero) > 3488 : 88 dey 3489 : 10e5 bpl teor11 348b : a206 ldx #6 ;(zp,x) 348d : a003 ldy #3 348f : teor12 set_ay absEOa,0 > load_flag 0 348f : a900 > lda #0 ;allow test to change I-flag (no mask) > 3491 : 48 > pha ;use stack to load status 3492 : b95e02 > lda absEOa,y ;precharge accu 3495 : 28 > plp 3496 : 4138 eor (indEO,x) tst_ay absrlo,absflo,0 3498 : 08 > php ;save flags 3499 : d96202 > cmp absrlo,y ;test result > trap_ne ; 349c : d0fe > bne * ;failed not equal (non zero) > 349e : 68 > pla ;load status > eor_flag 0 349f : 4930 > eor #0|fao ;invert expected flags + always on bits > 34a1 : d96602 > cmp absflo,y ;test flags > trap_ne 34a4 : d0fe > bne * ;failed not equal (non zero) > 34a6 : ca dex 34a7 : ca dex 34a8 : 88 dey 34a9 : 10e4 bpl teor12 34ab : a206 ldx #6 34ad : a003 ldy #3 34af : teor13 set_ay absEOa,$ff > load_flag $ff 34af : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 34b1 : 48 > pha ;use stack to load status 34b2 : b95e02 > lda absEOa,y ;precharge accu 34b5 : 28 > plp 34b6 : 4138 eor (indEO,x) tst_ay absrlo,absflo,$ff-fnz 34b8 : 08 > php ;save flags 34b9 : d96202 > cmp absrlo,y ;test result > trap_ne ; 34bc : d0fe > bne * ;failed not equal (non zero) > 34be : 68 > pla ;load status > eor_flag $ff-fnz 34bf : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 34c1 : d96602 > cmp absflo,y ;test flags > trap_ne 34c4 : d0fe > bne * ;failed not equal (non zero) > 34c6 : ca dex 34c7 : ca dex 34c8 : 88 dey 34c9 : 10e4 bpl teor13 34cb : a003 ldy #3 ;(zp),y 34cd : teor14 set_ay absEOa,0 > load_flag 0 34cd : a900 > lda #0 ;allow test to change I-flag (no mask) > 34cf : 48 > pha ;use stack to load status 34d0 : b95e02 > lda absEOa,y ;precharge accu 34d3 : 28 > plp 34d4 : 5138 eor (indEO),y tst_ay absrlo,absflo,0 34d6 : 08 > php ;save flags 34d7 : d96202 > cmp absrlo,y ;test result > trap_ne ; 34da : d0fe > bne * ;failed not equal (non zero) > 34dc : 68 > pla ;load status > eor_flag 0 34dd : 4930 > eor #0|fao ;invert expected flags + always on bits > 34df : d96602 > cmp absflo,y ;test flags > trap_ne 34e2 : d0fe > bne * ;failed not equal (non zero) > 34e4 : 88 dey 34e5 : 10e6 bpl teor14 34e7 : a003 ldy #3 34e9 : teor15 set_ay absEOa,$ff > load_flag $ff 34e9 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 34eb : 48 > pha ;use stack to load status 34ec : b95e02 > lda absEOa,y ;precharge accu 34ef : 28 > plp 34f0 : 5138 eor (indEO),y tst_ay absrlo,absflo,$ff-fnz 34f2 : 08 > php ;save flags 34f3 : d96202 > cmp absrlo,y ;test result > trap_ne ; 34f6 : d0fe > bne * ;failed not equal (non zero) > 34f8 : 68 > pla ;load status > eor_flag $ff-fnz 34f9 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 34fb : d96602 > cmp absflo,y ;test flags > trap_ne 34fe : d0fe > bne * ;failed not equal (non zero) > 3500 : 88 dey 3501 : 10e6 bpl teor15 next_test 3503 : ad0002 > lda test_case ;previous test 3506 : c927 > cmp #test_num > trap_ne ;test is out of sequence 3508 : d0fe > bne * ;failed not equal (non zero) > 0028 = >test_num = test_num + 1 350a : a928 > lda #test_num ;*** next tests' number 350c : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; OR 350f : a203 ldx #3 ;immediate - self modifying code 3511 : b50e tora lda zpOR,x 3513 : 8d0f02 sta ex_orai+1 ;set ORA # operand set_ax absORa,0 > load_flag 0 3516 : a900 > lda #0 ;allow test to change I-flag (no mask) > 3518 : 48 > pha ;use stack to load status 3519 : bd5602 > lda absORa,x ;precharge accu 351c : 28 > plp 351d : 200e02 jsr ex_orai ;execute ORA # in RAM tst_ax absrlo,absflo,0 3520 : 08 > php ;save flags 3521 : dd6202 > cmp absrlo,x ;test result > trap_ne 3524 : d0fe > bne * ;failed not equal (non zero) > 3526 : 68 > pla ;load status > eor_flag 0 3527 : 4930 > eor #0|fao ;invert expected flags + always on bits > 3529 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 352c : d0fe > bne * ;failed not equal (non zero) > 352e : ca dex 352f : 10e0 bpl tora 3531 : a203 ldx #3 3533 : b50e tora1 lda zpOR,x 3535 : 8d0f02 sta ex_orai+1 ;set ORA # operand set_ax absORa,$ff > load_flag $ff 3538 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 353a : 48 > pha ;use stack to load status 353b : bd5602 > lda absORa,x ;precharge accu 353e : 28 > plp 353f : 200e02 jsr ex_orai ;execute ORA # in RAM tst_ax absrlo,absflo,$ff-fnz 3542 : 08 > php ;save flags 3543 : dd6202 > cmp absrlo,x ;test result > trap_ne 3546 : d0fe > bne * ;failed not equal (non zero) > 3548 : 68 > pla ;load status > eor_flag $ff-fnz 3549 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 354b : dd6602 > cmp absflo,x ;test flags > trap_ne ; 354e : d0fe > bne * ;failed not equal (non zero) > 3550 : ca dex 3551 : 10e0 bpl tora1 3553 : a203 ldx #3 ;zp 3555 : b50e tora2 lda zpOR,x 3557 : 8502 sta zpt set_ax absORa,0 > load_flag 0 3559 : a900 > lda #0 ;allow test to change I-flag (no mask) > 355b : 48 > pha ;use stack to load status 355c : bd5602 > lda absORa,x ;precharge accu 355f : 28 > plp 3560 : 0502 ora zpt tst_ax absrlo,absflo,0 3562 : 08 > php ;save flags 3563 : dd6202 > cmp absrlo,x ;test result > trap_ne 3566 : d0fe > bne * ;failed not equal (non zero) > 3568 : 68 > pla ;load status > eor_flag 0 3569 : 4930 > eor #0|fao ;invert expected flags + always on bits > 356b : dd6602 > cmp absflo,x ;test flags > trap_ne ; 356e : d0fe > bne * ;failed not equal (non zero) > 3570 : ca dex 3571 : 10e2 bpl tora2 3573 : a203 ldx #3 3575 : b50e tora3 lda zpOR,x 3577 : 8502 sta zpt set_ax absORa,$ff > load_flag $ff 3579 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 357b : 48 > pha ;use stack to load status 357c : bd5602 > lda absORa,x ;precharge accu 357f : 28 > plp 3580 : 0502 ora zpt tst_ax absrlo,absflo,$ff-fnz 3582 : 08 > php ;save flags 3583 : dd6202 > cmp absrlo,x ;test result > trap_ne 3586 : d0fe > bne * ;failed not equal (non zero) > 3588 : 68 > pla ;load status > eor_flag $ff-fnz 3589 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 358b : dd6602 > cmp absflo,x ;test flags > trap_ne ; 358e : d0fe > bne * ;failed not equal (non zero) > 3590 : ca dex 3591 : 10e2 bpl tora3 3593 : a203 ldx #3 ;abs 3595 : b50e tora4 lda zpOR,x 3597 : 8d0302 sta abst set_ax absORa,0 > load_flag 0 359a : a900 > lda #0 ;allow test to change I-flag (no mask) > 359c : 48 > pha ;use stack to load status 359d : bd5602 > lda absORa,x ;precharge accu 35a0 : 28 > plp 35a1 : 0d0302 ora abst tst_ax absrlo,absflo,0 35a4 : 08 > php ;save flags 35a5 : dd6202 > cmp absrlo,x ;test result > trap_ne 35a8 : d0fe > bne * ;failed not equal (non zero) > 35aa : 68 > pla ;load status > eor_flag 0 35ab : 4930 > eor #0|fao ;invert expected flags + always on bits > 35ad : dd6602 > cmp absflo,x ;test flags > trap_ne ; 35b0 : d0fe > bne * ;failed not equal (non zero) > 35b2 : ca dex 35b3 : 10e0 bpl tora4 35b5 : a203 ldx #3 35b7 : b50e tora5 lda zpOR,x 35b9 : 8d0302 sta abst set_ax absORa,$ff > load_flag $ff 35bc : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 35be : 48 > pha ;use stack to load status 35bf : bd5602 > lda absORa,x ;precharge accu 35c2 : 28 > plp 35c3 : 0d0302 ora abst tst_ax absrlo,absflo,$ff-fnz 35c6 : 08 > php ;save flags 35c7 : dd6202 > cmp absrlo,x ;test result > trap_ne 35ca : d0fe > bne * ;failed not equal (non zero) > 35cc : 68 > pla ;load status > eor_flag $ff-fnz 35cd : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 35cf : dd6602 > cmp absflo,x ;test flags > trap_ne ; 35d2 : d0fe > bne * ;failed not equal (non zero) > 35d4 : ca dex 35d5 : 1002 bpl tora6 35d7 : a203 ldx #3 ;zp,x 35d9 : tora6 set_ax absORa,0 > load_flag 0 35d9 : a900 > lda #0 ;allow test to change I-flag (no mask) > 35db : 48 > pha ;use stack to load status 35dc : bd5602 > lda absORa,x ;precharge accu 35df : 28 > plp 35e0 : 150e ora zpOR,x tst_ax absrlo,absflo,0 35e2 : 08 > php ;save flags 35e3 : dd6202 > cmp absrlo,x ;test result > trap_ne 35e6 : d0fe > bne * ;failed not equal (non zero) > 35e8 : 68 > pla ;load status > eor_flag 0 35e9 : 4930 > eor #0|fao ;invert expected flags + always on bits > 35eb : dd6602 > cmp absflo,x ;test flags > trap_ne ; 35ee : d0fe > bne * ;failed not equal (non zero) > 35f0 : ca dex 35f1 : 10e6 bpl tora6 35f3 : a203 ldx #3 35f5 : tora7 set_ax absORa,$ff > load_flag $ff 35f5 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 35f7 : 48 > pha ;use stack to load status 35f8 : bd5602 > lda absORa,x ;precharge accu 35fb : 28 > plp 35fc : 150e ora zpOR,x tst_ax absrlo,absflo,$ff-fnz 35fe : 08 > php ;save flags 35ff : dd6202 > cmp absrlo,x ;test result > trap_ne 3602 : d0fe > bne * ;failed not equal (non zero) > 3604 : 68 > pla ;load status > eor_flag $ff-fnz 3605 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 3607 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 360a : d0fe > bne * ;failed not equal (non zero) > 360c : ca dex 360d : 10e6 bpl tora7 360f : a203 ldx #3 ;abs,x 3611 : tora8 set_ax absORa,0 > load_flag 0 3611 : a900 > lda #0 ;allow test to change I-flag (no mask) > 3613 : 48 > pha ;use stack to load status 3614 : bd5602 > lda absORa,x ;precharge accu 3617 : 28 > plp 3618 : 1d4a02 ora absOR,x tst_ax absrlo,absflo,0 361b : 08 > php ;save flags 361c : dd6202 > cmp absrlo,x ;test result > trap_ne 361f : d0fe > bne * ;failed not equal (non zero) > 3621 : 68 > pla ;load status > eor_flag 0 3622 : 4930 > eor #0|fao ;invert expected flags + always on bits > 3624 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 3627 : d0fe > bne * ;failed not equal (non zero) > 3629 : ca dex 362a : 10e5 bpl tora8 362c : a203 ldx #3 362e : tora9 set_ax absORa,$ff > load_flag $ff 362e : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 3630 : 48 > pha ;use stack to load status 3631 : bd5602 > lda absORa,x ;precharge accu 3634 : 28 > plp 3635 : 1d4a02 ora absOR,x tst_ax absrlo,absflo,$ff-fnz 3638 : 08 > php ;save flags 3639 : dd6202 > cmp absrlo,x ;test result > trap_ne 363c : d0fe > bne * ;failed not equal (non zero) > 363e : 68 > pla ;load status > eor_flag $ff-fnz 363f : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 3641 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 3644 : d0fe > bne * ;failed not equal (non zero) > 3646 : ca dex 3647 : 10e5 bpl tora9 3649 : a003 ldy #3 ;abs,y 364b : tora10 set_ay absORa,0 > load_flag 0 364b : a900 > lda #0 ;allow test to change I-flag (no mask) > 364d : 48 > pha ;use stack to load status 364e : b95602 > lda absORa,y ;precharge accu 3651 : 28 > plp 3652 : 194a02 ora absOR,y tst_ay absrlo,absflo,0 3655 : 08 > php ;save flags 3656 : d96202 > cmp absrlo,y ;test result > trap_ne ; 3659 : d0fe > bne * ;failed not equal (non zero) > 365b : 68 > pla ;load status > eor_flag 0 365c : 4930 > eor #0|fao ;invert expected flags + always on bits > 365e : d96602 > cmp absflo,y ;test flags > trap_ne 3661 : d0fe > bne * ;failed not equal (non zero) > 3663 : 88 dey 3664 : 10e5 bpl tora10 3666 : a003 ldy #3 3668 : tora11 set_ay absORa,$ff > load_flag $ff 3668 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 366a : 48 > pha ;use stack to load status 366b : b95602 > lda absORa,y ;precharge accu 366e : 28 > plp 366f : 194a02 ora absOR,y tst_ay absrlo,absflo,$ff-fnz 3672 : 08 > php ;save flags 3673 : d96202 > cmp absrlo,y ;test result > trap_ne ; 3676 : d0fe > bne * ;failed not equal (non zero) > 3678 : 68 > pla ;load status > eor_flag $ff-fnz 3679 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 367b : d96602 > cmp absflo,y ;test flags > trap_ne 367e : d0fe > bne * ;failed not equal (non zero) > 3680 : 88 dey 3681 : 10e5 bpl tora11 3683 : a206 ldx #6 ;(zp,x) 3685 : a003 ldy #3 3687 : tora12 set_ay absORa,0 > load_flag 0 3687 : a900 > lda #0 ;allow test to change I-flag (no mask) > 3689 : 48 > pha ;use stack to load status 368a : b95602 > lda absORa,y ;precharge accu 368d : 28 > plp 368e : 0140 ora (indOR,x) tst_ay absrlo,absflo,0 3690 : 08 > php ;save flags 3691 : d96202 > cmp absrlo,y ;test result > trap_ne ; 3694 : d0fe > bne * ;failed not equal (non zero) > 3696 : 68 > pla ;load status > eor_flag 0 3697 : 4930 > eor #0|fao ;invert expected flags + always on bits > 3699 : d96602 > cmp absflo,y ;test flags > trap_ne 369c : d0fe > bne * ;failed not equal (non zero) > 369e : ca dex 369f : ca dex 36a0 : 88 dey 36a1 : 10e4 bpl tora12 36a3 : a206 ldx #6 36a5 : a003 ldy #3 36a7 : tora13 set_ay absORa,$ff > load_flag $ff 36a7 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 36a9 : 48 > pha ;use stack to load status 36aa : b95602 > lda absORa,y ;precharge accu 36ad : 28 > plp 36ae : 0140 ora (indOR,x) tst_ay absrlo,absflo,$ff-fnz 36b0 : 08 > php ;save flags 36b1 : d96202 > cmp absrlo,y ;test result > trap_ne ; 36b4 : d0fe > bne * ;failed not equal (non zero) > 36b6 : 68 > pla ;load status > eor_flag $ff-fnz 36b7 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 36b9 : d96602 > cmp absflo,y ;test flags > trap_ne 36bc : d0fe > bne * ;failed not equal (non zero) > 36be : ca dex 36bf : ca dex 36c0 : 88 dey 36c1 : 10e4 bpl tora13 36c3 : a003 ldy #3 ;(zp),y 36c5 : tora14 set_ay absORa,0 > load_flag 0 36c5 : a900 > lda #0 ;allow test to change I-flag (no mask) > 36c7 : 48 > pha ;use stack to load status 36c8 : b95602 > lda absORa,y ;precharge accu 36cb : 28 > plp 36cc : 1140 ora (indOR),y tst_ay absrlo,absflo,0 36ce : 08 > php ;save flags 36cf : d96202 > cmp absrlo,y ;test result > trap_ne ; 36d2 : d0fe > bne * ;failed not equal (non zero) > 36d4 : 68 > pla ;load status > eor_flag 0 36d5 : 4930 > eor #0|fao ;invert expected flags + always on bits > 36d7 : d96602 > cmp absflo,y ;test flags > trap_ne 36da : d0fe > bne * ;failed not equal (non zero) > 36dc : 88 dey 36dd : 10e6 bpl tora14 36df : a003 ldy #3 36e1 : tora15 set_ay absORa,$ff > load_flag $ff 36e1 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 36e3 : 48 > pha ;use stack to load status 36e4 : b95602 > lda absORa,y ;precharge accu 36e7 : 28 > plp 36e8 : 1140 ora (indOR),y tst_ay absrlo,absflo,$ff-fnz 36ea : 08 > php ;save flags 36eb : d96202 > cmp absrlo,y ;test result > trap_ne ; 36ee : d0fe > bne * ;failed not equal (non zero) > 36f0 : 68 > pla ;load status > eor_flag $ff-fnz 36f1 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 36f3 : d96602 > cmp absflo,y ;test flags > trap_ne 36f6 : d0fe > bne * ;failed not equal (non zero) > 36f8 : 88 dey 36f9 : 10e6 bpl tora15 if I_flag = 3 36fb : 58 cli endif next_test 36fc : ad0002 > lda test_case ;previous test 36ff : c928 > cmp #test_num > trap_ne ;test is out of sequence 3701 : d0fe > bne * ;failed not equal (non zero) > 0029 = >test_num = test_num + 1 3703 : a929 > lda #test_num ;*** next tests' number 3705 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; full binary add/subtract test ; iterates through all combinations of operands and carry input ; uses increments/decrements to predict result & result flags 3708 : d8 cld 3709 : a204 ldx #ad2 ;for indexed test 370b : a0ff ldy #$ff ;max range 370d : a900 lda #0 ;start with adding zeroes & no carry 370f : 8502 sta adfc ;carry in - for diag 3711 : 8503 sta ad1 ;operand 1 - accumulator 3713 : 8504 sta ad2 ;operand 2 - memory or immediate 3715 : 8d0302 sta ada2 ;non zp 3718 : 8505 sta adrl ;expected result bits 0-7 371a : 8506 sta adrh ;expected result bit 8 (carry out) 371c : a9ff lda #$ff ;complemented operand 2 for subtract 371e : 8508 sta sb2 3720 : 8d0402 sta sba2 ;non zp 3723 : a902 lda #2 ;expected Z-flag 3725 : 8507 sta adrf 3727 : 18 tadd clc ;test with carry clear 3728 : 20a239 jsr chkadd 372b : e602 inc adfc ;now with carry 372d : e605 inc adrl ;result +1 372f : 08 php ;save N & Z from low result 3730 : 08 php 3731 : 68 pla ;accu holds expected flags 3732 : 2982 and #$82 ;mask N & Z 3734 : 28 plp 3735 : d002 bne tadd1 3737 : e606 inc adrh ;result bit 8 - carry 3739 : 0506 tadd1 ora adrh ;merge C to expected flags 373b : 8507 sta adrf ;save expected flags except overflow 373d : 38 sec ;test with carry set 373e : 20a239 jsr chkadd 3741 : c602 dec adfc ;same for operand +1 but no carry 3743 : e603 inc ad1 3745 : d0e0 bne tadd ;iterate op1 3747 : a900 lda #0 ;preset result to op2 when op1 = 0 3749 : 8506 sta adrh 374b : ee0302 inc ada2 374e : e604 inc ad2 3750 : 08 php ;save NZ as operand 2 becomes the new result 3751 : 68 pla 3752 : 2982 and #$82 ;mask N00000Z0 3754 : 8507 sta adrf ;no need to check carry as we are adding to 0 3756 : c608 dec sb2 ;complement subtract operand 2 3758 : ce0402 dec sba2 375b : a504 lda ad2 375d : 8505 sta adrl 375f : d0c6 bne tadd ;iterate op2 if disable_decimal < 1 next_test 3761 : ad0002 > lda test_case ;previous test 3764 : c929 > cmp #test_num > trap_ne ;test is out of sequence 3766 : d0fe > bne * ;failed not equal (non zero) > 002a = >test_num = test_num + 1 3768 : a92a > lda #test_num ;*** next tests' number 376a : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; decimal add/subtract test ; *** WARNING - tests documented behavior only! *** ; only valid BCD operands are tested, N V Z flags are ignored ; iterates through all valid combinations of operands and carry input ; uses increments/decrements to predict result & carry flag 376d : f8 sed 376e : a204 ldx #ad2 ;for indexed test 3770 : a0ff ldy #$ff ;max range 3772 : a999 lda #$99 ;start with adding 99 to 99 with carry 3774 : 8503 sta ad1 ;operand 1 - accumulator 3776 : 8504 sta ad2 ;operand 2 - memory or immediate 3778 : 8d0302 sta ada2 ;non zp 377b : 8505 sta adrl ;expected result bits 0-7 377d : a901 lda #1 ;set carry in & out 377f : 8502 sta adfc ;carry in - for diag 3781 : 8506 sta adrh ;expected result bit 8 (carry out) 3783 : a900 lda #0 ;complemented operand 2 for subtract 3785 : 8508 sta sb2 3787 : 8d0402 sta sba2 ;non zp 378a : 38 tdad sec ;test with carry set 378b : 206f38 jsr chkdad 378e : c602 dec adfc ;now with carry clear 3790 : a505 lda adrl ;decimal adjust result 3792 : d008 bne tdad1 ;skip clear carry & preset result 99 (9A-1) 3794 : c606 dec adrh 3796 : a999 lda #$99 3798 : 8505 sta adrl 379a : d012 bne tdad3 379c : 290f tdad1 and #$f ;lower nibble mask 379e : d00c bne tdad2 ;no decimal adjust needed 37a0 : c605 dec adrl ;decimal adjust (?0-6) 37a2 : c605 dec adrl 37a4 : c605 dec adrl 37a6 : c605 dec adrl 37a8 : c605 dec adrl 37aa : c605 dec adrl 37ac : c605 tdad2 dec adrl ;result -1 37ae : 18 tdad3 clc ;test with carry clear 37af : 206f38 jsr chkdad 37b2 : e602 inc adfc ;same for operand -1 but with carry 37b4 : a503 lda ad1 ;decimal adjust operand 1 37b6 : f015 beq tdad5 ;iterate operand 2 37b8 : 290f and #$f ;lower nibble mask 37ba : d00c bne tdad4 ;skip decimal adjust 37bc : c603 dec ad1 ;decimal adjust (?0-6) 37be : c603 dec ad1 37c0 : c603 dec ad1 37c2 : c603 dec ad1 37c4 : c603 dec ad1 37c6 : c603 dec ad1 37c8 : c603 tdad4 dec ad1 ;operand 1 -1 37ca : 4c8a37 jmp tdad ;iterate op1 37cd : a999 tdad5 lda #$99 ;precharge op1 max 37cf : 8503 sta ad1 37d1 : a504 lda ad2 ;decimal adjust operand 2 37d3 : f030 beq tdad7 ;end of iteration 37d5 : 290f and #$f ;lower nibble mask 37d7 : d018 bne tdad6 ;skip decimal adjust 37d9 : c604 dec ad2 ;decimal adjust (?0-6) 37db : c604 dec ad2 37dd : c604 dec ad2 37df : c604 dec ad2 37e1 : c604 dec ad2 37e3 : c604 dec ad2 37e5 : e608 inc sb2 ;complemented decimal adjust for subtract (?9+6) 37e7 : e608 inc sb2 37e9 : e608 inc sb2 37eb : e608 inc sb2 37ed : e608 inc sb2 37ef : e608 inc sb2 37f1 : c604 tdad6 dec ad2 ;operand 2 -1 37f3 : e608 inc sb2 ;complemented operand for subtract 37f5 : a508 lda sb2 37f7 : 8d0402 sta sba2 ;copy as non zp operand 37fa : a504 lda ad2 37fc : 8d0302 sta ada2 ;copy as non zp operand 37ff : 8505 sta adrl ;new result since op1+carry=00+carry +op2=op2 3801 : e606 inc adrh ;result carry 3803 : d085 bne tdad ;iterate op2 3805 : tdad7 next_test 3805 : ad0002 > lda test_case ;previous test 3808 : c92a > cmp #test_num > trap_ne ;test is out of sequence 380a : d0fe > bne * ;failed not equal (non zero) > 002b = >test_num = test_num + 1 380c : a92b > lda #test_num ;*** next tests' number 380e : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; decimal/binary switch test ; tests CLD, SED, PLP, RTI to properly switch between decimal & binary opcode ; tables 3811 : 18 clc 3812 : d8 cld 3813 : 08 php 3814 : a955 lda #$55 3816 : 6955 adc #$55 3818 : c9aa cmp #$aa trap_ne ;expected binary result after cld 381a : d0fe > bne * ;failed not equal (non zero) 381c : 18 clc 381d : f8 sed 381e : 08 php 381f : a955 lda #$55 3821 : 6955 adc #$55 3823 : c910 cmp #$10 trap_ne ;expected decimal result after sed 3825 : d0fe > bne * ;failed not equal (non zero) 3827 : d8 cld 3828 : 28 plp 3829 : a955 lda #$55 382b : 6955 adc #$55 382d : c910 cmp #$10 trap_ne ;expected decimal result after plp D=1 382f : d0fe > bne * ;failed not equal (non zero) 3831 : 28 plp 3832 : a955 lda #$55 3834 : 6955 adc #$55 3836 : c9aa cmp #$aa trap_ne ;expected binary result after plp D=0 3838 : d0fe > bne * ;failed not equal (non zero) 383a : 18 clc 383b : a938 lda #hi bin_rti_ret ;emulated interrupt for rti 383d : 48 pha 383e : a955 lda #lo bin_rti_ret 3840 : 48 pha 3841 : 08 php 3842 : f8 sed 3843 : a938 lda #hi dec_rti_ret ;emulated interrupt for rti 3845 : 48 pha 3846 : a94c lda #lo dec_rti_ret 3848 : 48 pha 3849 : 08 php 384a : d8 cld 384b : 40 rti 384c : dec_rti_ret 384c : a955 lda #$55 384e : 6955 adc #$55 3850 : c910 cmp #$10 trap_ne ;expected decimal result after rti D=1 3852 : d0fe > bne * ;failed not equal (non zero) 3854 : 40 rti 3855 : bin_rti_ret 3855 : a955 lda #$55 3857 : 6955 adc #$55 3859 : c9aa cmp #$aa trap_ne ;expected binary result after rti D=0 385b : d0fe > bne * ;failed not equal (non zero) endif 385d : ad0002 lda test_case 3860 : c92b cmp #test_num trap_ne ;previous test is out of sequence 3862 : d0fe > bne * ;failed not equal (non zero) 3864 : a9f0 lda #$f0 ;mark opcode testing complete 3866 : 8d0002 sta test_case ; final RAM integrity test ; verifies that none of the previous tests has altered RAM outside of the ; designated write areas. check_ram > ;RAM check disabled - RAM size not set ; *** DEBUG INFO *** ; to debug checksum errors uncomment check_ram in the next_test macro to ; narrow down the responsible opcode. ; may give false errors when monitor, OS or other background activity is ; allowed during previous tests. ; S U C C E S S ************************************************ ; ------------- success ;if you get here everything went well 3869 : 4c6938 > jmp * ;test passed, no errors ; ------------- ; S U C C E S S ************************************************ 386c : 4c0008 jmp start ;run again if disable_decimal < 1 ; core subroutine of the decimal add/subtract test ; *** WARNING - tests documented behavior only! *** ; only valid BCD operands are tested, N V Z flags are ignored ; iterates through all valid combinations of operands and carry input ; uses increments/decrements to predict result & carry flag 386f : chkdad ; decimal ADC / SBC zp 386f : 08 php ;save carry for subtract 3870 : a503 lda ad1 3872 : 6504 adc ad2 ;perform add 3874 : 08 php 3875 : c505 cmp adrl ;check result trap_ne ;bad result 3877 : d0fe > bne * ;failed not equal (non zero) 3879 : 68 pla ;check flags 387a : 2901 and #1 ;mask carry 387c : c506 cmp adrh trap_ne ;bad carry 387e : d0fe > bne * ;failed not equal (non zero) 3880 : 28 plp 3881 : 08 php ;save carry for next add 3882 : a503 lda ad1 3884 : e508 sbc sb2 ;perform subtract 3886 : 08 php 3887 : c505 cmp adrl ;check result trap_ne ;bad result 3889 : d0fe > bne * ;failed not equal (non zero) 388b : 68 pla ;check flags 388c : 2901 and #1 ;mask carry 388e : c506 cmp adrh trap_ne ;bad flags 3890 : d0fe > bne * ;failed not equal (non zero) 3892 : 28 plp ; decimal ADC / SBC abs 3893 : 08 php ;save carry for subtract 3894 : a503 lda ad1 3896 : 6d0302 adc ada2 ;perform add 3899 : 08 php 389a : c505 cmp adrl ;check result trap_ne ;bad result 389c : d0fe > bne * ;failed not equal (non zero) 389e : 68 pla ;check flags 389f : 2901 and #1 ;mask carry 38a1 : c506 cmp adrh trap_ne ;bad carry 38a3 : d0fe > bne * ;failed not equal (non zero) 38a5 : 28 plp 38a6 : 08 php ;save carry for next add 38a7 : a503 lda ad1 38a9 : ed0402 sbc sba2 ;perform subtract 38ac : 08 php 38ad : c505 cmp adrl ;check result trap_ne ;bad result 38af : d0fe > bne * ;failed not equal (non zero) 38b1 : 68 pla ;check flags 38b2 : 2901 and #1 ;mask carry 38b4 : c506 cmp adrh trap_ne ;bad carry 38b6 : d0fe > bne * ;failed not equal (non zero) 38b8 : 28 plp ; decimal ADC / SBC # 38b9 : 08 php ;save carry for subtract 38ba : a504 lda ad2 38bc : 8d1202 sta ex_adci+1 ;set ADC # operand 38bf : a503 lda ad1 38c1 : 201102 jsr ex_adci ;execute ADC # in RAM 38c4 : 08 php 38c5 : c505 cmp adrl ;check result trap_ne ;bad result 38c7 : d0fe > bne * ;failed not equal (non zero) 38c9 : 68 pla ;check flags 38ca : 2901 and #1 ;mask carry 38cc : c506 cmp adrh trap_ne ;bad carry 38ce : d0fe > bne * ;failed not equal (non zero) 38d0 : 28 plp 38d1 : 08 php ;save carry for next add 38d2 : a508 lda sb2 38d4 : 8d1502 sta ex_sbci+1 ;set SBC # operand 38d7 : a503 lda ad1 38d9 : 201402 jsr ex_sbci ;execute SBC # in RAM 38dc : 08 php 38dd : c505 cmp adrl ;check result trap_ne ;bad result 38df : d0fe > bne * ;failed not equal (non zero) 38e1 : 68 pla ;check flags 38e2 : 2901 and #1 ;mask carry 38e4 : c506 cmp adrh trap_ne ;bad carry 38e6 : d0fe > bne * ;failed not equal (non zero) 38e8 : 28 plp ; decimal ADC / SBC zp,x 38e9 : 08 php ;save carry for subtract 38ea : a503 lda ad1 38ec : 7500 adc 0,x ;perform add 38ee : 08 php 38ef : c505 cmp adrl ;check result trap_ne ;bad result 38f1 : d0fe > bne * ;failed not equal (non zero) 38f3 : 68 pla ;check flags 38f4 : 2901 and #1 ;mask carry 38f6 : c506 cmp adrh trap_ne ;bad carry 38f8 : d0fe > bne * ;failed not equal (non zero) 38fa : 28 plp 38fb : 08 php ;save carry for next add 38fc : a503 lda ad1 38fe : f504 sbc sb2-ad2,x ;perform subtract 3900 : 08 php 3901 : c505 cmp adrl ;check result trap_ne ;bad result 3903 : d0fe > bne * ;failed not equal (non zero) 3905 : 68 pla ;check flags 3906 : 2901 and #1 ;mask carry 3908 : c506 cmp adrh trap_ne ;bad carry 390a : d0fe > bne * ;failed not equal (non zero) 390c : 28 plp ; decimal ADC / SBC abs,x 390d : 08 php ;save carry for subtract 390e : a503 lda ad1 3910 : 7dff01 adc ada2-ad2,x ;perform add 3913 : 08 php 3914 : c505 cmp adrl ;check result trap_ne ;bad result 3916 : d0fe > bne * ;failed not equal (non zero) 3918 : 68 pla ;check flags 3919 : 2901 and #1 ;mask carry 391b : c506 cmp adrh trap_ne ;bad carry 391d : d0fe > bne * ;failed not equal (non zero) 391f : 28 plp 3920 : 08 php ;save carry for next add 3921 : a503 lda ad1 3923 : fd0002 sbc sba2-ad2,x ;perform subtract 3926 : 08 php 3927 : c505 cmp adrl ;check result trap_ne ;bad result 3929 : d0fe > bne * ;failed not equal (non zero) 392b : 68 pla ;check flags 392c : 2901 and #1 ;mask carry 392e : c506 cmp adrh trap_ne ;bad carry 3930 : d0fe > bne * ;failed not equal (non zero) 3932 : 28 plp ; decimal ADC / SBC abs,y 3933 : 08 php ;save carry for subtract 3934 : a503 lda ad1 3936 : 790401 adc ada2-$ff,y ;perform add 3939 : 08 php 393a : c505 cmp adrl ;check result trap_ne ;bad result 393c : d0fe > bne * ;failed not equal (non zero) 393e : 68 pla ;check flags 393f : 2901 and #1 ;mask carry 3941 : c506 cmp adrh trap_ne ;bad carry 3943 : d0fe > bne * ;failed not equal (non zero) 3945 : 28 plp 3946 : 08 php ;save carry for next add 3947 : a503 lda ad1 3949 : f90501 sbc sba2-$ff,y ;perform subtract 394c : 08 php 394d : c505 cmp adrl ;check result trap_ne ;bad result 394f : d0fe > bne * ;failed not equal (non zero) 3951 : 68 pla ;check flags 3952 : 2901 and #1 ;mask carry 3954 : c506 cmp adrh trap_ne ;bad carry 3956 : d0fe > bne * ;failed not equal (non zero) 3958 : 28 plp ; decimal ADC / SBC (zp,x) 3959 : 08 php ;save carry for subtract 395a : a503 lda ad1 395c : 6144 adc (lo adi2-ad2,x) ;perform add 395e : 08 php 395f : c505 cmp adrl ;check result trap_ne ;bad result 3961 : d0fe > bne * ;failed not equal (non zero) 3963 : 68 pla ;check flags 3964 : 2901 and #1 ;mask carry 3966 : c506 cmp adrh trap_ne ;bad carry 3968 : d0fe > bne * ;failed not equal (non zero) 396a : 28 plp 396b : 08 php ;save carry for next add 396c : a503 lda ad1 396e : e146 sbc (lo sbi2-ad2,x) ;perform subtract 3970 : 08 php 3971 : c505 cmp adrl ;check result trap_ne ;bad result 3973 : d0fe > bne * ;failed not equal (non zero) 3975 : 68 pla ;check flags 3976 : 2901 and #1 ;mask carry 3978 : c506 cmp adrh trap_ne ;bad carry 397a : d0fe > bne * ;failed not equal (non zero) 397c : 28 plp ; decimal ADC / SBC (abs),y 397d : 08 php ;save carry for subtract 397e : a503 lda ad1 3980 : 714c adc (adiy2),y ;perform add 3982 : 08 php 3983 : c505 cmp adrl ;check result trap_ne ;bad result 3985 : d0fe > bne * ;failed not equal (non zero) 3987 : 68 pla ;check flags 3988 : 2901 and #1 ;mask carry 398a : c506 cmp adrh trap_ne ;bad carry 398c : d0fe > bne * ;failed not equal (non zero) 398e : 28 plp 398f : 08 php ;save carry for next add 3990 : a503 lda ad1 3992 : f14e sbc (sbiy2),y ;perform subtract 3994 : 08 php 3995 : c505 cmp adrl ;check result trap_ne ;bad result 3997 : d0fe > bne * ;failed not equal (non zero) 3999 : 68 pla ;check flags 399a : 2901 and #1 ;mask carry 399c : c506 cmp adrh trap_ne ;bad carry 399e : d0fe > bne * ;failed not equal (non zero) 39a0 : 28 plp 39a1 : 60 rts endif ; core subroutine of the full binary add/subtract test ; iterates through all combinations of operands and carry input ; uses increments/decrements to predict result & result flags 39a2 : a507 chkadd lda adrf ;add V-flag if overflow 39a4 : 2983 and #$83 ;keep N-----ZC / clear V 39a6 : 48 pha 39a7 : a503 lda ad1 ;test sign unequal between operands 39a9 : 4504 eor ad2 39ab : 300a bmi ckad1 ;no overflow possible - operands have different sign 39ad : a503 lda ad1 ;test sign equal between operands and result 39af : 4505 eor adrl 39b1 : 1004 bpl ckad1 ;no overflow occured - operand and result have same sign 39b3 : 68 pla 39b4 : 0940 ora #$40 ;set V 39b6 : 48 pha 39b7 : 68 ckad1 pla 39b8 : 8507 sta adrf ;save expected flags ; binary ADC / SBC zp 39ba : 08 php ;save carry for subtract 39bb : a503 lda ad1 39bd : 6504 adc ad2 ;perform add 39bf : 08 php 39c0 : c505 cmp adrl ;check result trap_ne ;bad result 39c2 : d0fe > bne * ;failed not equal (non zero) 39c4 : 68 pla ;check flags 39c5 : 29c3 and #$c3 ;mask NV----ZC 39c7 : c507 cmp adrf trap_ne ;bad flags 39c9 : d0fe > bne * ;failed not equal (non zero) 39cb : 28 plp 39cc : 08 php ;save carry for next add 39cd : a503 lda ad1 39cf : e508 sbc sb2 ;perform subtract 39d1 : 08 php 39d2 : c505 cmp adrl ;check result trap_ne ;bad result 39d4 : d0fe > bne * ;failed not equal (non zero) 39d6 : 68 pla ;check flags 39d7 : 29c3 and #$c3 ;mask NV----ZC 39d9 : c507 cmp adrf trap_ne ;bad flags 39db : d0fe > bne * ;failed not equal (non zero) 39dd : 28 plp ; binary ADC / SBC abs 39de : 08 php ;save carry for subtract 39df : a503 lda ad1 39e1 : 6d0302 adc ada2 ;perform add 39e4 : 08 php 39e5 : c505 cmp adrl ;check result trap_ne ;bad result 39e7 : d0fe > bne * ;failed not equal (non zero) 39e9 : 68 pla ;check flags 39ea : 29c3 and #$c3 ;mask NV----ZC 39ec : c507 cmp adrf trap_ne ;bad flags 39ee : d0fe > bne * ;failed not equal (non zero) 39f0 : 28 plp 39f1 : 08 php ;save carry for next add 39f2 : a503 lda ad1 39f4 : ed0402 sbc sba2 ;perform subtract 39f7 : 08 php 39f8 : c505 cmp adrl ;check result trap_ne ;bad result 39fa : d0fe > bne * ;failed not equal (non zero) 39fc : 68 pla ;check flags 39fd : 29c3 and #$c3 ;mask NV----ZC 39ff : c507 cmp adrf trap_ne ;bad flags 3a01 : d0fe > bne * ;failed not equal (non zero) 3a03 : 28 plp ; binary ADC / SBC # 3a04 : 08 php ;save carry for subtract 3a05 : a504 lda ad2 3a07 : 8d1202 sta ex_adci+1 ;set ADC # operand 3a0a : a503 lda ad1 3a0c : 201102 jsr ex_adci ;execute ADC # in RAM 3a0f : 08 php 3a10 : c505 cmp adrl ;check result trap_ne ;bad result 3a12 : d0fe > bne * ;failed not equal (non zero) 3a14 : 68 pla ;check flags 3a15 : 29c3 and #$c3 ;mask NV----ZC 3a17 : c507 cmp adrf trap_ne ;bad flags 3a19 : d0fe > bne * ;failed not equal (non zero) 3a1b : 28 plp 3a1c : 08 php ;save carry for next add 3a1d : a508 lda sb2 3a1f : 8d1502 sta ex_sbci+1 ;set SBC # operand 3a22 : a503 lda ad1 3a24 : 201402 jsr ex_sbci ;execute SBC # in RAM 3a27 : 08 php 3a28 : c505 cmp adrl ;check result trap_ne ;bad result 3a2a : d0fe > bne * ;failed not equal (non zero) 3a2c : 68 pla ;check flags 3a2d : 29c3 and #$c3 ;mask NV----ZC 3a2f : c507 cmp adrf trap_ne ;bad flags 3a31 : d0fe > bne * ;failed not equal (non zero) 3a33 : 28 plp ; binary ADC / SBC zp,x 3a34 : 08 php ;save carry for subtract 3a35 : a503 lda ad1 3a37 : 7500 adc 0,x ;perform add 3a39 : 08 php 3a3a : c505 cmp adrl ;check result trap_ne ;bad result 3a3c : d0fe > bne * ;failed not equal (non zero) 3a3e : 68 pla ;check flags 3a3f : 29c3 and #$c3 ;mask NV----ZC 3a41 : c507 cmp adrf trap_ne ;bad flags 3a43 : d0fe > bne * ;failed not equal (non zero) 3a45 : 28 plp 3a46 : 08 php ;save carry for next add 3a47 : a503 lda ad1 3a49 : f504 sbc sb2-ad2,x ;perform subtract 3a4b : 08 php 3a4c : c505 cmp adrl ;check result trap_ne ;bad result 3a4e : d0fe > bne * ;failed not equal (non zero) 3a50 : 68 pla ;check flags 3a51 : 29c3 and #$c3 ;mask NV----ZC 3a53 : c507 cmp adrf trap_ne ;bad flags 3a55 : d0fe > bne * ;failed not equal (non zero) 3a57 : 28 plp ; binary ADC / SBC abs,x 3a58 : 08 php ;save carry for subtract 3a59 : a503 lda ad1 3a5b : 7dff01 adc ada2-ad2,x ;perform add 3a5e : 08 php 3a5f : c505 cmp adrl ;check result trap_ne ;bad result 3a61 : d0fe > bne * ;failed not equal (non zero) 3a63 : 68 pla ;check flags 3a64 : 29c3 and #$c3 ;mask NV----ZC 3a66 : c507 cmp adrf trap_ne ;bad flags 3a68 : d0fe > bne * ;failed not equal (non zero) 3a6a : 28 plp 3a6b : 08 php ;save carry for next add 3a6c : a503 lda ad1 3a6e : fd0002 sbc sba2-ad2,x ;perform subtract 3a71 : 08 php 3a72 : c505 cmp adrl ;check result trap_ne ;bad result 3a74 : d0fe > bne * ;failed not equal (non zero) 3a76 : 68 pla ;check flags 3a77 : 29c3 and #$c3 ;mask NV----ZC 3a79 : c507 cmp adrf trap_ne ;bad flags 3a7b : d0fe > bne * ;failed not equal (non zero) 3a7d : 28 plp ; binary ADC / SBC abs,y 3a7e : 08 php ;save carry for subtract 3a7f : a503 lda ad1 3a81 : 790401 adc ada2-$ff,y ;perform add 3a84 : 08 php 3a85 : c505 cmp adrl ;check result trap_ne ;bad result 3a87 : d0fe > bne * ;failed not equal (non zero) 3a89 : 68 pla ;check flags 3a8a : 29c3 and #$c3 ;mask NV----ZC 3a8c : c507 cmp adrf trap_ne ;bad flags 3a8e : d0fe > bne * ;failed not equal (non zero) 3a90 : 28 plp 3a91 : 08 php ;save carry for next add 3a92 : a503 lda ad1 3a94 : f90501 sbc sba2-$ff,y ;perform subtract 3a97 : 08 php 3a98 : c505 cmp adrl ;check result trap_ne ;bad result 3a9a : d0fe > bne * ;failed not equal (non zero) 3a9c : 68 pla ;check flags 3a9d : 29c3 and #$c3 ;mask NV----ZC 3a9f : c507 cmp adrf trap_ne ;bad flags 3aa1 : d0fe > bne * ;failed not equal (non zero) 3aa3 : 28 plp ; binary ADC / SBC (zp,x) 3aa4 : 08 php ;save carry for subtract 3aa5 : a503 lda ad1 3aa7 : 6144 adc (lo adi2-ad2,x) ;perform add 3aa9 : 08 php 3aaa : c505 cmp adrl ;check result trap_ne ;bad result 3aac : d0fe > bne * ;failed not equal (non zero) 3aae : 68 pla ;check flags 3aaf : 29c3 and #$c3 ;mask NV----ZC 3ab1 : c507 cmp adrf trap_ne ;bad flags 3ab3 : d0fe > bne * ;failed not equal (non zero) 3ab5 : 28 plp 3ab6 : 08 php ;save carry for next add 3ab7 : a503 lda ad1 3ab9 : e146 sbc (lo sbi2-ad2,x) ;perform subtract 3abb : 08 php 3abc : c505 cmp adrl ;check result trap_ne ;bad result 3abe : d0fe > bne * ;failed not equal (non zero) 3ac0 : 68 pla ;check flags 3ac1 : 29c3 and #$c3 ;mask NV----ZC 3ac3 : c507 cmp adrf trap_ne ;bad flags 3ac5 : d0fe > bne * ;failed not equal (non zero) 3ac7 : 28 plp ; binary ADC / SBC (abs),y 3ac8 : 08 php ;save carry for subtract 3ac9 : a503 lda ad1 3acb : 714c adc (adiy2),y ;perform add 3acd : 08 php 3ace : c505 cmp adrl ;check result trap_ne ;bad result 3ad0 : d0fe > bne * ;failed not equal (non zero) 3ad2 : 68 pla ;check flags 3ad3 : 29c3 and #$c3 ;mask NV----ZC 3ad5 : c507 cmp adrf trap_ne ;bad flags 3ad7 : d0fe > bne * ;failed not equal (non zero) 3ad9 : 28 plp 3ada : 08 php ;save carry for next add 3adb : a503 lda ad1 3add : f14e sbc (sbiy2),y ;perform subtract 3adf : 08 php 3ae0 : c505 cmp adrl ;check result trap_ne ;bad result 3ae2 : d0fe > bne * ;failed not equal (non zero) 3ae4 : 68 pla ;check flags 3ae5 : 29c3 and #$c3 ;mask NV----ZC 3ae7 : c507 cmp adrf trap_ne ;bad flags 3ae9 : d0fe > bne * ;failed not equal (non zero) 3aeb : 28 plp 3aec : 60 rts ; target for the jump absolute test 3aed : 88 dey 3aee : 88 dey 3aef : test_far 3aef : 08 php ;either SP or Y count will fail, if we do not hit 3af0 : 88 dey 3af1 : 88 dey 3af2 : 88 dey 3af3 : 28 plp trap_cs ;flags loaded? 3af4 : b0fe > bcs * ;failed carry set trap_vs 3af6 : 70fe > bvs * ;failed overflow set trap_mi 3af8 : 30fe > bmi * ;failed minus (bit 7 set) trap_eq 3afa : f0fe > beq * ;failed equal (zero) 3afc : c946 cmp #'F' ;registers loaded? trap_ne 3afe : d0fe > bne * ;failed not equal (non zero) 3b00 : e041 cpx #'A' trap_ne 3b02 : d0fe > bne * ;failed not equal (non zero) 3b04 : c04f cpy #('R'-3) trap_ne 3b06 : d0fe > bne * ;failed not equal (non zero) 3b08 : 48 pha ;save a,x 3b09 : 8a txa 3b0a : 48 pha 3b0b : ba tsx 3b0c : e0fd cpx #$fd ;check SP trap_ne 3b0e : d0fe > bne * ;failed not equal (non zero) 3b10 : 68 pla ;restore x 3b11 : aa tax set_stat $ff > load_flag $ff 3b12 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 3b14 : 48 > pha ;use stack to load status 3b15 : 28 > plp 3b16 : 68 pla ;restore a 3b17 : e8 inx ;return registers with modifications 3b18 : 49aa eor #$aa ;N=1, V=1, Z=0, C=1 3b1a : 4c0f0d jmp far_ret ; target for the jump indirect test 3b1d : 00 align 3b1e : 273b ptr_tst_ind dw test_ind 3b20 : 640d ptr_ind_ret dw ind_ret trap ;runover protection 3b22 : 4c223b > jmp * ;failed anyway 3b25 : 88 dey 3b26 : 88 dey 3b27 : test_ind 3b27 : 08 php ;either SP or Y count will fail, if we do not hit 3b28 : 88 dey 3b29 : 88 dey 3b2a : 88 dey 3b2b : 28 plp trap_cs ;flags loaded? 3b2c : b0fe > bcs * ;failed carry set trap_vs 3b2e : 70fe > bvs * ;failed overflow set trap_mi 3b30 : 30fe > bmi * ;failed minus (bit 7 set) trap_eq 3b32 : f0fe > beq * ;failed equal (zero) 3b34 : c949 cmp #'I' ;registers loaded? trap_ne 3b36 : d0fe > bne * ;failed not equal (non zero) 3b38 : e04e cpx #'N' trap_ne 3b3a : d0fe > bne * ;failed not equal (non zero) 3b3c : c041 cpy #('D'-3) trap_ne 3b3e : d0fe > bne * ;failed not equal (non zero) 3b40 : 48 pha ;save a,x 3b41 : 8a txa 3b42 : 48 pha 3b43 : ba tsx 3b44 : e0fd cpx #$fd ;check SP trap_ne 3b46 : d0fe > bne * ;failed not equal (non zero) 3b48 : 68 pla ;restore x 3b49 : aa tax set_stat $ff > load_flag $ff 3b4a : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 3b4c : 48 > pha ;use stack to load status 3b4d : 28 > plp 3b4e : 68 pla ;restore a 3b4f : e8 inx ;return registers with modifications 3b50 : 49aa eor #$aa ;N=1, V=1, Z=0, C=1 3b52 : 6c203b jmp (ptr_ind_ret) trap ;runover protection 3b55 : 4c553b > jmp * ;failed anyway 3b58 : 4c0008 jmp start ;catastrophic error - cannot continue ; target for the jump subroutine test 3b5b : 88 dey 3b5c : 88 dey 3b5d : test_jsr 3b5d : 08 php ;either SP or Y count will fail, if we do not hit 3b5e : 88 dey 3b5f : 88 dey 3b60 : 88 dey 3b61 : 28 plp trap_cs ;flags loaded? 3b62 : b0fe > bcs * ;failed carry set trap_vs 3b64 : 70fe > bvs * ;failed overflow set trap_mi 3b66 : 30fe > bmi * ;failed minus (bit 7 set) trap_eq 3b68 : f0fe > beq * ;failed equal (zero) 3b6a : c94a cmp #'J' ;registers loaded? trap_ne 3b6c : d0fe > bne * ;failed not equal (non zero) 3b6e : e053 cpx #'S' trap_ne 3b70 : d0fe > bne * ;failed not equal (non zero) 3b72 : c04f cpy #('R'-3) trap_ne 3b74 : d0fe > bne * ;failed not equal (non zero) 3b76 : 48 pha ;save a,x 3b77 : 8a txa 3b78 : 48 pha 3b79 : ba tsx ;sp -4? (return addr,a,x) 3b7a : e0fb cpx #$fb trap_ne 3b7c : d0fe > bne * ;failed not equal (non zero) 3b7e : adff01 lda $1ff ;propper return on stack 3b81 : c90d cmp #hi(jsr_ret) trap_ne 3b83 : d0fe > bne * ;failed not equal (non zero) 3b85 : adfe01 lda $1fe 3b88 : c99a cmp #lo(jsr_ret) trap_ne 3b8a : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 3b8c : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 3b8e : 48 > pha ;use stack to load status 3b8f : 28 > plp 3b90 : 68 pla ;pull x,a 3b91 : aa tax 3b92 : 68 pla 3b93 : e8 inx ;return registers with modifications 3b94 : 49aa eor #$aa ;N=1, V=1, Z=0, C=1 3b96 : 60 rts trap ;runover protection 3b97 : 4c973b > jmp * ;failed anyway 3b9a : 4c0008 jmp start ;catastrophic error - cannot continue ;trap in case of unexpected IRQ, NMI, BRK, RESET - BRK test target 3b9d : nmi_trap trap ;check stack for conditions at NMI 3b9d : 4c9d3b > jmp * ;failed anyway 3ba0 : 4c0008 jmp start ;catastrophic error - cannot continue 3ba3 : res_trap trap ;unexpected RESET 3ba3 : 4ca33b > jmp * ;failed anyway 3ba6 : 4c0008 jmp start ;catastrophic error - cannot continue 3ba9 : 88 dey 3baa : 88 dey 3bab : irq_trap ;BRK test or unextpected BRK or IRQ 3bab : 08 php ;either SP or Y count will fail, if we do not hit 3bac : 88 dey 3bad : 88 dey 3bae : 88 dey ;next traps could be caused by unexpected BRK or IRQ ;check stack for BREAK and originating location ;possible jump/branch into weeds (uninitialized space) 3baf : c9bd cmp #$ff-'B' ;BRK pass 2 registers loaded? 3bb1 : f042 beq break2 3bb3 : c942 cmp #'B' ;BRK pass 1 registers loaded? trap_ne 3bb5 : d0fe > bne * ;failed not equal (non zero) 3bb7 : e052 cpx #'R' trap_ne 3bb9 : d0fe > bne * ;failed not equal (non zero) 3bbb : c048 cpy #'K'-3 trap_ne 3bbd : d0fe > bne * ;failed not equal (non zero) 3bbf : 8500 sta irq_a ;save registers during break test 3bc1 : 8601 stx irq_x 3bc3 : ba tsx ;test break on stack 3bc4 : bd0201 lda $102,x cmp_flag 0 ;break test should have B=1 & unused=1 on stack 3bc7 : c930 > cmp #(0 |fao)&m8 ;expected flags + always on bits trap_ne ; - no break flag on stack 3bc9 : d0fe > bne * ;failed not equal (non zero) 3bcb : 68 pla cmp_flag intdis ;should have added interrupt disable 3bcc : c934 > cmp #(intdis |fao)&m8 ;expected flags + always on bits trap_ne 3bce : d0fe > bne * ;failed not equal (non zero) 3bd0 : ba tsx 3bd1 : e0fc cpx #$fc ;sp -3? (return addr, flags) trap_ne 3bd3 : d0fe > bne * ;failed not equal (non zero) 3bd5 : adff01 lda $1ff ;propper return on stack 3bd8 : c90d cmp #hi(brk_ret0) trap_ne 3bda : d0fe > bne * ;failed not equal (non zero) 3bdc : adfe01 lda $1fe 3bdf : c9d1 cmp #lo(brk_ret0) trap_ne 3be1 : d0fe > bne * ;failed not equal (non zero) load_flag $ff 3be3 : a9ff > lda #$ff ;allow test to change I-flag (no mask) 3be5 : 48 pha 3be6 : a601 ldx irq_x 3be8 : e8 inx ;return registers with modifications 3be9 : a500 lda irq_a 3beb : 49aa eor #$aa 3bed : 28 plp ;N=1, V=1, Z=1, C=1 but original flags should be restored 3bee : 40 rti trap ;runover protection 3bef : 4cef3b > jmp * ;failed anyway 3bf2 : 4c0008 jmp start ;catastrophic error - cannot continue 3bf5 : break2 ;BRK pass 2 3bf5 : e0ad cpx #$ff-'R' trap_ne 3bf7 : d0fe > bne * ;failed not equal (non zero) 3bf9 : c0b1 cpy #$ff-'K'-3 trap_ne 3bfb : d0fe > bne * ;failed not equal (non zero) 3bfd : 8500 sta irq_a ;save registers during break test 3bff : 8601 stx irq_x 3c01 : ba tsx ;test break on stack 3c02 : bd0201 lda $102,x cmp_flag $ff ;break test should have B=1 3c05 : c9ff > cmp #($ff |fao)&m8 ;expected flags + always on bits trap_ne ; - no break flag on stack 3c07 : d0fe > bne * ;failed not equal (non zero) 3c09 : 68 pla 3c0a : 0908 ora #decmode ;ignore decmode cleared if 65c02 cmp_flag $ff ;actual passed flags 3c0c : c9ff > cmp #($ff |fao)&m8 ;expected flags + always on bits trap_ne 3c0e : d0fe > bne * ;failed not equal (non zero) 3c10 : ba tsx 3c11 : e0fc cpx #$fc ;sp -3? (return addr, flags) trap_ne 3c13 : d0fe > bne * ;failed not equal (non zero) 3c15 : adff01 lda $1ff ;propper return on stack 3c18 : c90d cmp #hi(brk_ret1) trap_ne 3c1a : d0fe > bne * ;failed not equal (non zero) 3c1c : adfe01 lda $1fe 3c1f : c9f7 cmp #lo(brk_ret1) trap_ne 3c21 : d0fe > bne * ;failed not equal (non zero) load_flag intdis 3c23 : a904 > lda #intdis ;allow test to change I-flag (no mask) 3c25 : 48 pha 3c26 : a601 ldx irq_x 3c28 : e8 inx ;return registers with modifications 3c29 : a500 lda irq_a 3c2b : 49aa eor #$aa 3c2d : 28 plp ;N=0, V=0, Z=0, C=0 but original flags should be restored 3c2e : 40 rti trap ;runover protection 3c2f : 4c2f3c > jmp * ;failed anyway 3c32 : 4c0008 jmp start ;catastrophic error - cannot continue if report = 1 include "report.i65" endif ;copy of data to initialize BSS segment if load_data_direct != 1 zp_init zp1_ db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR zp7f_ db $7f ;test pattern for compare ;logical zeropage operands zpOR_ db 0,$1f,$71,$80 ;test pattern for OR zpAN_ db $0f,$ff,$7f,$80 ;test pattern for AND zpEO_ db $ff,$0f,$8f,$8f ;test pattern for EOR ;indirect addressing pointers ind1_ dw abs1 ;indirect pointer to pattern in absolute memory dw abs1+1 dw abs1+2 dw abs1+3 dw abs7f inw1_ dw abs1-$f8 ;indirect pointer for wrap-test pattern indt_ dw abst ;indirect pointer to store area in absolute memory dw abst+1 dw abst+2 dw abst+3 inwt_ dw abst-$f8 ;indirect pointer for wrap-test store indAN_ dw absAN ;indirect pointer to AND pattern in absolute memory dw absAN+1 dw absAN+2 dw absAN+3 indEO_ dw absEO ;indirect pointer to EOR pattern in absolute memory dw absEO+1 dw absEO+2 dw absEO+3 indOR_ dw absOR ;indirect pointer to OR pattern in absolute memory dw absOR+1 dw absOR+2 dw absOR+3 ;add/subtract indirect pointers adi2_ dw ada2 ;indirect pointer to operand 2 in absolute memory sbi2_ dw sba2 ;indirect pointer to complemented operand 2 (SBC) adiy2_ dw ada2-$ff ;with offset for indirect indexed sbiy2_ dw sba2-$ff zp_end if (zp_end - zp_init) != (zp_bss_end - zp_bss) ;force assembler error if size is different ERROR ERROR ERROR ;mismatch between bss and zeropage data endif data_init ex_and_ and #0 ;execute immediate opcodes rts ex_eor_ eor #0 ;execute immediate opcodes rts ex_ora_ ora #0 ;execute immediate opcodes rts ex_adc_ adc #0 ;execute immediate opcodes rts ex_sbc_ sbc #0 ;execute immediate opcodes rts abs1_ db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR abs7f_ db $7f ;test pattern for compare ;loads fLDx_ db fn,fn,0,fz ;expected flags for load ;shifts rASL_ ;expected result ASL & ROL -carry rROL_ db $86,$04,$82,0 ; " rROLc_ db $87,$05,$83,1 ;expected result ROL +carry rLSR_ ;expected result LSR & ROR -carry rROR_ db $61,$41,$20,0 ; " rRORc_ db $e1,$c1,$a0,$80 ;expected result ROR +carry fASL_ ;expected flags for shifts fROL_ db fnc,fc,fn,fz ;no carry in fROLc_ db fnc,fc,fn,0 ;carry in fLSR_ fROR_ db fc,0,fc,fz ;no carry in fRORc_ db fnc,fn,fnc,fn ;carry in ;increments (decrements) rINC_ db $7f,$80,$ff,0,1 ;expected result for INC/DEC fINC_ db 0,fn,fn,fz,0 ;expected flags for INC/DEC ;logical memory operand absOR_ db 0,$1f,$71,$80 ;test pattern for OR absAN_ db $0f,$ff,$7f,$80 ;test pattern for AND absEO_ db $ff,$0f,$8f,$8f ;test pattern for EOR ;logical accu operand absORa_ db 0,$f1,$1f,0 ;test pattern for OR absANa_ db $f0,$ff,$ff,$ff ;test pattern for AND absEOa_ db $ff,$f0,$f0,$0f ;test pattern for EOR ;logical results absrlo_ db 0,$ff,$7f,$80 absflo_ db fz,fn,0,fn data_end if (data_end - data_init) != (data_bss_end - data_bss) ;force assembler error if size is different ERROR ERROR ERROR ;mismatch between bss and data endif vec_init dw nmi_trap dw res_trap dw irq_trap vec_bss equ $fffa endif ;end of RAM init data if (load_data_direct = 1) & (ROM_vectors = 1) fffa = org $fffa ;vectors fffa : 9d3b dw nmi_trap fffc : a33b dw res_trap fffe : ab3b dw irq_trap endif fffa = end start No errors in pass 2. Wrote binary from address $0000 through $ffff. Total size 65536 bytes. Program start address is at $0800 (2048).