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 000a = zero_page = $a ;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 0400 = code_segment = $400 ;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 000a = org zero_page ;break test interrupt save 000a : 00 irq_a ds 1 ;a register 000b : 00 irq_x ds 1 ;x register if I_flag = 2 ;masking for I bit in status flag_I_on ds 1 ;or mask to load flags flag_I_off ds 1 ;and mask to load flags endif 000c : zpt ;5 bytes store/modify test area ;add/subtract operand generation and result/flag prediction 000c : 00 adfc ds 1 ;carry flag before op 000d : 00 ad1 ds 1 ;operand 1 - accumulator 000e : 00 ad2 ds 1 ;operand 2 - memory / immediate 000f : 00 adrl ds 1 ;expected result bits 0-7 0010 : 00 adrh ds 1 ;expected result bit 8 (carry) 0011 : 00 adrf ds 1 ;expected flags NV0000ZC (only binary mode) 0012 : 00 sb2 ds 1 ;operand 2 complemented for subtract 0013 : zp_bss 0013 : c3824100 zp1 db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR 0017 : 7f zp7f db $7f ;test pattern for compare ;logical zeropage operands 0018 : 001f7180 zpOR db 0,$1f,$71,$80 ;test pattern for OR 001c : 0fff7f80 zpAN db $0f,$ff,$7f,$80 ;test pattern for AND 0020 : ff0f8f8f zpEO db $ff,$0f,$8f,$8f ;test pattern for EOR ;indirect addressing pointers 0024 : 1702 ind1 dw abs1 ;indirect pointer to pattern in absolute memory 0026 : 1802 dw abs1+1 0028 : 1902 dw abs1+2 002a : 1a02 dw abs1+3 002c : 1b02 dw abs7f 002e : 1f01 inw1 dw abs1-$f8 ;indirect pointer for wrap-test pattern 0030 : 0302 indt dw abst ;indirect pointer to store area in absolute memory 0032 : 0402 dw abst+1 0034 : 0502 dw abst+2 0036 : 0602 dw abst+3 0038 : 0b01 inwt dw abst-$f8 ;indirect pointer for wrap-test store 003a : 4e02 indAN dw absAN ;indirect pointer to AND pattern in absolute memory 003c : 4f02 dw absAN+1 003e : 5002 dw absAN+2 0040 : 5102 dw absAN+3 0042 : 5202 indEO dw absEO ;indirect pointer to EOR pattern in absolute memory 0044 : 5302 dw absEO+1 0046 : 5402 dw absEO+2 0048 : 5502 dw absEO+3 004a : 4a02 indOR dw absOR ;indirect pointer to OR pattern in absolute memory 004c : 4b02 dw absOR+1 004e : 4c02 dw absOR+2 0050 : 4d02 dw absOR+3 ;add/subtract indirect pointers 0052 : 0302 adi2 dw ada2 ;indirect pointer to operand 2 in absolute memory 0054 : 0402 sbi2 dw sba2 ;indirect pointer to complemented operand 2 (SBC) 0056 : 0401 adiy2 dw ada2-$ff ;with offset for indirect indexed 0058 : 0501 sbiy2 dw sba2-$ff 005a : 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 0400 = org code_segment 0400 : d8 start cld 0401 : a2ff ldx #$ff 0403 : 9a txs 0404 : a900 lda #0 ;*** test 0 = initialize 0406 : 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 0409 : a205 ldx #5 040b : 4c3304 jmp psb_test 040e : psb_bwok 040e : a005 ldy #5 0410 : d008 bne psb_forw trap ;branch should be taken 0412 : 4c1204 > jmp * ;failed anyway 0415 : 88 dey ;forward landing zone 0416 : 88 dey 0417 : 88 dey 0418 : 88 dey 0419 : 88 dey 041a : psb_forw 041a : 88 dey 041b : 88 dey 041c : 88 dey 041d : 88 dey 041e : 88 dey 041f : f017 beq psb_fwok trap ;forward offset 0421 : 4c2104 > jmp * ;failed anyway 0424 : ca dex ;backward landing zone 0425 : ca dex 0426 : ca dex 0427 : ca dex 0428 : ca dex 0429 : psb_back 0429 : ca dex 042a : ca dex 042b : ca dex 042c : ca dex 042d : ca dex 042e : f0de beq psb_bwok trap ;backward offset 0430 : 4c3004 > jmp * ;failed anyway 0433 : psb_test 0433 : d0f4 bne psb_back trap ;branch should be taken 0435 : 4c3504 > jmp * ;failed anyway 0438 : 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 0438 : ad0002 > lda test_case ;previous test 043b : c900 > cmp #test_num > trap_ne ;test is out of sequence 043d : d0fe > bne * ;failed not equal (non zero) > 0001 = >test_num = test_num + 1 043f : a901 > lda #test_num ;*** next tests' number 0441 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test if disable_selfmod = 0 ;testing relative addressing with BEQ 0444 : a0fe ldy #$fe ;testing maximum range, not -1/-2 (invalid/self adr) 0446 : range_loop 0446 : 88 dey ;next relative address 0447 : 98 tya 0448 : aa tax ;precharge count to end of loop 0449 : 1008 bpl range_fw ;calculate relative address 044b : 18 clc ;avoid branch self or to relative address of branch 044c : 6902 adc #2 044e : ea nop ;offset landing zone - tolerate +/-5 offset to branch 044f : ea nop 0450 : ea nop 0451 : ea nop 0452 : ea nop 0453 : range_fw 0453 : ea nop 0454 : ea nop 0455 : ea nop 0456 : ea nop 0457 : ea nop 0458 : 497f eor #$7f ;complement except sign 045a : 8de604 sta range_adr ;load into test target 045d : a900 lda #0 ;should set zero flag in status register 045f : 4ce504 jmp range_op 0462 : ca dex ; offset landing zone - backward branch too far 0463 : ca dex 0464 : ca dex 0465 : ca dex 0466 : ca dex ;relative address target field with branch under test in the middle 0467 : ca dex ;-128 - max backward 0468 : ca dex 0469 : ca dex 046a : ca dex 046b : ca dex 046c : ca dex 046d : ca dex 046e : ca dex 046f : ca dex ;-120 0470 : ca dex 0471 : ca dex 0472 : ca dex 0473 : ca dex 0474 : ca dex 0475 : ca dex 0476 : ca dex 0477 : ca dex 0478 : ca dex 0479 : ca dex ;-110 047a : ca dex 047b : ca dex 047c : ca dex 047d : ca dex 047e : ca dex 047f : ca dex 0480 : ca dex 0481 : ca dex 0482 : ca dex 0483 : ca dex ;-100 0484 : ca dex 0485 : ca dex 0486 : ca dex 0487 : ca dex 0488 : ca dex 0489 : ca dex 048a : ca dex 048b : ca dex 048c : ca dex 048d : ca dex ;-90 048e : ca dex 048f : ca dex 0490 : ca dex 0491 : ca dex 0492 : ca dex 0493 : ca dex 0494 : ca dex 0495 : ca dex 0496 : ca dex 0497 : ca dex ;-80 0498 : ca dex 0499 : ca dex 049a : ca dex 049b : ca dex 049c : ca dex 049d : ca dex 049e : ca dex 049f : ca dex 04a0 : ca dex 04a1 : ca dex ;-70 04a2 : ca dex 04a3 : ca dex 04a4 : ca dex 04a5 : ca dex 04a6 : ca dex 04a7 : ca dex 04a8 : ca dex 04a9 : ca dex 04aa : ca dex 04ab : ca dex ;-60 04ac : ca dex 04ad : ca dex 04ae : ca dex 04af : ca dex 04b0 : ca dex 04b1 : ca dex 04b2 : ca dex 04b3 : ca dex 04b4 : ca dex 04b5 : ca dex ;-50 04b6 : ca dex 04b7 : ca dex 04b8 : ca dex 04b9 : ca dex 04ba : ca dex 04bb : ca dex 04bc : ca dex 04bd : ca dex 04be : ca dex 04bf : ca dex ;-40 04c0 : ca dex 04c1 : ca dex 04c2 : ca dex 04c3 : ca dex 04c4 : ca dex 04c5 : ca dex 04c6 : ca dex 04c7 : ca dex 04c8 : ca dex 04c9 : ca dex ;-30 04ca : ca dex 04cb : ca dex 04cc : ca dex 04cd : ca dex 04ce : ca dex 04cf : ca dex 04d0 : ca dex 04d1 : ca dex 04d2 : ca dex 04d3 : ca dex ;-20 04d4 : ca dex 04d5 : ca dex 04d6 : ca dex 04d7 : ca dex 04d8 : ca dex 04d9 : ca dex 04da : ca dex 04db : ca dex 04dc : ca dex 04dd : ca dex ;-10 04de : ca dex 04df : ca dex 04e0 : ca dex 04e1 : ca dex 04e2 : ca dex 04e3 : ca dex 04e4 : ca dex ;-3 04e5 : range_op ;test target with zero flag=0, z=1 if previous dex 04e6 = range_adr = *+1 ;modifiable relative address 04e5 : f03e beq *+64 ;+64 if called without modification 04e7 : ca dex ;+0 04e8 : ca dex 04e9 : ca dex 04ea : ca dex 04eb : ca dex 04ec : ca dex 04ed : ca dex 04ee : ca dex 04ef : ca dex 04f0 : ca dex 04f1 : ca dex ;+10 04f2 : ca dex 04f3 : ca dex 04f4 : ca dex 04f5 : ca dex 04f6 : ca dex 04f7 : ca dex 04f8 : ca dex 04f9 : ca dex 04fa : ca dex 04fb : ca dex ;+20 04fc : ca dex 04fd : ca dex 04fe : ca dex 04ff : ca dex 0500 : ca dex 0501 : ca dex 0502 : ca dex 0503 : ca dex 0504 : ca dex 0505 : ca dex ;+30 0506 : ca dex 0507 : ca dex 0508 : ca dex 0509 : ca dex 050a : ca dex 050b : ca dex 050c : ca dex 050d : ca dex 050e : ca dex 050f : ca dex ;+40 0510 : ca dex 0511 : ca dex 0512 : ca dex 0513 : ca dex 0514 : ca dex 0515 : ca dex 0516 : ca dex 0517 : ca dex 0518 : ca dex 0519 : ca dex ;+50 051a : ca dex 051b : ca dex 051c : ca dex 051d : ca dex 051e : ca dex 051f : ca dex 0520 : ca dex 0521 : ca dex 0522 : ca dex 0523 : ca dex ;+60 0524 : ca dex 0525 : ca dex 0526 : ca dex 0527 : ca dex 0528 : ca dex 0529 : ca dex 052a : ca dex 052b : ca dex 052c : ca dex 052d : ca dex ;+70 052e : ca dex 052f : ca dex 0530 : ca dex 0531 : ca dex 0532 : ca dex 0533 : ca dex 0534 : ca dex 0535 : ca dex 0536 : ca dex 0537 : ca dex ;+80 0538 : ca dex 0539 : ca dex 053a : ca dex 053b : ca dex 053c : ca dex 053d : ca dex 053e : ca dex 053f : ca dex 0540 : ca dex 0541 : ca dex ;+90 0542 : ca dex 0543 : ca dex 0544 : ca dex 0545 : ca dex 0546 : ca dex 0547 : ca dex 0548 : ca dex 0549 : ca dex 054a : ca dex 054b : ca dex ;+100 054c : ca dex 054d : ca dex 054e : ca dex 054f : ca dex 0550 : ca dex 0551 : ca dex 0552 : ca dex 0553 : ca dex 0554 : ca dex 0555 : ca dex ;+110 0556 : ca dex 0557 : ca dex 0558 : ca dex 0559 : ca dex 055a : ca dex 055b : ca dex 055c : ca dex 055d : ca dex 055e : ca dex 055f : ca dex ;+120 0560 : ca dex 0561 : ca dex 0562 : ca dex 0563 : ca dex 0564 : ca dex 0565 : ca dex 0566 : ea nop ;offset landing zone - forward branch too far 0567 : ea nop 0568 : ea nop 0569 : ea nop 056a : ea nop 056b : f008 beq range_ok ;+127 - max forward trap ; bad range 056d : 4c6d05 > jmp * ;failed anyway 0570 : ea nop ;offset landing zone - tolerate +/-5 offset to branch 0571 : ea nop 0572 : ea nop 0573 : ea nop 0574 : ea nop 0575 : range_ok 0575 : ea nop 0576 : ea nop 0577 : ea nop 0578 : ea nop 0579 : ea nop 057a : c000 cpy #0 057c : f003 beq range_end 057e : 4c4604 jmp range_loop 0581 : range_end ;range test successful endif next_test 0581 : ad0002 > lda test_case ;previous test 0584 : c901 > cmp #test_num > trap_ne ;test is out of sequence 0586 : d0fe > bne * ;failed not equal (non zero) > 0002 = >test_num = test_num + 1 0588 : a902 > lda #test_num ;*** next tests' number 058a : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ;partial test BNE & CMP, CPX, CPY immediate 058d : c001 cpy #1 ;testing BNE true 058f : d003 bne test_bne trap 0591 : 4c9105 > jmp * ;failed anyway 0594 : test_bne 0594 : a900 lda #0 0596 : c900 cmp #0 ;test compare immediate trap_ne 0598 : d0fe > bne * ;failed not equal (non zero) trap_cc 059a : 90fe > bcc * ;failed carry clear trap_mi 059c : 30fe > bmi * ;failed minus (bit 7 set) 059e : c901 cmp #1 trap_eq 05a0 : f0fe > beq * ;failed equal (zero) trap_cs 05a2 : b0fe > bcs * ;failed carry set trap_pl 05a4 : 10fe > bpl * ;failed plus (bit 7 clear) 05a6 : aa tax 05a7 : e000 cpx #0 ;test compare x immediate trap_ne 05a9 : d0fe > bne * ;failed not equal (non zero) trap_cc 05ab : 90fe > bcc * ;failed carry clear trap_mi 05ad : 30fe > bmi * ;failed minus (bit 7 set) 05af : e001 cpx #1 trap_eq 05b1 : f0fe > beq * ;failed equal (zero) trap_cs 05b3 : b0fe > bcs * ;failed carry set trap_pl 05b5 : 10fe > bpl * ;failed plus (bit 7 clear) 05b7 : a8 tay 05b8 : c000 cpy #0 ;test compare y immediate trap_ne 05ba : d0fe > bne * ;failed not equal (non zero) trap_cc 05bc : 90fe > bcc * ;failed carry clear trap_mi 05be : 30fe > bmi * ;failed minus (bit 7 set) 05c0 : c001 cpy #1 trap_eq 05c2 : f0fe > beq * ;failed equal (zero) trap_cs 05c4 : b0fe > bcs * ;failed carry set trap_pl 05c6 : 10fe > bpl * ;failed plus (bit 7 clear) next_test 05c8 : ad0002 > lda test_case ;previous test 05cb : c902 > cmp #test_num > trap_ne ;test is out of sequence 05cd : d0fe > bne * ;failed not equal (non zero) > 0003 = >test_num = test_num + 1 05cf : a903 > lda #test_num ;*** next tests' number 05d1 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ;testing stack operations PHA PHP PLA PLP 05d4 : a2ff ldx #$ff ;initialize stack 05d6 : 9a txs 05d7 : a955 lda #$55 05d9 : 48 pha 05da : a9aa lda #$aa 05dc : 48 pha 05dd : cdfe01 cmp $1fe ;on stack ? trap_ne 05e0 : d0fe > bne * ;failed not equal (non zero) 05e2 : ba tsx 05e3 : 8a txa ;overwrite accu 05e4 : c9fd cmp #$fd ;sp decremented? trap_ne 05e6 : d0fe > bne * ;failed not equal (non zero) 05e8 : 68 pla 05e9 : c9aa cmp #$aa ;successful retreived from stack? trap_ne 05eb : d0fe > bne * ;failed not equal (non zero) 05ed : 68 pla 05ee : c955 cmp #$55 trap_ne 05f0 : d0fe > bne * ;failed not equal (non zero) 05f2 : cdff01 cmp $1ff ;remains on stack? trap_ne 05f5 : d0fe > bne * ;failed not equal (non zero) 05f7 : ba tsx 05f8 : e0ff cpx #$ff ;sp incremented? trap_ne 05fa : d0fe > bne * ;failed not equal (non zero) next_test 05fc : ad0002 > lda test_case ;previous test 05ff : c903 > cmp #test_num > trap_ne ;test is out of sequence 0601 : d0fe > bne * ;failed not equal (non zero) > 0004 = >test_num = test_num + 1 0603 : a904 > lda #test_num ;*** next tests' number 0605 : 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 0608 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 060a : 48 > pha ;use stack to load status 060b : 28 > plp 060c : 101a bpl nbr1 ;branches should not be taken 060e : 501b bvc nbr2 0610 : 901c bcc nbr3 0612 : d01d bne nbr4 0614 : 3003 bmi br1 ;branches should be taken trap 0616 : 4c1606 > jmp * ;failed anyway 0619 : 7003 br1 bvs br2 trap 061b : 4c1b06 > jmp * ;failed anyway 061e : b003 br2 bcs br3 trap 0620 : 4c2006 > jmp * ;failed anyway 0623 : f00f br3 beq br4 trap 0625 : 4c2506 > jmp * ;failed anyway 0628 : nbr1 trap ;previous bpl taken 0628 : 4c2806 > jmp * ;failed anyway 062b : nbr2 trap ;previous bvc taken 062b : 4c2b06 > jmp * ;failed anyway 062e : nbr3 trap ;previous bcc taken 062e : 4c2e06 > jmp * ;failed anyway 0631 : nbr4 trap ;previous bne taken 0631 : 4c3106 > jmp * ;failed anyway 0634 : 08 br4 php 0635 : ba tsx 0636 : e0fe cpx #$fe ;sp after php? trap_ne 0638 : d0fe > bne * ;failed not equal (non zero) 063a : 68 pla cmp_flag $ff ;returned all flags on? 063b : c9ff > cmp #($ff |fao)&m8 ;expected flags + always on bits trap_ne 063d : d0fe > bne * ;failed not equal (non zero) 063f : ba tsx 0640 : e0ff cpx #$ff ;sp after php? trap_ne 0642 : d0fe > bne * ;failed not equal (non zero) set_stat 0 ;all off > load_flag 0 0644 : a900 > lda #0 ;allow test to change I-flag (no mask) > 0646 : 48 > pha ;use stack to load status 0647 : 28 > plp 0648 : 301a bmi nbr11 ;branches should not be taken 064a : 701b bvs nbr12 064c : b01c bcs nbr13 064e : f01d beq nbr14 0650 : 1003 bpl br11 ;branches should be taken trap 0652 : 4c5206 > jmp * ;failed anyway 0655 : 5003 br11 bvc br12 trap 0657 : 4c5706 > jmp * ;failed anyway 065a : 9003 br12 bcc br13 trap 065c : 4c5c06 > jmp * ;failed anyway 065f : d00f br13 bne br14 trap 0661 : 4c6106 > jmp * ;failed anyway 0664 : nbr11 trap ;previous bmi taken 0664 : 4c6406 > jmp * ;failed anyway 0667 : nbr12 trap ;previous bvs taken 0667 : 4c6706 > jmp * ;failed anyway 066a : nbr13 trap ;previous bcs taken 066a : 4c6a06 > jmp * ;failed anyway 066d : nbr14 trap ;previous beq taken 066d : 4c6d06 > jmp * ;failed anyway 0670 : 08 br14 php 0671 : 68 pla cmp_flag 0 ;flags off except break (pushed by sw) + reserved? 0672 : c930 > cmp #(0 |fao)&m8 ;expected flags + always on bits trap_ne 0674 : d0fe > bne * ;failed not equal (non zero) ;crosscheck flags set_stat zero > load_flag zero 0676 : a902 > lda #zero ;allow test to change I-flag (no mask) > 0678 : 48 > pha ;use stack to load status 0679 : 28 > plp 067a : d002 bne brzs1 067c : f003 beq brzs2 067e : brzs1 trap ;branch zero/non zero 067e : 4c7e06 > jmp * ;failed anyway 0681 : b002 brzs2 bcs brzs3 0683 : 9003 bcc brzs4 0685 : brzs3 trap ;branch carry/no carry 0685 : 4c8506 > jmp * ;failed anyway 0688 : 3002 brzs4 bmi brzs5 068a : 1003 bpl brzs6 068c : brzs5 trap ;branch minus/plus 068c : 4c8c06 > jmp * ;failed anyway 068f : 7002 brzs6 bvs brzs7 0691 : 5003 bvc brzs8 0693 : brzs7 trap ;branch overflow/no overflow 0693 : 4c9306 > jmp * ;failed anyway 0696 : brzs8 set_stat carry > load_flag carry 0696 : a901 > lda #carry ;allow test to change I-flag (no mask) > 0698 : 48 > pha ;use stack to load status 0699 : 28 > plp 069a : f002 beq brcs1 069c : d003 bne brcs2 069e : brcs1 trap ;branch zero/non zero 069e : 4c9e06 > jmp * ;failed anyway 06a1 : 9002 brcs2 bcc brcs3 06a3 : b003 bcs brcs4 06a5 : brcs3 trap ;branch carry/no carry 06a5 : 4ca506 > jmp * ;failed anyway 06a8 : 3002 brcs4 bmi brcs5 06aa : 1003 bpl brcs6 06ac : brcs5 trap ;branch minus/plus 06ac : 4cac06 > jmp * ;failed anyway 06af : 7002 brcs6 bvs brcs7 06b1 : 5003 bvc brcs8 06b3 : brcs7 trap ;branch overflow/no overflow 06b3 : 4cb306 > jmp * ;failed anyway 06b6 : brcs8 set_stat minus > load_flag minus 06b6 : a980 > lda #minus ;allow test to change I-flag (no mask) > 06b8 : 48 > pha ;use stack to load status 06b9 : 28 > plp 06ba : f002 beq brmi1 06bc : d003 bne brmi2 06be : brmi1 trap ;branch zero/non zero 06be : 4cbe06 > jmp * ;failed anyway 06c1 : b002 brmi2 bcs brmi3 06c3 : 9003 bcc brmi4 06c5 : brmi3 trap ;branch carry/no carry 06c5 : 4cc506 > jmp * ;failed anyway 06c8 : 1002 brmi4 bpl brmi5 06ca : 3003 bmi brmi6 06cc : brmi5 trap ;branch minus/plus 06cc : 4ccc06 > jmp * ;failed anyway 06cf : 7002 brmi6 bvs brmi7 06d1 : 5003 bvc brmi8 06d3 : brmi7 trap ;branch overflow/no overflow 06d3 : 4cd306 > jmp * ;failed anyway 06d6 : brmi8 set_stat overfl > load_flag overfl 06d6 : a940 > lda #overfl ;allow test to change I-flag (no mask) > 06d8 : 48 > pha ;use stack to load status 06d9 : 28 > plp 06da : f002 beq brvs1 06dc : d003 bne brvs2 06de : brvs1 trap ;branch zero/non zero 06de : 4cde06 > jmp * ;failed anyway 06e1 : b002 brvs2 bcs brvs3 06e3 : 9003 bcc brvs4 06e5 : brvs3 trap ;branch carry/no carry 06e5 : 4ce506 > jmp * ;failed anyway 06e8 : 3002 brvs4 bmi brvs5 06ea : 1003 bpl brvs6 06ec : brvs5 trap ;branch minus/plus 06ec : 4cec06 > jmp * ;failed anyway 06ef : 5002 brvs6 bvc brvs7 06f1 : 7003 bvs brvs8 06f3 : brvs7 trap ;branch overflow/no overflow 06f3 : 4cf306 > jmp * ;failed anyway 06f6 : brvs8 set_stat $ff-zero > load_flag $ff-zero 06f6 : a9fd > lda #$ff-zero ;allow test to change I-flag (no mask) > 06f8 : 48 > pha ;use stack to load status 06f9 : 28 > plp 06fa : f002 beq brzc1 06fc : d003 bne brzc2 06fe : brzc1 trap ;branch zero/non zero 06fe : 4cfe06 > jmp * ;failed anyway 0701 : 9002 brzc2 bcc brzc3 0703 : b003 bcs brzc4 0705 : brzc3 trap ;branch carry/no carry 0705 : 4c0507 > jmp * ;failed anyway 0708 : 1002 brzc4 bpl brzc5 070a : 3003 bmi brzc6 070c : brzc5 trap ;branch minus/plus 070c : 4c0c07 > jmp * ;failed anyway 070f : 5002 brzc6 bvc brzc7 0711 : 7003 bvs brzc8 0713 : brzc7 trap ;branch overflow/no overflow 0713 : 4c1307 > jmp * ;failed anyway 0716 : brzc8 set_stat $ff-carry > load_flag $ff-carry 0716 : a9fe > lda #$ff-carry ;allow test to change I-flag (no mask) > 0718 : 48 > pha ;use stack to load status 0719 : 28 > plp 071a : d002 bne brcc1 071c : f003 beq brcc2 071e : brcc1 trap ;branch zero/non zero 071e : 4c1e07 > jmp * ;failed anyway 0721 : b002 brcc2 bcs brcc3 0723 : 9003 bcc brcc4 0725 : brcc3 trap ;branch carry/no carry 0725 : 4c2507 > jmp * ;failed anyway 0728 : 1002 brcc4 bpl brcc5 072a : 3003 bmi brcc6 072c : brcc5 trap ;branch minus/plus 072c : 4c2c07 > jmp * ;failed anyway 072f : 5002 brcc6 bvc brcc7 0731 : 7003 bvs brcc8 0733 : brcc7 trap ;branch overflow/no overflow 0733 : 4c3307 > jmp * ;failed anyway 0736 : brcc8 set_stat $ff-minus > load_flag $ff-minus 0736 : a97f > lda #$ff-minus ;allow test to change I-flag (no mask) > 0738 : 48 > pha ;use stack to load status 0739 : 28 > plp 073a : d002 bne brpl1 073c : f003 beq brpl2 073e : brpl1 trap ;branch zero/non zero 073e : 4c3e07 > jmp * ;failed anyway 0741 : 9002 brpl2 bcc brpl3 0743 : b003 bcs brpl4 0745 : brpl3 trap ;branch carry/no carry 0745 : 4c4507 > jmp * ;failed anyway 0748 : 3002 brpl4 bmi brpl5 074a : 1003 bpl brpl6 074c : brpl5 trap ;branch minus/plus 074c : 4c4c07 > jmp * ;failed anyway 074f : 5002 brpl6 bvc brpl7 0751 : 7003 bvs brpl8 0753 : brpl7 trap ;branch overflow/no overflow 0753 : 4c5307 > jmp * ;failed anyway 0756 : brpl8 set_stat $ff-overfl > load_flag $ff-overfl 0756 : a9bf > lda #$ff-overfl ;allow test to change I-flag (no mask) > 0758 : 48 > pha ;use stack to load status 0759 : 28 > plp 075a : d002 bne brvc1 075c : f003 beq brvc2 075e : brvc1 trap ;branch zero/non zero 075e : 4c5e07 > jmp * ;failed anyway 0761 : 9002 brvc2 bcc brvc3 0763 : b003 bcs brvc4 0765 : brvc3 trap ;branch carry/no carry 0765 : 4c6507 > jmp * ;failed anyway 0768 : 1002 brvc4 bpl brvc5 076a : 3003 bmi brvc6 076c : brvc5 trap ;branch minus/plus 076c : 4c6c07 > jmp * ;failed anyway 076f : 7002 brvc6 bvs brvc7 0771 : 5003 bvc brvc8 0773 : brvc7 trap ;branch overflow/no overflow 0773 : 4c7307 > jmp * ;failed anyway 0776 : brvc8 next_test 0776 : ad0002 > lda test_case ;previous test 0779 : c904 > cmp #test_num > trap_ne ;test is out of sequence 077b : d0fe > bne * ;failed not equal (non zero) > 0005 = >test_num = test_num + 1 077d : a905 > lda #test_num ;*** next tests' number 077f : 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 0782 : a255 ldx #$55 ;x & y protected 0784 : a0aa ldy #$aa set_a 1,$ff ;push > load_flag $ff 0786 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0788 : 48 > pha ;use stack to load status 0789 : a901 > lda #1 ;precharge accu 078b : 28 > plp 078c : 48 pha tst_a 1,$ff 078d : 08 > php ;save flags 078e : c901 > cmp #1 ;test result > trap_ne 0790 : d0fe > bne * ;failed not equal (non zero) > 0792 : 68 > pla ;load status 0793 : 48 > pha > cmp_flag $ff 0794 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits > > trap_ne 0796 : d0fe > bne * ;failed not equal (non zero) > 0798 : 28 > plp ;restore status set_a 0,0 > load_flag 0 0799 : a900 > lda #0 ;allow test to change I-flag (no mask) > 079b : 48 > pha ;use stack to load status 079c : a900 > lda #0 ;precharge accu 079e : 28 > plp 079f : 48 pha tst_a 0,0 07a0 : 08 > php ;save flags 07a1 : c900 > cmp #0 ;test result > trap_ne 07a3 : d0fe > bne * ;failed not equal (non zero) > 07a5 : 68 > pla ;load status 07a6 : 48 > pha > cmp_flag 0 07a7 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 07a9 : d0fe > bne * ;failed not equal (non zero) > 07ab : 28 > plp ;restore status set_a $ff,$ff > load_flag $ff 07ac : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 07ae : 48 > pha ;use stack to load status 07af : a9ff > lda #$ff ;precharge accu 07b1 : 28 > plp 07b2 : 48 pha tst_a $ff,$ff 07b3 : 08 > php ;save flags 07b4 : c9ff > cmp #$ff ;test result > trap_ne 07b6 : d0fe > bne * ;failed not equal (non zero) > 07b8 : 68 > pla ;load status 07b9 : 48 > pha > cmp_flag $ff 07ba : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits > > trap_ne 07bc : d0fe > bne * ;failed not equal (non zero) > 07be : 28 > plp ;restore status set_a 1,0 > load_flag 0 07bf : a900 > lda #0 ;allow test to change I-flag (no mask) > 07c1 : 48 > pha ;use stack to load status 07c2 : a901 > lda #1 ;precharge accu 07c4 : 28 > plp 07c5 : 48 pha tst_a 1,0 07c6 : 08 > php ;save flags 07c7 : c901 > cmp #1 ;test result > trap_ne 07c9 : d0fe > bne * ;failed not equal (non zero) > 07cb : 68 > pla ;load status 07cc : 48 > pha > cmp_flag 0 07cd : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 07cf : d0fe > bne * ;failed not equal (non zero) > 07d1 : 28 > plp ;restore status set_a 0,$ff > load_flag $ff 07d2 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 07d4 : 48 > pha ;use stack to load status 07d5 : a900 > lda #0 ;precharge accu 07d7 : 28 > plp 07d8 : 48 pha tst_a 0,$ff 07d9 : 08 > php ;save flags 07da : c900 > cmp #0 ;test result > trap_ne 07dc : d0fe > bne * ;failed not equal (non zero) > 07de : 68 > pla ;load status 07df : 48 > pha > cmp_flag $ff 07e0 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits > > trap_ne 07e2 : d0fe > bne * ;failed not equal (non zero) > 07e4 : 28 > plp ;restore status set_a $ff,0 > load_flag 0 07e5 : a900 > lda #0 ;allow test to change I-flag (no mask) > 07e7 : 48 > pha ;use stack to load status 07e8 : a9ff > lda #$ff ;precharge accu 07ea : 28 > plp 07eb : 48 pha tst_a $ff,0 07ec : 08 > php ;save flags 07ed : c9ff > cmp #$ff ;test result > trap_ne 07ef : d0fe > bne * ;failed not equal (non zero) > 07f1 : 68 > pla ;load status 07f2 : 48 > pha > cmp_flag 0 07f3 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 07f5 : d0fe > bne * ;failed not equal (non zero) > 07f7 : 28 > plp ;restore status set_a 0,$ff ;pull > load_flag $ff 07f8 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 07fa : 48 > pha ;use stack to load status 07fb : a900 > lda #0 ;precharge accu 07fd : 28 > plp 07fe : 68 pla tst_a $ff,$ff-zero 07ff : 08 > php ;save flags 0800 : c9ff > cmp #$ff ;test result > trap_ne 0802 : d0fe > bne * ;failed not equal (non zero) > 0804 : 68 > pla ;load status 0805 : 48 > pha > cmp_flag $ff-zero 0806 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0808 : d0fe > bne * ;failed not equal (non zero) > 080a : 28 > plp ;restore status set_a $ff,0 > load_flag 0 080b : a900 > lda #0 ;allow test to change I-flag (no mask) > 080d : 48 > pha ;use stack to load status 080e : a9ff > lda #$ff ;precharge accu 0810 : 28 > plp 0811 : 68 pla tst_a 0,zero 0812 : 08 > php ;save flags 0813 : c900 > cmp #0 ;test result > trap_ne 0815 : d0fe > bne * ;failed not equal (non zero) > 0817 : 68 > pla ;load status 0818 : 48 > pha > cmp_flag zero 0819 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits > > trap_ne 081b : d0fe > bne * ;failed not equal (non zero) > 081d : 28 > plp ;restore status set_a $fe,$ff > load_flag $ff 081e : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0820 : 48 > pha ;use stack to load status 0821 : a9fe > lda #$fe ;precharge accu 0823 : 28 > plp 0824 : 68 pla tst_a 1,$ff-zero-minus 0825 : 08 > php ;save flags 0826 : c901 > cmp #1 ;test result > trap_ne 0828 : d0fe > bne * ;failed not equal (non zero) > 082a : 68 > pla ;load status 082b : 48 > pha > cmp_flag $ff-zero-minus 082c : c97d > cmp #($ff-zero-minus|fao)&m8 ;expected flags + always on bits > > trap_ne 082e : d0fe > bne * ;failed not equal (non zero) > 0830 : 28 > plp ;restore status set_a 0,0 > load_flag 0 0831 : a900 > lda #0 ;allow test to change I-flag (no mask) > 0833 : 48 > pha ;use stack to load status 0834 : a900 > lda #0 ;precharge accu 0836 : 28 > plp 0837 : 68 pla tst_a $ff,minus 0838 : 08 > php ;save flags 0839 : c9ff > cmp #$ff ;test result > trap_ne 083b : d0fe > bne * ;failed not equal (non zero) > 083d : 68 > pla ;load status 083e : 48 > pha > cmp_flag minus 083f : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0841 : d0fe > bne * ;failed not equal (non zero) > 0843 : 28 > plp ;restore status set_a $ff,$ff > load_flag $ff 0844 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0846 : 48 > pha ;use stack to load status 0847 : a9ff > lda #$ff ;precharge accu 0849 : 28 > plp 084a : 68 pla tst_a 0,$ff-minus 084b : 08 > php ;save flags 084c : c900 > cmp #0 ;test result > trap_ne 084e : d0fe > bne * ;failed not equal (non zero) > 0850 : 68 > pla ;load status 0851 : 48 > pha > cmp_flag $ff-minus 0852 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0854 : d0fe > bne * ;failed not equal (non zero) > 0856 : 28 > plp ;restore status set_a $fe,0 > load_flag 0 0857 : a900 > lda #0 ;allow test to change I-flag (no mask) > 0859 : 48 > pha ;use stack to load status 085a : a9fe > lda #$fe ;precharge accu 085c : 28 > plp 085d : 68 pla tst_a 1,0 085e : 08 > php ;save flags 085f : c901 > cmp #1 ;test result > trap_ne 0861 : d0fe > bne * ;failed not equal (non zero) > 0863 : 68 > pla ;load status 0864 : 48 > pha > cmp_flag 0 0865 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 0867 : d0fe > bne * ;failed not equal (non zero) > 0869 : 28 > plp ;restore status 086a : e055 cpx #$55 ;x & y unchanged? trap_ne 086c : d0fe > bne * ;failed not equal (non zero) 086e : c0aa cpy #$aa trap_ne 0870 : d0fe > bne * ;failed not equal (non zero) next_test 0872 : ad0002 > lda test_case ;previous test 0875 : c905 > cmp #test_num > trap_ne ;test is out of sequence 0877 : d0fe > bne * ;failed not equal (non zero) > 0006 = >test_num = test_num + 1 0879 : a906 > lda #test_num ;*** next tests' number 087b : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; partial pretest EOR # set_a $3c,0 > load_flag 0 087e : a900 > lda #0 ;allow test to change I-flag (no mask) > 0880 : 48 > pha ;use stack to load status 0881 : a93c > lda #$3c ;precharge accu 0883 : 28 > plp 0884 : 49c3 eor #$c3 tst_a $ff,fn 0886 : 08 > php ;save flags 0887 : c9ff > cmp #$ff ;test result > trap_ne 0889 : d0fe > bne * ;failed not equal (non zero) > 088b : 68 > pla ;load status 088c : 48 > pha > cmp_flag fn 088d : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 088f : d0fe > bne * ;failed not equal (non zero) > 0891 : 28 > plp ;restore status set_a $c3,0 > load_flag 0 0892 : a900 > lda #0 ;allow test to change I-flag (no mask) > 0894 : 48 > pha ;use stack to load status 0895 : a9c3 > lda #$c3 ;precharge accu 0897 : 28 > plp 0898 : 49c3 eor #$c3 tst_a 0,fz 089a : 08 > php ;save flags 089b : c900 > cmp #0 ;test result > trap_ne 089d : d0fe > bne * ;failed not equal (non zero) > 089f : 68 > pla ;load status 08a0 : 48 > pha > cmp_flag fz 08a1 : c932 > cmp #(fz|fao)&m8 ;expected flags + always on bits > > trap_ne 08a3 : d0fe > bne * ;failed not equal (non zero) > 08a5 : 28 > plp ;restore status next_test 08a6 : ad0002 > lda test_case ;previous test 08a9 : c906 > cmp #test_num > trap_ne ;test is out of sequence 08ab : d0fe > bne * ;failed not equal (non zero) > 0007 = >test_num = test_num + 1 08ad : a907 > lda #test_num ;*** next tests' number 08af : 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 08b2 : a224 ldx #$24 08b4 : a042 ldy #$42 set_a $18,0 > load_flag 0 08b6 : a900 > lda #0 ;allow test to change I-flag (no mask) > 08b8 : 48 > pha ;use stack to load status 08b9 : a918 > lda #$18 ;precharge accu 08bb : 28 > plp 08bc : ea nop tst_a $18,0 08bd : 08 > php ;save flags 08be : c918 > cmp #$18 ;test result > trap_ne 08c0 : d0fe > bne * ;failed not equal (non zero) > 08c2 : 68 > pla ;load status 08c3 : 48 > pha > cmp_flag 0 08c4 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 08c6 : d0fe > bne * ;failed not equal (non zero) > 08c8 : 28 > plp ;restore status 08c9 : e024 cpx #$24 trap_ne 08cb : d0fe > bne * ;failed not equal (non zero) 08cd : c042 cpy #$42 trap_ne 08cf : d0fe > bne * ;failed not equal (non zero) 08d1 : a2db ldx #$db 08d3 : a0bd ldy #$bd set_a $e7,$ff > load_flag $ff 08d5 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 08d7 : 48 > pha ;use stack to load status 08d8 : a9e7 > lda #$e7 ;precharge accu 08da : 28 > plp 08db : ea nop tst_a $e7,$ff 08dc : 08 > php ;save flags 08dd : c9e7 > cmp #$e7 ;test result > trap_ne 08df : d0fe > bne * ;failed not equal (non zero) > 08e1 : 68 > pla ;load status 08e2 : 48 > pha > cmp_flag $ff 08e3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits > > trap_ne 08e5 : d0fe > bne * ;failed not equal (non zero) > 08e7 : 28 > plp ;restore status 08e8 : e0db cpx #$db trap_ne 08ea : d0fe > bne * ;failed not equal (non zero) 08ec : c0bd cpy #$bd trap_ne 08ee : d0fe > bne * ;failed not equal (non zero) next_test 08f0 : ad0002 > lda test_case ;previous test 08f3 : c907 > cmp #test_num > trap_ne ;test is out of sequence 08f5 : d0fe > bne * ;failed not equal (non zero) > 0008 = >test_num = test_num + 1 08f7 : a908 > lda #test_num ;*** next tests' number 08f9 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; jump absolute set_stat $0 > load_flag $0 08fc : a900 > lda #$0 ;allow test to change I-flag (no mask) > 08fe : 48 > pha ;use stack to load status 08ff : 28 > plp 0900 : a946 lda #'F' 0902 : a241 ldx #'A' 0904 : a052 ldy #'R' ;N=0, V=0, Z=0, C=0 0906 : 4cef36 jmp test_far 0909 : ea nop 090a : ea nop trap_ne ;runover protection 090b : d0fe > bne * ;failed not equal (non zero) 090d : e8 inx 090e : e8 inx 090f : far_ret trap_eq ;returned flags OK? 090f : f0fe > beq * ;failed equal (zero) trap_pl 0911 : 10fe > bpl * ;failed plus (bit 7 clear) trap_cc 0913 : 90fe > bcc * ;failed carry clear trap_vc 0915 : 50fe > bvc * ;failed overflow clear 0917 : c9ec cmp #('F'^$aa) ;returned registers OK? trap_ne 0919 : d0fe > bne * ;failed not equal (non zero) 091b : e042 cpx #('A'+1) trap_ne 091d : d0fe > bne * ;failed not equal (non zero) 091f : c04f cpy #('R'-3) trap_ne 0921 : d0fe > bne * ;failed not equal (non zero) 0923 : ca dex 0924 : c8 iny 0925 : c8 iny 0926 : c8 iny 0927 : 49aa eor #$aa ;N=0, V=1, Z=0, C=1 0929 : 4c3209 jmp test_near 092c : ea nop 092d : ea nop trap_ne ;runover protection 092e : d0fe > bne * ;failed not equal (non zero) 0930 : e8 inx 0931 : e8 inx 0932 : test_near trap_eq ;passed flags OK? 0932 : f0fe > beq * ;failed equal (zero) trap_mi 0934 : 30fe > bmi * ;failed minus (bit 7 set) trap_cc 0936 : 90fe > bcc * ;failed carry clear trap_vc 0938 : 50fe > bvc * ;failed overflow clear 093a : c946 cmp #'F' ;passed registers OK? trap_ne 093c : d0fe > bne * ;failed not equal (non zero) 093e : e041 cpx #'A' trap_ne 0940 : d0fe > bne * ;failed not equal (non zero) 0942 : c052 cpy #'R' trap_ne 0944 : d0fe > bne * ;failed not equal (non zero) next_test 0946 : ad0002 > lda test_case ;previous test 0949 : c908 > cmp #test_num > trap_ne ;test is out of sequence 094b : d0fe > bne * ;failed not equal (non zero) > 0009 = >test_num = test_num + 1 094d : a909 > lda #test_num ;*** next tests' number 094f : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; jump indirect set_stat 0 > load_flag 0 0952 : a900 > lda #0 ;allow test to change I-flag (no mask) > 0954 : 48 > pha ;use stack to load status 0955 : 28 > plp 0956 : a949 lda #'I' 0958 : a24e ldx #'N' 095a : a044 ldy #'D' ;N=0, V=0, Z=0, C=0 095c : 6c1e37 jmp (ptr_tst_ind) 095f : ea nop trap_ne ;runover protection 0960 : d0fe > bne * ;failed not equal (non zero) 0962 : 88 dey 0963 : 88 dey 0964 : ind_ret 0964 : 08 php ;either SP or Y count will fail, if we do not hit 0965 : 88 dey 0966 : 88 dey 0967 : 88 dey 0968 : 28 plp trap_eq ;returned flags OK? 0969 : f0fe > beq * ;failed equal (zero) trap_pl 096b : 10fe > bpl * ;failed plus (bit 7 clear) trap_cc 096d : 90fe > bcc * ;failed carry clear trap_vc 096f : 50fe > bvc * ;failed overflow clear 0971 : c9e3 cmp #('I'^$aa) ;returned registers OK? trap_ne 0973 : d0fe > bne * ;failed not equal (non zero) 0975 : e04f cpx #('N'+1) trap_ne 0977 : d0fe > bne * ;failed not equal (non zero) 0979 : c03e cpy #('D'-6) trap_ne 097b : d0fe > bne * ;failed not equal (non zero) 097d : ba tsx ;SP check 097e : e0ff cpx #$ff trap_ne 0980 : d0fe > bne * ;failed not equal (non zero) next_test 0982 : ad0002 > lda test_case ;previous test 0985 : c909 > cmp #test_num > trap_ne ;test is out of sequence 0987 : d0fe > bne * ;failed not equal (non zero) > 000a = >test_num = test_num + 1 0989 : a90a > lda #test_num ;*** next tests' number 098b : 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 098e : a900 > lda #0 ;allow test to change I-flag (no mask) > 0990 : 48 > pha ;use stack to load status 0991 : 28 > plp 0992 : a94a lda #'J' 0994 : a253 ldx #'S' 0996 : a052 ldy #'R' ;N=0, V=0, Z=0, C=0 0998 : 205d37 jsr test_jsr 099a = jsr_ret = *-1 ;last address of jsr = return address 099b : 08 php ;either SP or Y count will fail, if we do not hit 099c : 88 dey 099d : 88 dey 099e : 88 dey 099f : 28 plp trap_eq ;returned flags OK? 09a0 : f0fe > beq * ;failed equal (zero) trap_pl 09a2 : 10fe > bpl * ;failed plus (bit 7 clear) trap_cc 09a4 : 90fe > bcc * ;failed carry clear trap_vc 09a6 : 50fe > bvc * ;failed overflow clear 09a8 : c9e0 cmp #('J'^$aa) ;returned registers OK? trap_ne 09aa : d0fe > bne * ;failed not equal (non zero) 09ac : e054 cpx #('S'+1) trap_ne 09ae : d0fe > bne * ;failed not equal (non zero) 09b0 : c04c cpy #('R'-6) trap_ne 09b2 : d0fe > bne * ;failed not equal (non zero) 09b4 : ba tsx ;sp? 09b5 : e0ff cpx #$ff trap_ne 09b7 : d0fe > bne * ;failed not equal (non zero) next_test 09b9 : ad0002 > lda test_case ;previous test 09bc : c90a > cmp #test_num > trap_ne ;test is out of sequence 09be : d0fe > bne * ;failed not equal (non zero) > 000b = >test_num = test_num + 1 09c0 : a90b > lda #test_num ;*** next tests' number 09c2 : 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! 09c5 : a900 > lda #0 ;allow test to change I-flag (no mask) 09c7 : 48 pha 09c8 : a942 lda #'B' 09ca : a252 ldx #'R' 09cc : a04b ldy #'K' 09ce : 28 plp ;N=0, V=0, Z=0, C=0 09cf : 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 09d0 : 88 dey ;should not be executed 09d1 : brk_ret0 ;address of break return 09d1 : 08 php ;either SP or Y count will fail, if we do not hit 09d2 : 88 dey 09d3 : 88 dey 09d4 : 88 dey 09d5 : c9e8 cmp #'B'^$aa ;returned registers OK? ;the IRQ vector was never executed if A & X stay unmodified trap_ne 09d7 : d0fe > bne * ;failed not equal (non zero) 09d9 : e053 cpx #'R'+1 trap_ne 09db : d0fe > bne * ;failed not equal (non zero) 09dd : c045 cpy #'K'-6 trap_ne 09df : d0fe > bne * ;failed not equal (non zero) 09e1 : 68 pla ;returned flags OK (unchanged)? cmp_flag 0 09e2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits trap_ne 09e4 : d0fe > bne * ;failed not equal (non zero) 09e6 : ba tsx ;sp? 09e7 : e0ff cpx #$ff trap_ne 09e9 : d0fe > bne * ;failed not equal (non zero) if ROM_vectors = 1 load_flag $ff ;with interrupts disabled if allowed! 09eb : a9ff > lda #$ff ;allow test to change I-flag (no mask) 09ed : 48 pha 09ee : a9bd lda #$ff-'B' 09f0 : a2ad ldx #$ff-'R' 09f2 : a0b4 ldy #$ff-'K' 09f4 : 28 plp ;N=1, V=1, Z=1, C=1 09f5 : 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 09f6 : 88 dey ;should not be executed 09f7 : brk_ret1 ;address of break return 09f7 : 08 php ;either SP or Y count will fail, if we do not hit 09f8 : 88 dey 09f9 : 88 dey 09fa : 88 dey 09fb : c917 cmp #($ff-'B')^$aa ;returned registers OK? ;the IRQ vector was never executed if A & X stay unmodified trap_ne 09fd : d0fe > bne * ;failed not equal (non zero) 09ff : e0ae cpx #$ff-'R'+1 trap_ne 0a01 : d0fe > bne * ;failed not equal (non zero) 0a03 : c0ae cpy #$ff-'K'-6 trap_ne 0a05 : d0fe > bne * ;failed not equal (non zero) 0a07 : 68 pla ;returned flags OK (unchanged)? cmp_flag $ff 0a08 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits trap_ne 0a0a : d0fe > bne * ;failed not equal (non zero) 0a0c : ba tsx ;sp? 0a0d : e0ff cpx #$ff trap_ne 0a0f : d0fe > bne * ;failed not equal (non zero) next_test 0a11 : ad0002 > lda test_case ;previous test 0a14 : c90b > cmp #test_num > trap_ne ;test is out of sequence 0a16 : d0fe > bne * ;failed not equal (non zero) > 000c = >test_num = test_num + 1 0a18 : a90c > lda #test_num ;*** next tests' number 0a1a : 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 0a1d : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0a1f : 48 > pha ;use stack to load status 0a20 : 28 > plp 0a21 : 18 clc tst_stat $ff-carry 0a22 : 08 > php ;save status 0a23 : 68 > pla ;use stack to retrieve status 0a24 : 48 > pha > cmp_flag $ff-carry 0a25 : c9fe > cmp #($ff-carry|fao)&m8 ;expected flags + always on bits > > trap_ne 0a27 : d0fe > bne * ;failed not equal (non zero) > 0a29 : 28 > plp ;restore status 0a2a : 38 sec tst_stat $ff 0a2b : 08 > php ;save status 0a2c : 68 > pla ;use stack to retrieve status 0a2d : 48 > pha > cmp_flag $ff 0a2e : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits > > trap_ne 0a30 : d0fe > bne * ;failed not equal (non zero) > 0a32 : 28 > plp ;restore status if I_flag = 3 0a33 : 58 cli tst_stat $ff-intdis 0a34 : 08 > php ;save status 0a35 : 68 > pla ;use stack to retrieve status 0a36 : 48 > pha > cmp_flag $ff-intdis 0a37 : c9fb > cmp #($ff-intdis|fao)&m8 ;expected flags + always on bits > > trap_ne 0a39 : d0fe > bne * ;failed not equal (non zero) > 0a3b : 28 > plp ;restore status 0a3c : 78 sei tst_stat $ff 0a3d : 08 > php ;save status 0a3e : 68 > pla ;use stack to retrieve status 0a3f : 48 > pha > cmp_flag $ff 0a40 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits > > trap_ne 0a42 : d0fe > bne * ;failed not equal (non zero) > 0a44 : 28 > plp ;restore status endif 0a45 : d8 cld tst_stat $ff-decmode 0a46 : 08 > php ;save status 0a47 : 68 > pla ;use stack to retrieve status 0a48 : 48 > pha > cmp_flag $ff-decmode 0a49 : c9f7 > cmp #($ff-decmode|fao)&m8 ;expected flags + always on bits > > trap_ne 0a4b : d0fe > bne * ;failed not equal (non zero) > 0a4d : 28 > plp ;restore status 0a4e : f8 sed tst_stat $ff 0a4f : 08 > php ;save status 0a50 : 68 > pla ;use stack to retrieve status 0a51 : 48 > pha > cmp_flag $ff 0a52 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits > > trap_ne 0a54 : d0fe > bne * ;failed not equal (non zero) > 0a56 : 28 > plp ;restore status 0a57 : b8 clv tst_stat $ff-overfl 0a58 : 08 > php ;save status 0a59 : 68 > pla ;use stack to retrieve status 0a5a : 48 > pha > cmp_flag $ff-overfl 0a5b : c9bf > cmp #($ff-overfl|fao)&m8 ;expected flags + always on bits > > trap_ne 0a5d : d0fe > bne * ;failed not equal (non zero) > 0a5f : 28 > plp ;restore status set_stat 0 > load_flag 0 0a60 : a900 > lda #0 ;allow test to change I-flag (no mask) > 0a62 : 48 > pha ;use stack to load status 0a63 : 28 > plp tst_stat 0 0a64 : 08 > php ;save status 0a65 : 68 > pla ;use stack to retrieve status 0a66 : 48 > pha > cmp_flag 0 0a67 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 0a69 : d0fe > bne * ;failed not equal (non zero) > 0a6b : 28 > plp ;restore status 0a6c : 38 sec tst_stat carry 0a6d : 08 > php ;save status 0a6e : 68 > pla ;use stack to retrieve status 0a6f : 48 > pha > cmp_flag carry 0a70 : c931 > cmp #(carry|fao)&m8 ;expected flags + always on bits > > trap_ne 0a72 : d0fe > bne * ;failed not equal (non zero) > 0a74 : 28 > plp ;restore status 0a75 : 18 clc tst_stat 0 0a76 : 08 > php ;save status 0a77 : 68 > pla ;use stack to retrieve status 0a78 : 48 > pha > cmp_flag 0 0a79 : c930 > cmp #(0 |fao)&m8 ;expected flags + always on bits > > trap_ne 0a7b : d0fe > bne * ;failed not equal (non zero) > 0a7d : 28 > plp ;restore status if I_flag = 3 0a7e : 78 sei tst_stat intdis 0a7f : 08 > php ;save status 0a80 : 68 > pla ;use stack to retrieve status 0a81 : 48 > pha > cmp_flag intdis 0a82 : c934 > cmp #(intdis|fao)&m8 ;expected flags + always on bits > > trap_ne 0a84 : d0fe > bne * ;failed not equal (non zero) > 0a86 : 28 > plp ;restore status 0a87 : 58 cli tst_stat 0 0a88 : 08 > php ;save status 0a89 : 68 > pla ;use stack to retrieve status 0a8a : 48 > pha > cmp_flag 0 0a8b : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 0a8d : d0fe > bne * ;failed not equal (non zero) > 0a8f : 28 > plp ;restore status endif 0a90 : f8 sed tst_stat decmode 0a91 : 08 > php ;save status 0a92 : 68 > pla ;use stack to retrieve status 0a93 : 48 > pha > cmp_flag decmode 0a94 : c938 > cmp #(decmode|fao)&m8 ;expected flags + always on bits > > trap_ne 0a96 : d0fe > bne * ;failed not equal (non zero) > 0a98 : 28 > plp ;restore status 0a99 : d8 cld tst_stat 0 0a9a : 08 > php ;save status 0a9b : 68 > pla ;use stack to retrieve status 0a9c : 48 > pha > cmp_flag 0 0a9d : c930 > cmp #(0 |fao)&m8 ;expected flags + always on bits > > trap_ne 0a9f : d0fe > bne * ;failed not equal (non zero) > 0aa1 : 28 > plp ;restore status set_stat overfl > load_flag overfl 0aa2 : a940 > lda #overfl ;allow test to change I-flag (no mask) > 0aa4 : 48 > pha ;use stack to load status 0aa5 : 28 > plp tst_stat overfl 0aa6 : 08 > php ;save status 0aa7 : 68 > pla ;use stack to retrieve status 0aa8 : 48 > pha > cmp_flag overfl 0aa9 : c970 > cmp #(overfl|fao)&m8 ;expected flags + always on bits > > trap_ne 0aab : d0fe > bne * ;failed not equal (non zero) > 0aad : 28 > plp ;restore status 0aae : b8 clv tst_stat 0 0aaf : 08 > php ;save status 0ab0 : 68 > pla ;use stack to retrieve status 0ab1 : 48 > pha > cmp_flag 0 0ab2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 0ab4 : d0fe > bne * ;failed not equal (non zero) > 0ab6 : 28 > plp ;restore status next_test 0ab7 : ad0002 > lda test_case ;previous test 0aba : c90c > cmp #test_num > trap_ne ;test is out of sequence 0abc : d0fe > bne * ;failed not equal (non zero) > 000d = >test_num = test_num + 1 0abe : a90d > lda #test_num ;*** next tests' number 0ac0 : 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 0ac3 : a2fe ldx #$fe set_stat $ff > load_flag $ff 0ac5 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0ac7 : 48 > pha ;use stack to load status 0ac8 : 28 > plp 0ac9 : e8 inx ;ff tst_x $ff,$ff-zero 0aca : 08 > php ;save flags 0acb : e0ff > cpx #$ff ;test result > trap_ne 0acd : d0fe > bne * ;failed not equal (non zero) > 0acf : 68 > pla ;load status 0ad0 : 48 > pha > cmp_flag $ff-zero 0ad1 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0ad3 : d0fe > bne * ;failed not equal (non zero) > 0ad5 : 28 > plp ;restore status 0ad6 : e8 inx ;00 tst_x 0,$ff-minus 0ad7 : 08 > php ;save flags 0ad8 : e000 > cpx #0 ;test result > trap_ne 0ada : d0fe > bne * ;failed not equal (non zero) > 0adc : 68 > pla ;load status 0add : 48 > pha > cmp_flag $ff-minus 0ade : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0ae0 : d0fe > bne * ;failed not equal (non zero) > 0ae2 : 28 > plp ;restore status 0ae3 : e8 inx ;01 tst_x 1,$ff-minus-zero 0ae4 : 08 > php ;save flags 0ae5 : e001 > cpx #1 ;test result > trap_ne 0ae7 : d0fe > bne * ;failed not equal (non zero) > 0ae9 : 68 > pla ;load status 0aea : 48 > pha > cmp_flag $ff-minus-zero 0aeb : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0aed : d0fe > bne * ;failed not equal (non zero) > 0aef : 28 > plp ;restore status 0af0 : ca dex ;00 tst_x 0,$ff-minus 0af1 : 08 > php ;save flags 0af2 : e000 > cpx #0 ;test result > trap_ne 0af4 : d0fe > bne * ;failed not equal (non zero) > 0af6 : 68 > pla ;load status 0af7 : 48 > pha > cmp_flag $ff-minus 0af8 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0afa : d0fe > bne * ;failed not equal (non zero) > 0afc : 28 > plp ;restore status 0afd : ca dex ;ff tst_x $ff,$ff-zero 0afe : 08 > php ;save flags 0aff : e0ff > cpx #$ff ;test result > trap_ne 0b01 : d0fe > bne * ;failed not equal (non zero) > 0b03 : 68 > pla ;load status 0b04 : 48 > pha > cmp_flag $ff-zero 0b05 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0b07 : d0fe > bne * ;failed not equal (non zero) > 0b09 : 28 > plp ;restore status 0b0a : ca dex ;fe set_stat 0 > load_flag 0 0b0b : a900 > lda #0 ;allow test to change I-flag (no mask) > 0b0d : 48 > pha ;use stack to load status 0b0e : 28 > plp 0b0f : e8 inx ;ff tst_x $ff,minus 0b10 : 08 > php ;save flags 0b11 : e0ff > cpx #$ff ;test result > trap_ne 0b13 : d0fe > bne * ;failed not equal (non zero) > 0b15 : 68 > pla ;load status 0b16 : 48 > pha > cmp_flag minus 0b17 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0b19 : d0fe > bne * ;failed not equal (non zero) > 0b1b : 28 > plp ;restore status 0b1c : e8 inx ;00 tst_x 0,zero 0b1d : 08 > php ;save flags 0b1e : e000 > cpx #0 ;test result > trap_ne 0b20 : d0fe > bne * ;failed not equal (non zero) > 0b22 : 68 > pla ;load status 0b23 : 48 > pha > cmp_flag zero 0b24 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0b26 : d0fe > bne * ;failed not equal (non zero) > 0b28 : 28 > plp ;restore status 0b29 : e8 inx ;01 tst_x 1,0 0b2a : 08 > php ;save flags 0b2b : e001 > cpx #1 ;test result > trap_ne 0b2d : d0fe > bne * ;failed not equal (non zero) > 0b2f : 68 > pla ;load status 0b30 : 48 > pha > cmp_flag 0 0b31 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 0b33 : d0fe > bne * ;failed not equal (non zero) > 0b35 : 28 > plp ;restore status 0b36 : ca dex ;00 tst_x 0,zero 0b37 : 08 > php ;save flags 0b38 : e000 > cpx #0 ;test result > trap_ne 0b3a : d0fe > bne * ;failed not equal (non zero) > 0b3c : 68 > pla ;load status 0b3d : 48 > pha > cmp_flag zero 0b3e : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0b40 : d0fe > bne * ;failed not equal (non zero) > 0b42 : 28 > plp ;restore status 0b43 : ca dex ;ff tst_x $ff,minus 0b44 : 08 > php ;save flags 0b45 : e0ff > cpx #$ff ;test result > trap_ne 0b47 : d0fe > bne * ;failed not equal (non zero) > 0b49 : 68 > pla ;load status 0b4a : 48 > pha > cmp_flag minus 0b4b : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0b4d : d0fe > bne * ;failed not equal (non zero) > 0b4f : 28 > plp ;restore status 0b50 : a0fe ldy #$fe set_stat $ff > load_flag $ff 0b52 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0b54 : 48 > pha ;use stack to load status 0b55 : 28 > plp 0b56 : c8 iny ;ff tst_y $ff,$ff-zero 0b57 : 08 > php ;save flags 0b58 : c0ff > cpy #$ff ;test result > trap_ne 0b5a : d0fe > bne * ;failed not equal (non zero) > 0b5c : 68 > pla ;load status 0b5d : 48 > pha > cmp_flag $ff-zero 0b5e : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0b60 : d0fe > bne * ;failed not equal (non zero) > 0b62 : 28 > plp ;restore status 0b63 : c8 iny ;00 tst_y 0,$ff-minus 0b64 : 08 > php ;save flags 0b65 : c000 > cpy #0 ;test result > trap_ne 0b67 : d0fe > bne * ;failed not equal (non zero) > 0b69 : 68 > pla ;load status 0b6a : 48 > pha > cmp_flag $ff-minus 0b6b : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0b6d : d0fe > bne * ;failed not equal (non zero) > 0b6f : 28 > plp ;restore status 0b70 : c8 iny ;01 tst_y 1,$ff-minus-zero 0b71 : 08 > php ;save flags 0b72 : c001 > cpy #1 ;test result > trap_ne 0b74 : d0fe > bne * ;failed not equal (non zero) > 0b76 : 68 > pla ;load status 0b77 : 48 > pha > cmp_flag $ff-minus-zero 0b78 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0b7a : d0fe > bne * ;failed not equal (non zero) > 0b7c : 28 > plp ;restore status 0b7d : 88 dey ;00 tst_y 0,$ff-minus 0b7e : 08 > php ;save flags 0b7f : c000 > cpy #0 ;test result > trap_ne 0b81 : d0fe > bne * ;failed not equal (non zero) > 0b83 : 68 > pla ;load status 0b84 : 48 > pha > cmp_flag $ff-minus 0b85 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0b87 : d0fe > bne * ;failed not equal (non zero) > 0b89 : 28 > plp ;restore status 0b8a : 88 dey ;ff tst_y $ff,$ff-zero 0b8b : 08 > php ;save flags 0b8c : c0ff > cpy #$ff ;test result > trap_ne 0b8e : d0fe > bne * ;failed not equal (non zero) > 0b90 : 68 > pla ;load status 0b91 : 48 > pha > cmp_flag $ff-zero 0b92 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0b94 : d0fe > bne * ;failed not equal (non zero) > 0b96 : 28 > plp ;restore status 0b97 : 88 dey ;fe set_stat 0 > load_flag 0 0b98 : a900 > lda #0 ;allow test to change I-flag (no mask) > 0b9a : 48 > pha ;use stack to load status 0b9b : 28 > plp 0b9c : c8 iny ;ff tst_y $ff,0+minus 0b9d : 08 > php ;save flags 0b9e : c0ff > cpy #$ff ;test result > trap_ne 0ba0 : d0fe > bne * ;failed not equal (non zero) > 0ba2 : 68 > pla ;load status 0ba3 : 48 > pha > cmp_flag 0+minus 0ba4 : c9b0 > cmp #(0+minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0ba6 : d0fe > bne * ;failed not equal (non zero) > 0ba8 : 28 > plp ;restore status 0ba9 : c8 iny ;00 tst_y 0,zero 0baa : 08 > php ;save flags 0bab : c000 > cpy #0 ;test result > trap_ne 0bad : d0fe > bne * ;failed not equal (non zero) > 0baf : 68 > pla ;load status 0bb0 : 48 > pha > cmp_flag zero 0bb1 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0bb3 : d0fe > bne * ;failed not equal (non zero) > 0bb5 : 28 > plp ;restore status 0bb6 : c8 iny ;01 tst_y 1,0 0bb7 : 08 > php ;save flags 0bb8 : c001 > cpy #1 ;test result > trap_ne 0bba : d0fe > bne * ;failed not equal (non zero) > 0bbc : 68 > pla ;load status 0bbd : 48 > pha > cmp_flag 0 0bbe : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 0bc0 : d0fe > bne * ;failed not equal (non zero) > 0bc2 : 28 > plp ;restore status 0bc3 : 88 dey ;00 tst_y 0,zero 0bc4 : 08 > php ;save flags 0bc5 : c000 > cpy #0 ;test result > trap_ne 0bc7 : d0fe > bne * ;failed not equal (non zero) > 0bc9 : 68 > pla ;load status 0bca : 48 > pha > cmp_flag zero 0bcb : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0bcd : d0fe > bne * ;failed not equal (non zero) > 0bcf : 28 > plp ;restore status 0bd0 : 88 dey ;ff tst_y $ff,minus 0bd1 : 08 > php ;save flags 0bd2 : c0ff > cpy #$ff ;test result > trap_ne 0bd4 : d0fe > bne * ;failed not equal (non zero) > 0bd6 : 68 > pla ;load status 0bd7 : 48 > pha > cmp_flag minus 0bd8 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0bda : d0fe > bne * ;failed not equal (non zero) > 0bdc : 28 > plp ;restore status 0bdd : a2ff ldx #$ff set_stat $ff > load_flag $ff 0bdf : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0be1 : 48 > pha ;use stack to load status 0be2 : 28 > plp 0be3 : 8a txa tst_a $ff,$ff-zero 0be4 : 08 > php ;save flags 0be5 : c9ff > cmp #$ff ;test result > trap_ne 0be7 : d0fe > bne * ;failed not equal (non zero) > 0be9 : 68 > pla ;load status 0bea : 48 > pha > cmp_flag $ff-zero 0beb : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0bed : d0fe > bne * ;failed not equal (non zero) > 0bef : 28 > plp ;restore status 0bf0 : 08 php 0bf1 : e8 inx ;00 0bf2 : 28 plp 0bf3 : 8a txa tst_a 0,$ff-minus 0bf4 : 08 > php ;save flags 0bf5 : c900 > cmp #0 ;test result > trap_ne 0bf7 : d0fe > bne * ;failed not equal (non zero) > 0bf9 : 68 > pla ;load status 0bfa : 48 > pha > cmp_flag $ff-minus 0bfb : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0bfd : d0fe > bne * ;failed not equal (non zero) > 0bff : 28 > plp ;restore status 0c00 : 08 php 0c01 : e8 inx ;01 0c02 : 28 plp 0c03 : 8a txa tst_a 1,$ff-minus-zero 0c04 : 08 > php ;save flags 0c05 : c901 > cmp #1 ;test result > trap_ne 0c07 : d0fe > bne * ;failed not equal (non zero) > 0c09 : 68 > pla ;load status 0c0a : 48 > pha > cmp_flag $ff-minus-zero 0c0b : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0c0d : d0fe > bne * ;failed not equal (non zero) > 0c0f : 28 > plp ;restore status set_stat 0 > load_flag 0 0c10 : a900 > lda #0 ;allow test to change I-flag (no mask) > 0c12 : 48 > pha ;use stack to load status 0c13 : 28 > plp 0c14 : 8a txa tst_a 1,0 0c15 : 08 > php ;save flags 0c16 : c901 > cmp #1 ;test result > trap_ne 0c18 : d0fe > bne * ;failed not equal (non zero) > 0c1a : 68 > pla ;load status 0c1b : 48 > pha > cmp_flag 0 0c1c : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 0c1e : d0fe > bne * ;failed not equal (non zero) > 0c20 : 28 > plp ;restore status 0c21 : 08 php 0c22 : ca dex ;00 0c23 : 28 plp 0c24 : 8a txa tst_a 0,zero 0c25 : 08 > php ;save flags 0c26 : c900 > cmp #0 ;test result > trap_ne 0c28 : d0fe > bne * ;failed not equal (non zero) > 0c2a : 68 > pla ;load status 0c2b : 48 > pha > cmp_flag zero 0c2c : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0c2e : d0fe > bne * ;failed not equal (non zero) > 0c30 : 28 > plp ;restore status 0c31 : 08 php 0c32 : ca dex ;ff 0c33 : 28 plp 0c34 : 8a txa tst_a $ff,minus 0c35 : 08 > php ;save flags 0c36 : c9ff > cmp #$ff ;test result > trap_ne 0c38 : d0fe > bne * ;failed not equal (non zero) > 0c3a : 68 > pla ;load status 0c3b : 48 > pha > cmp_flag minus 0c3c : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0c3e : d0fe > bne * ;failed not equal (non zero) > 0c40 : 28 > plp ;restore status 0c41 : a0ff ldy #$ff set_stat $ff > load_flag $ff 0c43 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0c45 : 48 > pha ;use stack to load status 0c46 : 28 > plp 0c47 : 98 tya tst_a $ff,$ff-zero 0c48 : 08 > php ;save flags 0c49 : c9ff > cmp #$ff ;test result > trap_ne 0c4b : d0fe > bne * ;failed not equal (non zero) > 0c4d : 68 > pla ;load status 0c4e : 48 > pha > cmp_flag $ff-zero 0c4f : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0c51 : d0fe > bne * ;failed not equal (non zero) > 0c53 : 28 > plp ;restore status 0c54 : 08 php 0c55 : c8 iny ;00 0c56 : 28 plp 0c57 : 98 tya tst_a 0,$ff-minus 0c58 : 08 > php ;save flags 0c59 : c900 > cmp #0 ;test result > trap_ne 0c5b : d0fe > bne * ;failed not equal (non zero) > 0c5d : 68 > pla ;load status 0c5e : 48 > pha > cmp_flag $ff-minus 0c5f : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0c61 : d0fe > bne * ;failed not equal (non zero) > 0c63 : 28 > plp ;restore status 0c64 : 08 php 0c65 : c8 iny ;01 0c66 : 28 plp 0c67 : 98 tya tst_a 1,$ff-minus-zero 0c68 : 08 > php ;save flags 0c69 : c901 > cmp #1 ;test result > trap_ne 0c6b : d0fe > bne * ;failed not equal (non zero) > 0c6d : 68 > pla ;load status 0c6e : 48 > pha > cmp_flag $ff-minus-zero 0c6f : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0c71 : d0fe > bne * ;failed not equal (non zero) > 0c73 : 28 > plp ;restore status set_stat 0 > load_flag 0 0c74 : a900 > lda #0 ;allow test to change I-flag (no mask) > 0c76 : 48 > pha ;use stack to load status 0c77 : 28 > plp 0c78 : 98 tya tst_a 1,0 0c79 : 08 > php ;save flags 0c7a : c901 > cmp #1 ;test result > trap_ne 0c7c : d0fe > bne * ;failed not equal (non zero) > 0c7e : 68 > pla ;load status 0c7f : 48 > pha > cmp_flag 0 0c80 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 0c82 : d0fe > bne * ;failed not equal (non zero) > 0c84 : 28 > plp ;restore status 0c85 : 08 php 0c86 : 88 dey ;00 0c87 : 28 plp 0c88 : 98 tya tst_a 0,zero 0c89 : 08 > php ;save flags 0c8a : c900 > cmp #0 ;test result > trap_ne 0c8c : d0fe > bne * ;failed not equal (non zero) > 0c8e : 68 > pla ;load status 0c8f : 48 > pha > cmp_flag zero 0c90 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0c92 : d0fe > bne * ;failed not equal (non zero) > 0c94 : 28 > plp ;restore status 0c95 : 08 php 0c96 : 88 dey ;ff 0c97 : 28 plp 0c98 : 98 tya tst_a $ff,minus 0c99 : 08 > php ;save flags 0c9a : c9ff > cmp #$ff ;test result > trap_ne 0c9c : d0fe > bne * ;failed not equal (non zero) > 0c9e : 68 > pla ;load status 0c9f : 48 > pha > cmp_flag minus 0ca0 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0ca2 : d0fe > bne * ;failed not equal (non zero) > 0ca4 : 28 > plp ;restore status load_flag $ff 0ca5 : a9ff > lda #$ff ;allow test to change I-flag (no mask) 0ca7 : 48 pha 0ca8 : a2ff ldx #$ff ;ff 0caa : 8a txa 0cab : 28 plp 0cac : a8 tay tst_y $ff,$ff-zero 0cad : 08 > php ;save flags 0cae : c0ff > cpy #$ff ;test result > trap_ne 0cb0 : d0fe > bne * ;failed not equal (non zero) > 0cb2 : 68 > pla ;load status 0cb3 : 48 > pha > cmp_flag $ff-zero 0cb4 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0cb6 : d0fe > bne * ;failed not equal (non zero) > 0cb8 : 28 > plp ;restore status 0cb9 : 08 php 0cba : e8 inx ;00 0cbb : 8a txa 0cbc : 28 plp 0cbd : a8 tay tst_y 0,$ff-minus 0cbe : 08 > php ;save flags 0cbf : c000 > cpy #0 ;test result > trap_ne 0cc1 : d0fe > bne * ;failed not equal (non zero) > 0cc3 : 68 > pla ;load status 0cc4 : 48 > pha > cmp_flag $ff-minus 0cc5 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0cc7 : d0fe > bne * ;failed not equal (non zero) > 0cc9 : 28 > plp ;restore status 0cca : 08 php 0ccb : e8 inx ;01 0ccc : 8a txa 0ccd : 28 plp 0cce : a8 tay tst_y 1,$ff-minus-zero 0ccf : 08 > php ;save flags 0cd0 : c001 > cpy #1 ;test result > trap_ne 0cd2 : d0fe > bne * ;failed not equal (non zero) > 0cd4 : 68 > pla ;load status 0cd5 : 48 > pha > cmp_flag $ff-minus-zero 0cd6 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0cd8 : d0fe > bne * ;failed not equal (non zero) > 0cda : 28 > plp ;restore status load_flag 0 0cdb : a900 > lda #0 ;allow test to change I-flag (no mask) 0cdd : 48 pha 0cde : a900 lda #0 0ce0 : 8a txa 0ce1 : 28 plp 0ce2 : a8 tay tst_y 1,0 0ce3 : 08 > php ;save flags 0ce4 : c001 > cpy #1 ;test result > trap_ne 0ce6 : d0fe > bne * ;failed not equal (non zero) > 0ce8 : 68 > pla ;load status 0ce9 : 48 > pha > cmp_flag 0 0cea : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 0cec : d0fe > bne * ;failed not equal (non zero) > 0cee : 28 > plp ;restore status 0cef : 08 php 0cf0 : ca dex ;00 0cf1 : 8a txa 0cf2 : 28 plp 0cf3 : a8 tay tst_y 0,zero 0cf4 : 08 > php ;save flags 0cf5 : c000 > cpy #0 ;test result > trap_ne 0cf7 : d0fe > bne * ;failed not equal (non zero) > 0cf9 : 68 > pla ;load status 0cfa : 48 > pha > cmp_flag zero 0cfb : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0cfd : d0fe > bne * ;failed not equal (non zero) > 0cff : 28 > plp ;restore status 0d00 : 08 php 0d01 : ca dex ;ff 0d02 : 8a txa 0d03 : 28 plp 0d04 : a8 tay tst_y $ff,minus 0d05 : 08 > php ;save flags 0d06 : c0ff > cpy #$ff ;test result > trap_ne 0d08 : d0fe > bne * ;failed not equal (non zero) > 0d0a : 68 > pla ;load status 0d0b : 48 > pha > cmp_flag minus 0d0c : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0d0e : d0fe > bne * ;failed not equal (non zero) > 0d10 : 28 > plp ;restore status load_flag $ff 0d11 : a9ff > lda #$ff ;allow test to change I-flag (no mask) 0d13 : 48 pha 0d14 : a0ff ldy #$ff ;ff 0d16 : 98 tya 0d17 : 28 plp 0d18 : aa tax tst_x $ff,$ff-zero 0d19 : 08 > php ;save flags 0d1a : e0ff > cpx #$ff ;test result > trap_ne 0d1c : d0fe > bne * ;failed not equal (non zero) > 0d1e : 68 > pla ;load status 0d1f : 48 > pha > cmp_flag $ff-zero 0d20 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0d22 : d0fe > bne * ;failed not equal (non zero) > 0d24 : 28 > plp ;restore status 0d25 : 08 php 0d26 : c8 iny ;00 0d27 : 98 tya 0d28 : 28 plp 0d29 : aa tax tst_x 0,$ff-minus 0d2a : 08 > php ;save flags 0d2b : e000 > cpx #0 ;test result > trap_ne 0d2d : d0fe > bne * ;failed not equal (non zero) > 0d2f : 68 > pla ;load status 0d30 : 48 > pha > cmp_flag $ff-minus 0d31 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0d33 : d0fe > bne * ;failed not equal (non zero) > 0d35 : 28 > plp ;restore status 0d36 : 08 php 0d37 : c8 iny ;01 0d38 : 98 tya 0d39 : 28 plp 0d3a : aa tax tst_x 1,$ff-minus-zero 0d3b : 08 > php ;save flags 0d3c : e001 > cpx #1 ;test result > trap_ne 0d3e : d0fe > bne * ;failed not equal (non zero) > 0d40 : 68 > pla ;load status 0d41 : 48 > pha > cmp_flag $ff-minus-zero 0d42 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0d44 : d0fe > bne * ;failed not equal (non zero) > 0d46 : 28 > plp ;restore status load_flag 0 0d47 : a900 > lda #0 ;allow test to change I-flag (no mask) 0d49 : 48 pha 0d4a : a900 lda #0 ;preset status 0d4c : 98 tya 0d4d : 28 plp 0d4e : aa tax tst_x 1,0 0d4f : 08 > php ;save flags 0d50 : e001 > cpx #1 ;test result > trap_ne 0d52 : d0fe > bne * ;failed not equal (non zero) > 0d54 : 68 > pla ;load status 0d55 : 48 > pha > cmp_flag 0 0d56 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits > > trap_ne 0d58 : d0fe > bne * ;failed not equal (non zero) > 0d5a : 28 > plp ;restore status 0d5b : 08 php 0d5c : 88 dey ;00 0d5d : 98 tya 0d5e : 28 plp 0d5f : aa tax tst_x 0,zero 0d60 : 08 > php ;save flags 0d61 : e000 > cpx #0 ;test result > trap_ne 0d63 : d0fe > bne * ;failed not equal (non zero) > 0d65 : 68 > pla ;load status 0d66 : 48 > pha > cmp_flag zero 0d67 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits > > trap_ne 0d69 : d0fe > bne * ;failed not equal (non zero) > 0d6b : 28 > plp ;restore status 0d6c : 08 php 0d6d : 88 dey ;ff 0d6e : 98 tya 0d6f : 28 plp 0d70 : aa tax tst_x $ff,minus 0d71 : 08 > php ;save flags 0d72 : e0ff > cpx #$ff ;test result > trap_ne 0d74 : d0fe > bne * ;failed not equal (non zero) > 0d76 : 68 > pla ;load status 0d77 : 48 > pha > cmp_flag minus 0d78 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits > > trap_ne 0d7a : d0fe > bne * ;failed not equal (non zero) > 0d7c : 28 > plp ;restore status next_test 0d7d : ad0002 > lda test_case ;previous test 0d80 : c90d > cmp #test_num > trap_ne ;test is out of sequence 0d82 : d0fe > bne * ;failed not equal (non zero) > 000e = >test_num = test_num + 1 0d84 : a90e > lda #test_num ;*** next tests' number 0d86 : 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. 0d89 : a201 ldx #1 ;01 set_stat $ff > load_flag $ff 0d8b : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0d8d : 48 > pha ;use stack to load status 0d8e : 28 > plp 0d8f : 9a txs 0d90 : 08 php 0d91 : ad0101 lda $101 cmp_flag $ff 0d94 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits trap_ne 0d96 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 0d98 : a900 > lda #0 ;allow test to change I-flag (no mask) > 0d9a : 48 > pha ;use stack to load status 0d9b : 28 > plp 0d9c : 9a txs 0d9d : 08 php 0d9e : ad0101 lda $101 cmp_flag 0 0da1 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits trap_ne 0da3 : d0fe > bne * ;failed not equal (non zero) 0da5 : ca dex ;00 set_stat $ff > load_flag $ff 0da6 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0da8 : 48 > pha ;use stack to load status 0da9 : 28 > plp 0daa : 9a txs 0dab : 08 php 0dac : ad0001 lda $100 cmp_flag $ff 0daf : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits trap_ne 0db1 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 0db3 : a900 > lda #0 ;allow test to change I-flag (no mask) > 0db5 : 48 > pha ;use stack to load status 0db6 : 28 > plp 0db7 : 9a txs 0db8 : 08 php 0db9 : ad0001 lda $100 cmp_flag 0 0dbc : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits trap_ne 0dbe : d0fe > bne * ;failed not equal (non zero) 0dc0 : ca dex ;ff set_stat $ff > load_flag $ff 0dc1 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0dc3 : 48 > pha ;use stack to load status 0dc4 : 28 > plp 0dc5 : 9a txs 0dc6 : 08 php 0dc7 : adff01 lda $1ff cmp_flag $ff 0dca : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits trap_ne 0dcc : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 0dce : a900 > lda #0 ;allow test to change I-flag (no mask) > 0dd0 : 48 > pha ;use stack to load status 0dd1 : 28 > plp 0dd2 : 9a txs 0dd3 : 08 php 0dd4 : adff01 lda $1ff cmp_flag 0 0dd7 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits 0dd9 : a201 ldx #1 0ddb : 9a txs ;sp=01 set_stat $ff > load_flag $ff 0ddc : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0dde : 48 > pha ;use stack to load status 0ddf : 28 > plp 0de0 : ba tsx ;clears Z, N 0de1 : 08 php ;sp=00 0de2 : e001 cpx #1 trap_ne 0de4 : d0fe > bne * ;failed not equal (non zero) 0de6 : ad0101 lda $101 cmp_flag $ff-minus-zero 0de9 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits trap_ne 0deb : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 0ded : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0def : 48 > pha ;use stack to load status 0df0 : 28 > plp 0df1 : ba tsx ;clears N, sets Z 0df2 : 08 php ;sp=ff 0df3 : e000 cpx #0 trap_ne 0df5 : d0fe > bne * ;failed not equal (non zero) 0df7 : ad0001 lda $100 cmp_flag $ff-minus 0dfa : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits trap_ne 0dfc : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 0dfe : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0e00 : 48 > pha ;use stack to load status 0e01 : 28 > plp 0e02 : ba tsx ;clears N, sets Z 0e03 : 08 php ;sp=fe 0e04 : e0ff cpx #$ff trap_ne 0e06 : d0fe > bne * ;failed not equal (non zero) 0e08 : adff01 lda $1ff cmp_flag $ff-zero 0e0b : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits trap_ne 0e0d : d0fe > bne * ;failed not equal (non zero) 0e0f : a201 ldx #1 0e11 : 9a txs ;sp=01 set_stat 0 > load_flag 0 0e12 : a900 > lda #0 ;allow test to change I-flag (no mask) > 0e14 : 48 > pha ;use stack to load status 0e15 : 28 > plp 0e16 : ba tsx ;clears Z, N 0e17 : 08 php ;sp=00 0e18 : e001 cpx #1 trap_ne 0e1a : d0fe > bne * ;failed not equal (non zero) 0e1c : ad0101 lda $101 cmp_flag 0 0e1f : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits trap_ne 0e21 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 0e23 : a900 > lda #0 ;allow test to change I-flag (no mask) > 0e25 : 48 > pha ;use stack to load status 0e26 : 28 > plp 0e27 : ba tsx ;clears N, sets Z 0e28 : 08 php ;sp=ff 0e29 : e000 cpx #0 trap_ne 0e2b : d0fe > bne * ;failed not equal (non zero) 0e2d : ad0001 lda $100 cmp_flag zero 0e30 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits trap_ne 0e32 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 0e34 : a900 > lda #0 ;allow test to change I-flag (no mask) > 0e36 : 48 > pha ;use stack to load status 0e37 : 28 > plp 0e38 : ba tsx ;clears N, sets Z 0e39 : 08 php ;sp=fe 0e3a : e0ff cpx #$ff trap_ne 0e3c : d0fe > bne * ;failed not equal (non zero) 0e3e : adff01 lda $1ff cmp_flag minus 0e41 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits trap_ne 0e43 : d0fe > bne * ;failed not equal (non zero) 0e45 : 68 pla ;sp=ff next_test 0e46 : ad0002 > lda test_case ;previous test 0e49 : c90e > cmp #test_num > trap_ne ;test is out of sequence 0e4b : d0fe > bne * ;failed not equal (non zero) > 000f = >test_num = test_num + 1 0e4d : a90f > lda #test_num ;*** next tests' number 0e4f : 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 0e52 : a003 ldy #3 0e54 : tldx set_stat 0 > load_flag 0 0e54 : a900 > lda #0 ;allow test to change I-flag (no mask) > 0e56 : 48 > pha ;use stack to load status 0e57 : 28 > plp 0e58 : b613 ldx zp1,y 0e5a : 08 php ;test stores do not alter flags 0e5b : 8a txa 0e5c : 49c3 eor #$c3 0e5e : 28 plp 0e5f : 990302 sta abst,y 0e62 : 08 php ;flags after load/store sequence 0e63 : 49c3 eor #$c3 0e65 : d91702 cmp abs1,y ;test result trap_ne 0e68 : d0fe > bne * ;failed not equal (non zero) 0e6a : 68 pla ;load status eor_flag 0 0e6b : 4930 > eor #0|fao ;invert expected flags + always on bits 0e6d : d91c02 cmp fLDx,y ;test flags trap_ne 0e70 : d0fe > bne * ;failed not equal (non zero) 0e72 : 88 dey 0e73 : 10df bpl tldx 0e75 : a003 ldy #3 0e77 : tldx1 set_stat $ff > load_flag $ff 0e77 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0e79 : 48 > pha ;use stack to load status 0e7a : 28 > plp 0e7b : b613 ldx zp1,y 0e7d : 08 php ;test stores do not alter flags 0e7e : 8a txa 0e7f : 49c3 eor #$c3 0e81 : 28 plp 0e82 : 990302 sta abst,y 0e85 : 08 php ;flags after load/store sequence 0e86 : 49c3 eor #$c3 0e88 : d91702 cmp abs1,y ;test result trap_ne 0e8b : d0fe > bne * ;failed not equal (non zero) 0e8d : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 0e8e : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 0e90 : d91c02 cmp fLDx,y ;test flags trap_ne 0e93 : d0fe > bne * ;failed not equal (non zero) 0e95 : 88 dey 0e96 : 10df bpl tldx1 0e98 : a003 ldy #3 0e9a : tldx2 set_stat 0 > load_flag 0 0e9a : a900 > lda #0 ;allow test to change I-flag (no mask) > 0e9c : 48 > pha ;use stack to load status 0e9d : 28 > plp 0e9e : be1702 ldx abs1,y 0ea1 : 08 php ;test stores do not alter flags 0ea2 : 8a txa 0ea3 : 49c3 eor #$c3 0ea5 : aa tax 0ea6 : 28 plp 0ea7 : 960c stx zpt,y 0ea9 : 08 php ;flags after load/store sequence 0eaa : 49c3 eor #$c3 0eac : d91300 cmp zp1,y ;test result trap_ne 0eaf : d0fe > bne * ;failed not equal (non zero) 0eb1 : 68 pla ;load status eor_flag 0 0eb2 : 4930 > eor #0|fao ;invert expected flags + always on bits 0eb4 : d91c02 cmp fLDx,y ;test flags trap_ne 0eb7 : d0fe > bne * ;failed not equal (non zero) 0eb9 : 88 dey 0eba : 10de bpl tldx2 0ebc : a003 ldy #3 0ebe : tldx3 set_stat $ff > load_flag $ff 0ebe : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0ec0 : 48 > pha ;use stack to load status 0ec1 : 28 > plp 0ec2 : be1702 ldx abs1,y 0ec5 : 08 php ;test stores do not alter flags 0ec6 : 8a txa 0ec7 : 49c3 eor #$c3 0ec9 : aa tax 0eca : 28 plp 0ecb : 960c stx zpt,y 0ecd : 08 php ;flags after load/store sequence 0ece : 49c3 eor #$c3 0ed0 : d91300 cmp zp1,y ;test result trap_ne 0ed3 : d0fe > bne * ;failed not equal (non zero) 0ed5 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 0ed6 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 0ed8 : d91c02 cmp fLDx,y ;test flags trap_ne 0edb : d0fe > bne * ;failed not equal (non zero) 0edd : 88 dey 0ede : 10de bpl tldx3 0ee0 : a003 ldy #3 ;testing store result 0ee2 : a200 ldx #0 0ee4 : b90c00 tstx lda zpt,y 0ee7 : 49c3 eor #$c3 0ee9 : d91300 cmp zp1,y trap_ne ;store to zp data 0eec : d0fe > bne * ;failed not equal (non zero) 0eee : 960c stx zpt,y ;clear 0ef0 : b90302 lda abst,y 0ef3 : 49c3 eor #$c3 0ef5 : d91702 cmp abs1,y trap_ne ;store to abs data 0ef8 : d0fe > bne * ;failed not equal (non zero) 0efa : 8a txa 0efb : 990302 sta abst,y ;clear 0efe : 88 dey 0eff : 10e3 bpl tstx next_test 0f01 : ad0002 > lda test_case ;previous test 0f04 : c90f > cmp #test_num > trap_ne ;test is out of sequence 0f06 : d0fe > bne * ;failed not equal (non zero) > 0010 = >test_num = test_num + 1 0f08 : a910 > lda #test_num ;*** next tests' number 0f0a : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; indexed wraparound test (only zp should wrap) 0f0d : a0fd ldy #3+$fa 0f0f : b619 tldx4 ldx zp1-$fa&$ff,y ;wrap on indexed zp 0f11 : 8a txa 0f12 : 990901 sta abst-$fa,y ;no STX abs,y! 0f15 : 88 dey 0f16 : c0fa cpy #$fa 0f18 : b0f5 bcs tldx4 0f1a : a0fd ldy #3+$fa 0f1c : be1d01 tldx5 ldx abs1-$fa,y ;no wrap on indexed abs 0f1f : 9612 stx zpt-$fa&$ff,y 0f21 : 88 dey 0f22 : c0fa cpy #$fa 0f24 : b0f6 bcs tldx5 0f26 : a003 ldy #3 ;testing wraparound result 0f28 : a200 ldx #0 0f2a : b90c00 tstx1 lda zpt,y 0f2d : d91300 cmp zp1,y trap_ne ;store to zp data 0f30 : d0fe > bne * ;failed not equal (non zero) 0f32 : 960c stx zpt,y ;clear 0f34 : b90302 lda abst,y 0f37 : d91702 cmp abs1,y trap_ne ;store to abs data 0f3a : d0fe > bne * ;failed not equal (non zero) 0f3c : 8a txa 0f3d : 990302 sta abst,y ;clear 0f40 : 88 dey 0f41 : 10e7 bpl tstx1 next_test 0f43 : ad0002 > lda test_case ;previous test 0f46 : c910 > cmp #test_num > trap_ne ;test is out of sequence 0f48 : d0fe > bne * ;failed not equal (non zero) > 0011 = >test_num = test_num + 1 0f4a : a911 > lda #test_num ;*** next tests' number 0f4c : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; LDY / STY - zp,x / abs,x 0f4f : a203 ldx #3 0f51 : tldy set_stat 0 > load_flag 0 0f51 : a900 > lda #0 ;allow test to change I-flag (no mask) > 0f53 : 48 > pha ;use stack to load status 0f54 : 28 > plp 0f55 : b413 ldy zp1,x 0f57 : 08 php ;test stores do not alter flags 0f58 : 98 tya 0f59 : 49c3 eor #$c3 0f5b : 28 plp 0f5c : 9d0302 sta abst,x 0f5f : 08 php ;flags after load/store sequence 0f60 : 49c3 eor #$c3 0f62 : dd1702 cmp abs1,x ;test result trap_ne 0f65 : d0fe > bne * ;failed not equal (non zero) 0f67 : 68 pla ;load status eor_flag 0 0f68 : 4930 > eor #0|fao ;invert expected flags + always on bits 0f6a : dd1c02 cmp fLDx,x ;test flags trap_ne 0f6d : d0fe > bne * ;failed not equal (non zero) 0f6f : ca dex 0f70 : 10df bpl tldy 0f72 : a203 ldx #3 0f74 : tldy1 set_stat $ff > load_flag $ff 0f74 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0f76 : 48 > pha ;use stack to load status 0f77 : 28 > plp 0f78 : b413 ldy zp1,x 0f7a : 08 php ;test stores do not alter flags 0f7b : 98 tya 0f7c : 49c3 eor #$c3 0f7e : 28 plp 0f7f : 9d0302 sta abst,x 0f82 : 08 php ;flags after load/store sequence 0f83 : 49c3 eor #$c3 0f85 : dd1702 cmp abs1,x ;test result trap_ne 0f88 : d0fe > bne * ;failed not equal (non zero) 0f8a : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 0f8b : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 0f8d : dd1c02 cmp fLDx,x ;test flags trap_ne 0f90 : d0fe > bne * ;failed not equal (non zero) 0f92 : ca dex 0f93 : 10df bpl tldy1 0f95 : a203 ldx #3 0f97 : tldy2 set_stat 0 > load_flag 0 0f97 : a900 > lda #0 ;allow test to change I-flag (no mask) > 0f99 : 48 > pha ;use stack to load status 0f9a : 28 > plp 0f9b : bc1702 ldy abs1,x 0f9e : 08 php ;test stores do not alter flags 0f9f : 98 tya 0fa0 : 49c3 eor #$c3 0fa2 : a8 tay 0fa3 : 28 plp 0fa4 : 940c sty zpt,x 0fa6 : 08 php ;flags after load/store sequence 0fa7 : 49c3 eor #$c3 0fa9 : d513 cmp zp1,x ;test result trap_ne 0fab : d0fe > bne * ;failed not equal (non zero) 0fad : 68 pla ;load status eor_flag 0 0fae : 4930 > eor #0|fao ;invert expected flags + always on bits 0fb0 : dd1c02 cmp fLDx,x ;test flags trap_ne 0fb3 : d0fe > bne * ;failed not equal (non zero) 0fb5 : ca dex 0fb6 : 10df bpl tldy2 0fb8 : a203 ldx #3 0fba : tldy3 set_stat $ff > load_flag $ff 0fba : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 0fbc : 48 > pha ;use stack to load status 0fbd : 28 > plp 0fbe : bc1702 ldy abs1,x 0fc1 : 08 php ;test stores do not alter flags 0fc2 : 98 tya 0fc3 : 49c3 eor #$c3 0fc5 : a8 tay 0fc6 : 28 plp 0fc7 : 940c sty zpt,x 0fc9 : 08 php ;flags after load/store sequence 0fca : 49c3 eor #$c3 0fcc : d513 cmp zp1,x ;test result trap_ne 0fce : d0fe > bne * ;failed not equal (non zero) 0fd0 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 0fd1 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 0fd3 : dd1c02 cmp fLDx,x ;test flags trap_ne 0fd6 : d0fe > bne * ;failed not equal (non zero) 0fd8 : ca dex 0fd9 : 10df bpl tldy3 0fdb : a203 ldx #3 ;testing store result 0fdd : a000 ldy #0 0fdf : b50c tsty lda zpt,x 0fe1 : 49c3 eor #$c3 0fe3 : d513 cmp zp1,x trap_ne ;store to zp,x data 0fe5 : d0fe > bne * ;failed not equal (non zero) 0fe7 : 940c sty zpt,x ;clear 0fe9 : bd0302 lda abst,x 0fec : 49c3 eor #$c3 0fee : dd1702 cmp abs1,x trap_ne ;store to abs,x data 0ff1 : d0fe > bne * ;failed not equal (non zero) 0ff3 : 8a txa 0ff4 : 9d0302 sta abst,x ;clear 0ff7 : ca dex 0ff8 : 10e5 bpl tsty next_test 0ffa : ad0002 > lda test_case ;previous test 0ffd : c911 > cmp #test_num > trap_ne ;test is out of sequence 0fff : d0fe > bne * ;failed not equal (non zero) > 0012 = >test_num = test_num + 1 1001 : a912 > lda #test_num ;*** next tests' number 1003 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; indexed wraparound test (only zp should wrap) 1006 : a2fd ldx #3+$fa 1008 : b419 tldy4 ldy zp1-$fa&$ff,x ;wrap on indexed zp 100a : 98 tya 100b : 9d0901 sta abst-$fa,x ;no STX abs,x! 100e : ca dex 100f : e0fa cpx #$fa 1011 : b0f5 bcs tldy4 1013 : a2fd ldx #3+$fa 1015 : bc1d01 tldy5 ldy abs1-$fa,x ;no wrap on indexed abs 1018 : 9412 sty zpt-$fa&$ff,x 101a : ca dex 101b : e0fa cpx #$fa 101d : b0f6 bcs tldy5 101f : a203 ldx #3 ;testing wraparound result 1021 : a000 ldy #0 1023 : b50c tsty1 lda zpt,x 1025 : d513 cmp zp1,x trap_ne ;store to zp,x data 1027 : d0fe > bne * ;failed not equal (non zero) 1029 : 940c sty zpt,x ;clear 102b : bd0302 lda abst,x 102e : dd1702 cmp abs1,x trap_ne ;store to abs,x data 1031 : d0fe > bne * ;failed not equal (non zero) 1033 : 8a txa 1034 : 9d0302 sta abst,x ;clear 1037 : ca dex 1038 : 10e9 bpl tsty1 next_test 103a : ad0002 > lda test_case ;previous test 103d : c912 > cmp #test_num > trap_ne ;test is out of sequence 103f : d0fe > bne * ;failed not equal (non zero) > 0013 = >test_num = test_num + 1 1041 : a913 > lda #test_num ;*** next tests' number 1043 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; LDX / STX - zp / abs / # set_stat 0 > load_flag 0 1046 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1048 : 48 > pha ;use stack to load status 1049 : 28 > plp 104a : a613 ldx zp1 104c : 08 php ;test stores do not alter flags 104d : 8a txa 104e : 49c3 eor #$c3 1050 : aa tax 1051 : 28 plp 1052 : 8e0302 stx abst 1055 : 08 php ;flags after load/store sequence 1056 : 49c3 eor #$c3 1058 : aa tax 1059 : e0c3 cpx #$c3 ;test result trap_ne 105b : d0fe > bne * ;failed not equal (non zero) 105d : 68 pla ;load status eor_flag 0 105e : 4930 > eor #0|fao ;invert expected flags + always on bits 1060 : cd1c02 cmp fLDx ;test flags trap_ne 1063 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1065 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1067 : 48 > pha ;use stack to load status 1068 : 28 > plp 1069 : a614 ldx zp1+1 106b : 08 php ;test stores do not alter flags 106c : 8a txa 106d : 49c3 eor #$c3 106f : aa tax 1070 : 28 plp 1071 : 8e0402 stx abst+1 1074 : 08 php ;flags after load/store sequence 1075 : 49c3 eor #$c3 1077 : aa tax 1078 : e082 cpx #$82 ;test result trap_ne 107a : d0fe > bne * ;failed not equal (non zero) 107c : 68 pla ;load status eor_flag 0 107d : 4930 > eor #0|fao ;invert expected flags + always on bits 107f : cd1d02 cmp fLDx+1 ;test flags trap_ne 1082 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1084 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1086 : 48 > pha ;use stack to load status 1087 : 28 > plp 1088 : a615 ldx zp1+2 108a : 08 php ;test stores do not alter flags 108b : 8a txa 108c : 49c3 eor #$c3 108e : aa tax 108f : 28 plp 1090 : 8e0502 stx abst+2 1093 : 08 php ;flags after load/store sequence 1094 : 49c3 eor #$c3 1096 : aa tax 1097 : e041 cpx #$41 ;test result trap_ne 1099 : d0fe > bne * ;failed not equal (non zero) 109b : 68 pla ;load status eor_flag 0 109c : 4930 > eor #0|fao ;invert expected flags + always on bits 109e : cd1e02 cmp fLDx+2 ;test flags trap_ne 10a1 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 10a3 : a900 > lda #0 ;allow test to change I-flag (no mask) > 10a5 : 48 > pha ;use stack to load status 10a6 : 28 > plp 10a7 : a616 ldx zp1+3 10a9 : 08 php ;test stores do not alter flags 10aa : 8a txa 10ab : 49c3 eor #$c3 10ad : aa tax 10ae : 28 plp 10af : 8e0602 stx abst+3 10b2 : 08 php ;flags after load/store sequence 10b3 : 49c3 eor #$c3 10b5 : aa tax 10b6 : e000 cpx #0 ;test result trap_ne 10b8 : d0fe > bne * ;failed not equal (non zero) 10ba : 68 pla ;load status eor_flag 0 10bb : 4930 > eor #0|fao ;invert expected flags + always on bits 10bd : cd1f02 cmp fLDx+3 ;test flags trap_ne 10c0 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 10c2 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 10c4 : 48 > pha ;use stack to load status 10c5 : 28 > plp 10c6 : a613 ldx zp1 10c8 : 08 php ;test stores do not alter flags 10c9 : 8a txa 10ca : 49c3 eor #$c3 10cc : aa tax 10cd : 28 plp 10ce : 8e0302 stx abst 10d1 : 08 php ;flags after load/store sequence 10d2 : 49c3 eor #$c3 10d4 : aa tax 10d5 : e0c3 cpx #$c3 ;test result trap_ne ; 10d7 : d0fe > bne * ;failed not equal (non zero) 10d9 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 10da : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 10dc : cd1c02 cmp fLDx ;test flags trap_ne 10df : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 10e1 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 10e3 : 48 > pha ;use stack to load status 10e4 : 28 > plp 10e5 : a614 ldx zp1+1 10e7 : 08 php ;test stores do not alter flags 10e8 : 8a txa 10e9 : 49c3 eor #$c3 10eb : aa tax 10ec : 28 plp 10ed : 8e0402 stx abst+1 10f0 : 08 php ;flags after load/store sequence 10f1 : 49c3 eor #$c3 10f3 : aa tax 10f4 : e082 cpx #$82 ;test result trap_ne 10f6 : d0fe > bne * ;failed not equal (non zero) 10f8 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 10f9 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 10fb : cd1d02 cmp fLDx+1 ;test flags trap_ne 10fe : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1100 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1102 : 48 > pha ;use stack to load status 1103 : 28 > plp 1104 : a615 ldx zp1+2 1106 : 08 php ;test stores do not alter flags 1107 : 8a txa 1108 : 49c3 eor #$c3 110a : aa tax 110b : 28 plp 110c : 8e0502 stx abst+2 110f : 08 php ;flags after load/store sequence 1110 : 49c3 eor #$c3 1112 : aa tax 1113 : e041 cpx #$41 ;test result trap_ne ; 1115 : d0fe > bne * ;failed not equal (non zero) 1117 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1118 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 111a : cd1e02 cmp fLDx+2 ;test flags trap_ne 111d : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 111f : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1121 : 48 > pha ;use stack to load status 1122 : 28 > plp 1123 : a616 ldx zp1+3 1125 : 08 php ;test stores do not alter flags 1126 : 8a txa 1127 : 49c3 eor #$c3 1129 : aa tax 112a : 28 plp 112b : 8e0602 stx abst+3 112e : 08 php ;flags after load/store sequence 112f : 49c3 eor #$c3 1131 : aa tax 1132 : e000 cpx #0 ;test result trap_ne 1134 : d0fe > bne * ;failed not equal (non zero) 1136 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1137 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1139 : cd1f02 cmp fLDx+3 ;test flags trap_ne 113c : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 113e : a900 > lda #0 ;allow test to change I-flag (no mask) > 1140 : 48 > pha ;use stack to load status 1141 : 28 > plp 1142 : ae1702 ldx abs1 1145 : 08 php ;test stores do not alter flags 1146 : 8a txa 1147 : 49c3 eor #$c3 1149 : aa tax 114a : 28 plp 114b : 860c stx zpt 114d : 08 php ;flags after load/store sequence 114e : 49c3 eor #$c3 1150 : c513 cmp zp1 ;test result trap_ne 1152 : d0fe > bne * ;failed not equal (non zero) 1154 : 68 pla ;load status eor_flag 0 1155 : 4930 > eor #0|fao ;invert expected flags + always on bits 1157 : cd1c02 cmp fLDx ;test flags trap_ne 115a : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 115c : a900 > lda #0 ;allow test to change I-flag (no mask) > 115e : 48 > pha ;use stack to load status 115f : 28 > plp 1160 : ae1802 ldx abs1+1 1163 : 08 php ;test stores do not alter flags 1164 : 8a txa 1165 : 49c3 eor #$c3 1167 : aa tax 1168 : 28 plp 1169 : 860d stx zpt+1 116b : 08 php ;flags after load/store sequence 116c : 49c3 eor #$c3 116e : c514 cmp zp1+1 ;test result trap_ne 1170 : d0fe > bne * ;failed not equal (non zero) 1172 : 68 pla ;load status eor_flag 0 1173 : 4930 > eor #0|fao ;invert expected flags + always on bits 1175 : cd1d02 cmp fLDx+1 ;test flags trap_ne 1178 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 117a : a900 > lda #0 ;allow test to change I-flag (no mask) > 117c : 48 > pha ;use stack to load status 117d : 28 > plp 117e : ae1902 ldx abs1+2 1181 : 08 php ;test stores do not alter flags 1182 : 8a txa 1183 : 49c3 eor #$c3 1185 : aa tax 1186 : 28 plp 1187 : 860e stx zpt+2 1189 : 08 php ;flags after load/store sequence 118a : 49c3 eor #$c3 118c : c515 cmp zp1+2 ;test result trap_ne 118e : d0fe > bne * ;failed not equal (non zero) 1190 : 68 pla ;load status eor_flag 0 1191 : 4930 > eor #0|fao ;invert expected flags + always on bits 1193 : cd1e02 cmp fLDx+2 ;test flags 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 : ae1a02 ldx abs1+3 119f : 08 php ;test stores do not alter flags 11a0 : 8a txa 11a1 : 49c3 eor #$c3 11a3 : aa tax 11a4 : 28 plp 11a5 : 860f stx zpt+3 11a7 : 08 php ;flags after load/store sequence 11a8 : 49c3 eor #$c3 11aa : c516 cmp zp1+3 ;test result trap_ne 11ac : d0fe > bne * ;failed not equal (non zero) 11ae : 68 pla ;load status eor_flag 0 11af : 4930 > eor #0|fao ;invert expected flags + always on bits 11b1 : cd1f02 cmp fLDx+3 ;test flags trap_ne 11b4 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 11b6 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 11b8 : 48 > pha ;use stack to load status 11b9 : 28 > plp 11ba : ae1702 ldx abs1 11bd : 08 php ;test stores do not alter flags 11be : 8a txa 11bf : 49c3 eor #$c3 11c1 : aa tax 11c2 : 28 plp 11c3 : 860c stx zpt 11c5 : 08 php ;flags after load/store sequence 11c6 : 49c3 eor #$c3 11c8 : aa tax 11c9 : e413 cpx zp1 ;test result trap_ne 11cb : d0fe > bne * ;failed not equal (non zero) 11cd : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 11ce : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 11d0 : cd1c02 cmp fLDx ;test flags trap_ne 11d3 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 11d5 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 11d7 : 48 > pha ;use stack to load status 11d8 : 28 > plp 11d9 : ae1802 ldx abs1+1 11dc : 08 php ;test stores do not alter flags 11dd : 8a txa 11de : 49c3 eor #$c3 11e0 : aa tax 11e1 : 28 plp 11e2 : 860d stx zpt+1 11e4 : 08 php ;flags after load/store sequence 11e5 : 49c3 eor #$c3 11e7 : aa tax 11e8 : e414 cpx zp1+1 ;test result trap_ne 11ea : d0fe > bne * ;failed not equal (non zero) 11ec : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 11ed : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 11ef : cd1d02 cmp fLDx+1 ;test flags trap_ne 11f2 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 11f4 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 11f6 : 48 > pha ;use stack to load status 11f7 : 28 > plp 11f8 : ae1902 ldx abs1+2 11fb : 08 php ;test stores do not alter flags 11fc : 8a txa 11fd : 49c3 eor #$c3 11ff : aa tax 1200 : 28 plp 1201 : 860e stx zpt+2 1203 : 08 php ;flags after load/store sequence 1204 : 49c3 eor #$c3 1206 : aa tax 1207 : e415 cpx zp1+2 ;test result trap_ne 1209 : d0fe > bne * ;failed not equal (non zero) 120b : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 120c : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 120e : cd1e02 cmp fLDx+2 ;test flags trap_ne 1211 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1213 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1215 : 48 > pha ;use stack to load status 1216 : 28 > plp 1217 : ae1a02 ldx abs1+3 121a : 08 php ;test stores do not alter flags 121b : 8a txa 121c : 49c3 eor #$c3 121e : aa tax 121f : 28 plp 1220 : 860f stx zpt+3 1222 : 08 php ;flags after load/store sequence 1223 : 49c3 eor #$c3 1225 : aa tax 1226 : e416 cpx zp1+3 ;test result trap_ne 1228 : d0fe > bne * ;failed not equal (non zero) 122a : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 122b : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 122d : cd1f02 cmp fLDx+3 ;test flags trap_ne 1230 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1232 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1234 : 48 > pha ;use stack to load status 1235 : 28 > plp 1236 : a2c3 ldx #$c3 1238 : 08 php 1239 : ec1702 cpx abs1 ;test result trap_ne 123c : d0fe > bne * ;failed not equal (non zero) 123e : 68 pla ;load status eor_flag 0 123f : 4930 > eor #0|fao ;invert expected flags + always on bits 1241 : cd1c02 cmp fLDx ;test flags trap_ne 1244 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1246 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1248 : 48 > pha ;use stack to load status 1249 : 28 > plp 124a : a282 ldx #$82 124c : 08 php 124d : ec1802 cpx abs1+1 ;test result trap_ne 1250 : d0fe > bne * ;failed not equal (non zero) 1252 : 68 pla ;load status eor_flag 0 1253 : 4930 > eor #0|fao ;invert expected flags + always on bits 1255 : cd1d02 cmp fLDx+1 ;test flags trap_ne 1258 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 125a : a900 > lda #0 ;allow test to change I-flag (no mask) > 125c : 48 > pha ;use stack to load status 125d : 28 > plp 125e : a241 ldx #$41 1260 : 08 php 1261 : ec1902 cpx abs1+2 ;test result trap_ne 1264 : d0fe > bne * ;failed not equal (non zero) 1266 : 68 pla ;load status eor_flag 0 1267 : 4930 > eor #0|fao ;invert expected flags + always on bits 1269 : cd1e02 cmp fLDx+2 ;test flags trap_ne 126c : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 126e : a900 > lda #0 ;allow test to change I-flag (no mask) > 1270 : 48 > pha ;use stack to load status 1271 : 28 > plp 1272 : a200 ldx #0 1274 : 08 php 1275 : ec1a02 cpx abs1+3 ;test result trap_ne 1278 : d0fe > bne * ;failed not equal (non zero) 127a : 68 pla ;load status eor_flag 0 127b : 4930 > eor #0|fao ;invert expected flags + always on bits 127d : cd1f02 cmp fLDx+3 ;test flags trap_ne 1280 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1282 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1284 : 48 > pha ;use stack to load status 1285 : 28 > plp 1286 : a2c3 ldx #$c3 1288 : 08 php 1289 : ec1702 cpx abs1 ;test result trap_ne 128c : d0fe > bne * ;failed not equal (non zero) 128e : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 128f : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1291 : cd1c02 cmp fLDx ;test flags trap_ne 1294 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1296 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1298 : 48 > pha ;use stack to load status 1299 : 28 > plp 129a : a282 ldx #$82 129c : 08 php 129d : ec1802 cpx abs1+1 ;test result trap_ne 12a0 : d0fe > bne * ;failed not equal (non zero) 12a2 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 12a3 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 12a5 : cd1d02 cmp fLDx+1 ;test flags trap_ne 12a8 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 12aa : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 12ac : 48 > pha ;use stack to load status 12ad : 28 > plp 12ae : a241 ldx #$41 12b0 : 08 php 12b1 : ec1902 cpx abs1+2 ;test result trap_ne 12b4 : d0fe > bne * ;failed not equal (non zero) 12b6 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 12b7 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 12b9 : cd1e02 cmp fLDx+2 ;test flags trap_ne 12bc : d0fe > bne * ;failed not equal (non zero) 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 : a200 ldx #0 12c4 : 08 php 12c5 : ec1a02 cpx abs1+3 ;test result trap_ne 12c8 : d0fe > bne * ;failed not equal (non zero) 12ca : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 12cb : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 12cd : cd1f02 cmp fLDx+3 ;test flags trap_ne 12d0 : d0fe > bne * ;failed not equal (non zero) 12d2 : a200 ldx #0 12d4 : a50c lda zpt 12d6 : 49c3 eor #$c3 12d8 : c513 cmp zp1 trap_ne ;store to zp data 12da : d0fe > bne * ;failed not equal (non zero) 12dc : 860c stx zpt ;clear 12de : ad0302 lda abst 12e1 : 49c3 eor #$c3 12e3 : cd1702 cmp abs1 trap_ne ;store to abs data 12e6 : d0fe > bne * ;failed not equal (non zero) 12e8 : 8e0302 stx abst ;clear 12eb : a50d lda zpt+1 12ed : 49c3 eor #$c3 12ef : c514 cmp zp1+1 trap_ne ;store to zp data 12f1 : d0fe > bne * ;failed not equal (non zero) 12f3 : 860d stx zpt+1 ;clear 12f5 : ad0402 lda abst+1 12f8 : 49c3 eor #$c3 12fa : cd1802 cmp abs1+1 trap_ne ;store to abs data 12fd : d0fe > bne * ;failed not equal (non zero) 12ff : 8e0402 stx abst+1 ;clear 1302 : a50e lda zpt+2 1304 : 49c3 eor #$c3 1306 : c515 cmp zp1+2 trap_ne ;store to zp data 1308 : d0fe > bne * ;failed not equal (non zero) 130a : 860e stx zpt+2 ;clear 130c : ad0502 lda abst+2 130f : 49c3 eor #$c3 1311 : cd1902 cmp abs1+2 trap_ne ;store to abs data 1314 : d0fe > bne * ;failed not equal (non zero) 1316 : 8e0502 stx abst+2 ;clear 1319 : a50f lda zpt+3 131b : 49c3 eor #$c3 131d : c516 cmp zp1+3 trap_ne ;store to zp data 131f : d0fe > bne * ;failed not equal (non zero) 1321 : 860f stx zpt+3 ;clear 1323 : ad0602 lda abst+3 1326 : 49c3 eor #$c3 1328 : cd1a02 cmp abs1+3 trap_ne ;store to abs data 132b : d0fe > bne * ;failed not equal (non zero) 132d : 8e0602 stx abst+3 ;clear next_test 1330 : ad0002 > lda test_case ;previous test 1333 : c913 > cmp #test_num > trap_ne ;test is out of sequence 1335 : d0fe > bne * ;failed not equal (non zero) > 0014 = >test_num = test_num + 1 1337 : a914 > lda #test_num ;*** next tests' number 1339 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; LDY / STY - zp / abs / # set_stat 0 > load_flag 0 133c : a900 > lda #0 ;allow test to change I-flag (no mask) > 133e : 48 > pha ;use stack to load status 133f : 28 > plp 1340 : a413 ldy zp1 1342 : 08 php ;test stores do not alter flags 1343 : 98 tya 1344 : 49c3 eor #$c3 1346 : a8 tay 1347 : 28 plp 1348 : 8c0302 sty abst 134b : 08 php ;flags after load/store sequence 134c : 49c3 eor #$c3 134e : a8 tay 134f : c0c3 cpy #$c3 ;test result trap_ne 1351 : d0fe > bne * ;failed not equal (non zero) 1353 : 68 pla ;load status eor_flag 0 1354 : 4930 > eor #0|fao ;invert expected flags + always on bits 1356 : cd1c02 cmp fLDx ;test flags trap_ne 1359 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 135b : a900 > lda #0 ;allow test to change I-flag (no mask) > 135d : 48 > pha ;use stack to load status 135e : 28 > plp 135f : a414 ldy zp1+1 1361 : 08 php ;test stores do not alter flags 1362 : 98 tya 1363 : 49c3 eor #$c3 1365 : a8 tay 1366 : 28 plp 1367 : 8c0402 sty abst+1 136a : 08 php ;flags after load/store sequence 136b : 49c3 eor #$c3 136d : a8 tay 136e : c082 cpy #$82 ;test result trap_ne 1370 : d0fe > bne * ;failed not equal (non zero) 1372 : 68 pla ;load status eor_flag 0 1373 : 4930 > eor #0|fao ;invert expected flags + always on bits 1375 : cd1d02 cmp fLDx+1 ;test flags trap_ne 1378 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 137a : a900 > lda #0 ;allow test to change I-flag (no mask) > 137c : 48 > pha ;use stack to load status 137d : 28 > plp 137e : a415 ldy zp1+2 1380 : 08 php ;test stores do not alter flags 1381 : 98 tya 1382 : 49c3 eor #$c3 1384 : a8 tay 1385 : 28 plp 1386 : 8c0502 sty abst+2 1389 : 08 php ;flags after load/store sequence 138a : 49c3 eor #$c3 138c : a8 tay 138d : c041 cpy #$41 ;test result trap_ne 138f : d0fe > bne * ;failed not equal (non zero) 1391 : 68 pla ;load status eor_flag 0 1392 : 4930 > eor #0|fao ;invert expected flags + always on bits 1394 : cd1e02 cmp fLDx+2 ;test flags trap_ne 1397 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1399 : a900 > lda #0 ;allow test to change I-flag (no mask) > 139b : 48 > pha ;use stack to load status 139c : 28 > plp 139d : a416 ldy zp1+3 139f : 08 php ;test stores do not alter flags 13a0 : 98 tya 13a1 : 49c3 eor #$c3 13a3 : a8 tay 13a4 : 28 plp 13a5 : 8c0602 sty abst+3 13a8 : 08 php ;flags after load/store sequence 13a9 : 49c3 eor #$c3 13ab : a8 tay 13ac : c000 cpy #0 ;test result trap_ne 13ae : d0fe > bne * ;failed not equal (non zero) 13b0 : 68 pla ;load status eor_flag 0 13b1 : 4930 > eor #0|fao ;invert expected flags + always on bits 13b3 : cd1f02 cmp fLDx+3 ;test flags trap_ne 13b6 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 13b8 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 13ba : 48 > pha ;use stack to load status 13bb : 28 > plp 13bc : a413 ldy zp1 13be : 08 php ;test stores do not alter flags 13bf : 98 tya 13c0 : 49c3 eor #$c3 13c2 : a8 tay 13c3 : 28 plp 13c4 : 8c0302 sty abst 13c7 : 08 php ;flags after load/store sequence 13c8 : 49c3 eor #$c3 13ca : a8 tay 13cb : c0c3 cpy #$c3 ;test result trap_ne 13cd : d0fe > bne * ;failed not equal (non zero) 13cf : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 13d0 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 13d2 : cd1c02 cmp fLDx ;test flags trap_ne 13d5 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 13d7 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 13d9 : 48 > pha ;use stack to load status 13da : 28 > plp 13db : a414 ldy zp1+1 13dd : 08 php ;test stores do not alter flags 13de : 98 tya 13df : 49c3 eor #$c3 13e1 : a8 tay 13e2 : 28 plp 13e3 : 8c0402 sty abst+1 13e6 : 08 php ;flags after load/store sequence 13e7 : 49c3 eor #$c3 13e9 : a8 tay 13ea : c082 cpy #$82 ;test result trap_ne 13ec : d0fe > bne * ;failed not equal (non zero) 13ee : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 13ef : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 13f1 : cd1d02 cmp fLDx+1 ;test flags trap_ne 13f4 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 13f6 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 13f8 : 48 > pha ;use stack to load status 13f9 : 28 > plp 13fa : a415 ldy zp1+2 13fc : 08 php ;test stores do not alter flags 13fd : 98 tya 13fe : 49c3 eor #$c3 1400 : a8 tay 1401 : 28 plp 1402 : 8c0502 sty abst+2 1405 : 08 php ;flags after load/store sequence 1406 : 49c3 eor #$c3 1408 : a8 tay 1409 : c041 cpy #$41 ;test result trap_ne 140b : d0fe > bne * ;failed not equal (non zero) 140d : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 140e : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1410 : cd1e02 cmp fLDx+2 ;test flags trap_ne 1413 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1415 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1417 : 48 > pha ;use stack to load status 1418 : 28 > plp 1419 : a416 ldy zp1+3 141b : 08 php ;test stores do not alter flags 141c : 98 tya 141d : 49c3 eor #$c3 141f : a8 tay 1420 : 28 plp 1421 : 8c0602 sty abst+3 1424 : 08 php ;flags after load/store sequence 1425 : 49c3 eor #$c3 1427 : a8 tay 1428 : c000 cpy #0 ;test result trap_ne 142a : d0fe > bne * ;failed not equal (non zero) 142c : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 142d : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 142f : cd1f02 cmp fLDx+3 ;test flags trap_ne 1432 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1434 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1436 : 48 > pha ;use stack to load status 1437 : 28 > plp 1438 : ac1702 ldy abs1 143b : 08 php ;test stores do not alter flags 143c : 98 tya 143d : 49c3 eor #$c3 143f : a8 tay 1440 : 28 plp 1441 : 840c sty zpt 1443 : 08 php ;flags after load/store sequence 1444 : 49c3 eor #$c3 1446 : a8 tay 1447 : c413 cpy zp1 ;test result trap_ne 1449 : d0fe > bne * ;failed not equal (non zero) 144b : 68 pla ;load status eor_flag 0 144c : 4930 > eor #0|fao ;invert expected flags + always on bits 144e : cd1c02 cmp fLDx ;test flags trap_ne 1451 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1453 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1455 : 48 > pha ;use stack to load status 1456 : 28 > plp 1457 : ac1802 ldy abs1+1 145a : 08 php ;test stores do not alter flags 145b : 98 tya 145c : 49c3 eor #$c3 145e : a8 tay 145f : 28 plp 1460 : 840d sty zpt+1 1462 : 08 php ;flags after load/store sequence 1463 : 49c3 eor #$c3 1465 : a8 tay 1466 : c414 cpy zp1+1 ;test result trap_ne 1468 : d0fe > bne * ;failed not equal (non zero) 146a : 68 pla ;load status eor_flag 0 146b : 4930 > eor #0|fao ;invert expected flags + always on bits 146d : cd1d02 cmp fLDx+1 ;test flags trap_ne 1470 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1472 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1474 : 48 > pha ;use stack to load status 1475 : 28 > plp 1476 : ac1902 ldy abs1+2 1479 : 08 php ;test stores do not alter flags 147a : 98 tya 147b : 49c3 eor #$c3 147d : a8 tay 147e : 28 plp 147f : 840e sty zpt+2 1481 : 08 php ;flags after load/store sequence 1482 : 49c3 eor #$c3 1484 : a8 tay 1485 : c415 cpy zp1+2 ;test result trap_ne 1487 : d0fe > bne * ;failed not equal (non zero) 1489 : 68 pla ;load status eor_flag 0 148a : 4930 > eor #0|fao ;invert expected flags + always on bits 148c : cd1e02 cmp fLDx+2 ;test flags trap_ne 148f : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1491 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1493 : 48 > pha ;use stack to load status 1494 : 28 > plp 1495 : ac1a02 ldy abs1+3 1498 : 08 php ;test stores do not alter flags 1499 : 98 tya 149a : 49c3 eor #$c3 149c : a8 tay 149d : 28 plp 149e : 840f sty zpt+3 14a0 : 08 php ;flags after load/store sequence 14a1 : 49c3 eor #$c3 14a3 : a8 tay 14a4 : c416 cpy zp1+3 ;test result trap_ne 14a6 : d0fe > bne * ;failed not equal (non zero) 14a8 : 68 pla ;load status eor_flag 0 14a9 : 4930 > eor #0|fao ;invert expected flags + always on bits 14ab : cd1f02 cmp fLDx+3 ;test flags trap_ne 14ae : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 14b0 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 14b2 : 48 > pha ;use stack to load status 14b3 : 28 > plp 14b4 : ac1702 ldy abs1 14b7 : 08 php ;test stores do not alter flags 14b8 : 98 tya 14b9 : 49c3 eor #$c3 14bb : a8 tay 14bc : 28 plp 14bd : 840c sty zpt 14bf : 08 php ;flags after load/store sequence 14c0 : 49c3 eor #$c3 14c2 : a8 tay 14c3 : c513 cmp zp1 ;test result trap_ne 14c5 : d0fe > bne * ;failed not equal (non zero) 14c7 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 14c8 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 14ca : cd1c02 cmp fLDx ;test flags trap_ne 14cd : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 14cf : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 14d1 : 48 > pha ;use stack to load status 14d2 : 28 > plp 14d3 : ac1802 ldy abs1+1 14d6 : 08 php ;test stores do not alter flags 14d7 : 98 tya 14d8 : 49c3 eor #$c3 14da : a8 tay 14db : 28 plp 14dc : 840d sty zpt+1 14de : 08 php ;flags after load/store sequence 14df : 49c3 eor #$c3 14e1 : a8 tay 14e2 : c514 cmp zp1+1 ;test result trap_ne 14e4 : d0fe > bne * ;failed not equal (non zero) 14e6 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 14e7 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 14e9 : cd1d02 cmp fLDx+1 ;test flags trap_ne 14ec : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 14ee : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 14f0 : 48 > pha ;use stack to load status 14f1 : 28 > plp 14f2 : ac1902 ldy abs1+2 14f5 : 08 php ;test stores do not alter flags 14f6 : 98 tya 14f7 : 49c3 eor #$c3 14f9 : a8 tay 14fa : 28 plp 14fb : 840e sty zpt+2 14fd : 08 php ;flags after load/store sequence 14fe : 49c3 eor #$c3 1500 : a8 tay 1501 : c515 cmp zp1+2 ;test result trap_ne 1503 : d0fe > bne * ;failed not equal (non zero) 1505 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1506 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1508 : cd1e02 cmp fLDx+2 ;test flags trap_ne 150b : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 150d : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 150f : 48 > pha ;use stack to load status 1510 : 28 > plp 1511 : ac1a02 ldy abs1+3 1514 : 08 php ;test stores do not alter flags 1515 : 98 tya 1516 : 49c3 eor #$c3 1518 : a8 tay 1519 : 28 plp 151a : 840f sty zpt+3 151c : 08 php ;flags after load/store sequence 151d : 49c3 eor #$c3 151f : a8 tay 1520 : c516 cmp zp1+3 ;test result trap_ne 1522 : d0fe > bne * ;failed not equal (non zero) 1524 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1525 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1527 : cd1f02 cmp fLDx+3 ;test flags trap_ne 152a : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 152c : a900 > lda #0 ;allow test to change I-flag (no mask) > 152e : 48 > pha ;use stack to load status 152f : 28 > plp 1530 : a0c3 ldy #$c3 1532 : 08 php 1533 : cc1702 cpy abs1 ;test result trap_ne 1536 : d0fe > bne * ;failed not equal (non zero) 1538 : 68 pla ;load status eor_flag 0 1539 : 4930 > eor #0|fao ;invert expected flags + always on bits 153b : cd1c02 cmp fLDx ;test flags trap_ne 153e : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1540 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1542 : 48 > pha ;use stack to load status 1543 : 28 > plp 1544 : a082 ldy #$82 1546 : 08 php 1547 : cc1802 cpy abs1+1 ;test result trap_ne 154a : d0fe > bne * ;failed not equal (non zero) 154c : 68 pla ;load status eor_flag 0 154d : 4930 > eor #0|fao ;invert expected flags + always on bits 154f : cd1d02 cmp fLDx+1 ;test flags trap_ne 1552 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1554 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1556 : 48 > pha ;use stack to load status 1557 : 28 > plp 1558 : a041 ldy #$41 155a : 08 php 155b : cc1902 cpy abs1+2 ;test result trap_ne 155e : d0fe > bne * ;failed not equal (non zero) 1560 : 68 pla ;load status eor_flag 0 1561 : 4930 > eor #0|fao ;invert expected flags + always on bits 1563 : cd1e02 cmp fLDx+2 ;test flags trap_ne 1566 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1568 : a900 > lda #0 ;allow test to change I-flag (no mask) > 156a : 48 > pha ;use stack to load status 156b : 28 > plp 156c : a000 ldy #0 156e : 08 php 156f : cc1a02 cpy abs1+3 ;test result trap_ne 1572 : d0fe > bne * ;failed not equal (non zero) 1574 : 68 pla ;load status eor_flag 0 1575 : 4930 > eor #0|fao ;invert expected flags + always on bits 1577 : cd1f02 cmp fLDx+3 ;test flags trap_ne 157a : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 157c : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 157e : 48 > pha ;use stack to load status 157f : 28 > plp 1580 : a0c3 ldy #$c3 1582 : 08 php 1583 : cc1702 cpy abs1 ;test result trap_ne 1586 : d0fe > bne * ;failed not equal (non zero) 1588 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1589 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 158b : cd1c02 cmp fLDx ;test flags trap_ne 158e : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1590 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1592 : 48 > pha ;use stack to load status 1593 : 28 > plp 1594 : a082 ldy #$82 1596 : 08 php 1597 : cc1802 cpy abs1+1 ;test result trap_ne 159a : d0fe > bne * ;failed not equal (non zero) 159c : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 159d : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 159f : cd1d02 cmp fLDx+1 ;test flags trap_ne 15a2 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 15a4 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 15a6 : 48 > pha ;use stack to load status 15a7 : 28 > plp 15a8 : a041 ldy #$41 15aa : 08 php 15ab : cc1902 cpy abs1+2 ;test result trap_ne 15ae : d0fe > bne * ;failed not equal (non zero) 15b0 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 15b1 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 15b3 : cd1e02 cmp fLDx+2 ;test flags trap_ne 15b6 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 15b8 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 15ba : 48 > pha ;use stack to load status 15bb : 28 > plp 15bc : a000 ldy #0 15be : 08 php 15bf : cc1a02 cpy abs1+3 ;test result trap_ne 15c2 : d0fe > bne * ;failed not equal (non zero) 15c4 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 15c5 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 15c7 : cd1f02 cmp fLDx+3 ;test flags trap_ne 15ca : d0fe > bne * ;failed not equal (non zero) 15cc : a000 ldy #0 15ce : a50c lda zpt 15d0 : 49c3 eor #$c3 15d2 : c513 cmp zp1 trap_ne ;store to zp data 15d4 : d0fe > bne * ;failed not equal (non zero) 15d6 : 840c sty zpt ;clear 15d8 : ad0302 lda abst 15db : 49c3 eor #$c3 15dd : cd1702 cmp abs1 trap_ne ;store to abs data 15e0 : d0fe > bne * ;failed not equal (non zero) 15e2 : 8c0302 sty abst ;clear 15e5 : a50d lda zpt+1 15e7 : 49c3 eor #$c3 15e9 : c514 cmp zp1+1 trap_ne ;store to zp+1 data 15eb : d0fe > bne * ;failed not equal (non zero) 15ed : 840d sty zpt+1 ;clear 15ef : ad0402 lda abst+1 15f2 : 49c3 eor #$c3 15f4 : cd1802 cmp abs1+1 trap_ne ;store to abs+1 data 15f7 : d0fe > bne * ;failed not equal (non zero) 15f9 : 8c0402 sty abst+1 ;clear 15fc : a50e lda zpt+2 15fe : 49c3 eor #$c3 1600 : c515 cmp zp1+2 trap_ne ;store to zp+2 data 1602 : d0fe > bne * ;failed not equal (non zero) 1604 : 840e sty zpt+2 ;clear 1606 : ad0502 lda abst+2 1609 : 49c3 eor #$c3 160b : cd1902 cmp abs1+2 trap_ne ;store to abs+2 data 160e : d0fe > bne * ;failed not equal (non zero) 1610 : 8c0502 sty abst+2 ;clear 1613 : a50f lda zpt+3 1615 : 49c3 eor #$c3 1617 : c516 cmp zp1+3 trap_ne ;store to zp+3 data 1619 : d0fe > bne * ;failed not equal (non zero) 161b : 840f sty zpt+3 ;clear 161d : ad0602 lda abst+3 1620 : 49c3 eor #$c3 1622 : cd1a02 cmp abs1+3 trap_ne ;store to abs+3 data 1625 : d0fe > bne * ;failed not equal (non zero) 1627 : 8c0602 sty abst+3 ;clear next_test 162a : ad0002 > lda test_case ;previous test 162d : c914 > cmp #test_num > trap_ne ;test is out of sequence 162f : d0fe > bne * ;failed not equal (non zero) > 0015 = >test_num = test_num + 1 1631 : a915 > lda #test_num ;*** next tests' number 1633 : 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 1636 : a203 ldx #3 1638 : tldax set_stat 0 > load_flag 0 1638 : a900 > lda #0 ;allow test to change I-flag (no mask) > 163a : 48 > pha ;use stack to load status 163b : 28 > plp 163c : b513 lda zp1,x 163e : 08 php ;test stores do not alter flags 163f : 49c3 eor #$c3 1641 : 28 plp 1642 : 9d0302 sta abst,x 1645 : 08 php ;flags after load/store sequence 1646 : 49c3 eor #$c3 1648 : dd1702 cmp abs1,x ;test result trap_ne 164b : d0fe > bne * ;failed not equal (non zero) 164d : 68 pla ;load status eor_flag 0 164e : 4930 > eor #0|fao ;invert expected flags + always on bits 1650 : dd1c02 cmp fLDx,x ;test flags trap_ne 1653 : d0fe > bne * ;failed not equal (non zero) 1655 : ca dex 1656 : 10e0 bpl tldax 1658 : a203 ldx #3 165a : tldax1 set_stat $ff > load_flag $ff 165a : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 165c : 48 > pha ;use stack to load status 165d : 28 > plp 165e : b513 lda zp1,x 1660 : 08 php ;test stores do not alter flags 1661 : 49c3 eor #$c3 1663 : 28 plp 1664 : 9d0302 sta abst,x 1667 : 08 php ;flags after load/store sequence 1668 : 49c3 eor #$c3 166a : dd1702 cmp abs1,x ;test result trap_ne 166d : d0fe > bne * ;failed not equal (non zero) 166f : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1670 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1672 : dd1c02 cmp fLDx,x ;test flags trap_ne 1675 : d0fe > bne * ;failed not equal (non zero) 1677 : ca dex 1678 : 10e0 bpl tldax1 167a : a203 ldx #3 167c : tldax2 set_stat 0 > load_flag 0 167c : a900 > lda #0 ;allow test to change I-flag (no mask) > 167e : 48 > pha ;use stack to load status 167f : 28 > plp 1680 : bd1702 lda abs1,x 1683 : 08 php ;test stores do not alter flags 1684 : 49c3 eor #$c3 1686 : 28 plp 1687 : 950c sta zpt,x 1689 : 08 php ;flags after load/store sequence 168a : 49c3 eor #$c3 168c : d513 cmp zp1,x ;test result trap_ne 168e : d0fe > bne * ;failed not equal (non zero) 1690 : 68 pla ;load status eor_flag 0 1691 : 4930 > eor #0|fao ;invert expected flags + always on bits 1693 : dd1c02 cmp fLDx,x ;test flags trap_ne 1696 : d0fe > bne * ;failed not equal (non zero) 1698 : ca dex 1699 : 10e1 bpl tldax2 169b : a203 ldx #3 169d : tldax3 set_stat $ff > load_flag $ff 169d : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 169f : 48 > pha ;use stack to load status 16a0 : 28 > plp 16a1 : bd1702 lda abs1,x 16a4 : 08 php ;test stores do not alter flags 16a5 : 49c3 eor #$c3 16a7 : 28 plp 16a8 : 950c sta zpt,x 16aa : 08 php ;flags after load/store sequence 16ab : 49c3 eor #$c3 16ad : d513 cmp zp1,x ;test result trap_ne 16af : d0fe > bne * ;failed not equal (non zero) 16b1 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 16b2 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 16b4 : dd1c02 cmp fLDx,x ;test flags trap_ne 16b7 : d0fe > bne * ;failed not equal (non zero) 16b9 : ca dex 16ba : 10e1 bpl tldax3 16bc : a203 ldx #3 ;testing store result 16be : a000 ldy #0 16c0 : b50c tstax lda zpt,x 16c2 : 49c3 eor #$c3 16c4 : d513 cmp zp1,x trap_ne ;store to zp,x data 16c6 : d0fe > bne * ;failed not equal (non zero) 16c8 : 940c sty zpt,x ;clear 16ca : bd0302 lda abst,x 16cd : 49c3 eor #$c3 16cf : dd1702 cmp abs1,x trap_ne ;store to abs,x data 16d2 : d0fe > bne * ;failed not equal (non zero) 16d4 : 8a txa 16d5 : 9d0302 sta abst,x ;clear 16d8 : ca dex 16d9 : 10e5 bpl tstax next_test 16db : ad0002 > lda test_case ;previous test 16de : c915 > cmp #test_num > trap_ne ;test is out of sequence 16e0 : d0fe > bne * ;failed not equal (non zero) > 0016 = >test_num = test_num + 1 16e2 : a916 > lda #test_num ;*** next tests' number 16e4 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; LDA / STA - (zp),y / abs,y / (zp,x) 16e7 : a003 ldy #3 16e9 : tlday set_stat 0 > load_flag 0 16e9 : a900 > lda #0 ;allow test to change I-flag (no mask) > 16eb : 48 > pha ;use stack to load status 16ec : 28 > plp 16ed : b124 lda (ind1),y 16ef : 08 php ;test stores do not alter flags 16f0 : 49c3 eor #$c3 16f2 : 28 plp 16f3 : 990302 sta abst,y 16f6 : 08 php ;flags after load/store sequence 16f7 : 49c3 eor #$c3 16f9 : d91702 cmp abs1,y ;test result trap_ne 16fc : d0fe > bne * ;failed not equal (non zero) 16fe : 68 pla ;load status eor_flag 0 16ff : 4930 > eor #0|fao ;invert expected flags + always on bits 1701 : d91c02 cmp fLDx,y ;test flags trap_ne 1704 : d0fe > bne * ;failed not equal (non zero) 1706 : 88 dey 1707 : 10e0 bpl tlday 1709 : a003 ldy #3 170b : tlday1 set_stat $ff > load_flag $ff 170b : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 170d : 48 > pha ;use stack to load status 170e : 28 > plp 170f : b124 lda (ind1),y 1711 : 08 php ;test stores do not alter flags 1712 : 49c3 eor #$c3 1714 : 28 plp 1715 : 990302 sta abst,y 1718 : 08 php ;flags after load/store sequence 1719 : 49c3 eor #$c3 171b : d91702 cmp abs1,y ;test result trap_ne 171e : d0fe > bne * ;failed not equal (non zero) 1720 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1721 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1723 : d91c02 cmp fLDx,y ;test flags trap_ne 1726 : d0fe > bne * ;failed not equal (non zero) 1728 : 88 dey 1729 : 10e0 bpl tlday1 172b : a003 ldy #3 ;testing store result 172d : a200 ldx #0 172f : b90302 tstay lda abst,y 1732 : 49c3 eor #$c3 1734 : d91702 cmp abs1,y trap_ne ;store to abs data 1737 : d0fe > bne * ;failed not equal (non zero) 1739 : 8a txa 173a : 990302 sta abst,y ;clear 173d : 88 dey 173e : 10ef bpl tstay 1740 : a003 ldy #3 1742 : tlday2 set_stat 0 > load_flag 0 1742 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1744 : 48 > pha ;use stack to load status 1745 : 28 > plp 1746 : b91702 lda abs1,y 1749 : 08 php ;test stores do not alter flags 174a : 49c3 eor #$c3 174c : 28 plp 174d : 9130 sta (indt),y 174f : 08 php ;flags after load/store sequence 1750 : 49c3 eor #$c3 1752 : d124 cmp (ind1),y ;test result trap_ne 1754 : d0fe > bne * ;failed not equal (non zero) 1756 : 68 pla ;load status eor_flag 0 1757 : 4930 > eor #0|fao ;invert expected flags + always on bits 1759 : d91c02 cmp fLDx,y ;test flags trap_ne 175c : d0fe > bne * ;failed not equal (non zero) 175e : 88 dey 175f : 10e1 bpl tlday2 1761 : a003 ldy #3 1763 : tlday3 set_stat $ff > load_flag $ff 1763 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1765 : 48 > pha ;use stack to load status 1766 : 28 > plp 1767 : b91702 lda abs1,y 176a : 08 php ;test stores do not alter flags 176b : 49c3 eor #$c3 176d : 28 plp 176e : 9130 sta (indt),y 1770 : 08 php ;flags after load/store sequence 1771 : 49c3 eor #$c3 1773 : d124 cmp (ind1),y ;test result trap_ne 1775 : d0fe > bne * ;failed not equal (non zero) 1777 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1778 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 177a : d91c02 cmp fLDx,y ;test flags trap_ne 177d : d0fe > bne * ;failed not equal (non zero) 177f : 88 dey 1780 : 10e1 bpl tlday3 1782 : a003 ldy #3 ;testing store result 1784 : a200 ldx #0 1786 : b90302 tstay1 lda abst,y 1789 : 49c3 eor #$c3 178b : d91702 cmp abs1,y trap_ne ;store to abs data 178e : d0fe > bne * ;failed not equal (non zero) 1790 : 8a txa 1791 : 990302 sta abst,y ;clear 1794 : 88 dey 1795 : 10ef bpl tstay1 1797 : a206 ldx #6 1799 : a003 ldy #3 179b : tldax4 set_stat 0 > load_flag 0 179b : a900 > lda #0 ;allow test to change I-flag (no mask) > 179d : 48 > pha ;use stack to load status 179e : 28 > plp 179f : a124 lda (ind1,x) 17a1 : 08 php ;test stores do not alter flags 17a2 : 49c3 eor #$c3 17a4 : 28 plp 17a5 : 8130 sta (indt,x) 17a7 : 08 php ;flags after load/store sequence 17a8 : 49c3 eor #$c3 17aa : d91702 cmp abs1,y ;test result trap_ne 17ad : d0fe > bne * ;failed not equal (non zero) 17af : 68 pla ;load status eor_flag 0 17b0 : 4930 > eor #0|fao ;invert expected flags + always on bits 17b2 : d91c02 cmp fLDx,y ;test flags trap_ne 17b5 : d0fe > bne * ;failed not equal (non zero) 17b7 : ca dex 17b8 : ca dex 17b9 : 88 dey 17ba : 10df bpl tldax4 17bc : a206 ldx #6 17be : a003 ldy #3 17c0 : tldax5 set_stat $ff > load_flag $ff 17c0 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 17c2 : 48 > pha ;use stack to load status 17c3 : 28 > plp 17c4 : a124 lda (ind1,x) 17c6 : 08 php ;test stores do not alter flags 17c7 : 49c3 eor #$c3 17c9 : 28 plp 17ca : 8130 sta (indt,x) 17cc : 08 php ;flags after load/store sequence 17cd : 49c3 eor #$c3 17cf : d91702 cmp abs1,y ;test result trap_ne 17d2 : d0fe > bne * ;failed not equal (non zero) 17d4 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 17d5 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 17d7 : d91c02 cmp fLDx,y ;test flags trap_ne 17da : d0fe > bne * ;failed not equal (non zero) 17dc : ca dex 17dd : ca dex 17de : 88 dey 17df : 10df bpl tldax5 17e1 : a003 ldy #3 ;testing store result 17e3 : a200 ldx #0 17e5 : b90302 tstay2 lda abst,y 17e8 : 49c3 eor #$c3 17ea : d91702 cmp abs1,y trap_ne ;store to abs data 17ed : d0fe > bne * ;failed not equal (non zero) 17ef : 8a txa 17f0 : 990302 sta abst,y ;clear 17f3 : 88 dey 17f4 : 10ef bpl tstay2 next_test 17f6 : ad0002 > lda test_case ;previous test 17f9 : c916 > cmp #test_num > trap_ne ;test is out of sequence 17fb : d0fe > bne * ;failed not equal (non zero) > 0017 = >test_num = test_num + 1 17fd : a917 > lda #test_num ;*** next tests' number 17ff : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; indexed wraparound test (only zp should wrap) 1802 : a2fd ldx #3+$fa 1804 : b519 tldax6 lda zp1-$fa&$ff,x ;wrap on indexed zp 1806 : 9d0901 sta abst-$fa,x ;no STX abs,x! 1809 : ca dex 180a : e0fa cpx #$fa 180c : b0f6 bcs tldax6 180e : a2fd ldx #3+$fa 1810 : bd1d01 tldax7 lda abs1-$fa,x ;no wrap on indexed abs 1813 : 9512 sta zpt-$fa&$ff,x 1815 : ca dex 1816 : e0fa cpx #$fa 1818 : b0f6 bcs tldax7 181a : a203 ldx #3 ;testing wraparound result 181c : a000 ldy #0 181e : b50c tstax1 lda zpt,x 1820 : d513 cmp zp1,x trap_ne ;store to zp,x data 1822 : d0fe > bne * ;failed not equal (non zero) 1824 : 940c sty zpt,x ;clear 1826 : bd0302 lda abst,x 1829 : dd1702 cmp abs1,x trap_ne ;store to abs,x data 182c : d0fe > bne * ;failed not equal (non zero) 182e : 8a txa 182f : 9d0302 sta abst,x ;clear 1832 : ca dex 1833 : 10e9 bpl tstax1 1835 : a0fb ldy #3+$f8 1837 : a2fe ldx #6+$f8 1839 : a12c tlday4 lda (ind1-$f8&$ff,x) ;wrap on indexed zp indirect 183b : 990b01 sta abst-$f8,y 183e : ca dex 183f : ca dex 1840 : 88 dey 1841 : c0f8 cpy #$f8 1843 : b0f4 bcs tlday4 1845 : a003 ldy #3 ;testing wraparound result 1847 : a200 ldx #0 1849 : b90302 tstay4 lda abst,y 184c : d91702 cmp abs1,y trap_ne ;store to abs data 184f : d0fe > bne * ;failed not equal (non zero) 1851 : 8a txa 1852 : 990302 sta abst,y ;clear 1855 : 88 dey 1856 : 10f1 bpl tstay4 1858 : a0fb ldy #3+$f8 185a : b91f01 tlday5 lda abs1-$f8,y ;no wrap on indexed abs 185d : 9138 sta (inwt),y 185f : 88 dey 1860 : c0f8 cpy #$f8 1862 : b0f6 bcs tlday5 1864 : a003 ldy #3 ;testing wraparound result 1866 : a200 ldx #0 1868 : b90302 tstay5 lda abst,y 186b : d91702 cmp abs1,y trap_ne ;store to abs data 186e : d0fe > bne * ;failed not equal (non zero) 1870 : 8a txa 1871 : 990302 sta abst,y ;clear 1874 : 88 dey 1875 : 10f1 bpl tstay5 1877 : a0fb ldy #3+$f8 1879 : a2fe ldx #6+$f8 187b : b12e tlday6 lda (inw1),y ;no wrap on zp indirect indexed 187d : 8138 sta (indt-$f8&$ff,x) 187f : ca dex 1880 : ca dex 1881 : 88 dey 1882 : c0f8 cpy #$f8 1884 : b0f5 bcs tlday6 1886 : a003 ldy #3 ;testing wraparound result 1888 : a200 ldx #0 188a : b90302 tstay6 lda abst,y 188d : d91702 cmp abs1,y trap_ne ;store to abs data 1890 : d0fe > bne * ;failed not equal (non zero) 1892 : 8a txa 1893 : 990302 sta abst,y ;clear 1896 : 88 dey 1897 : 10f1 bpl tstay6 next_test 1899 : ad0002 > lda test_case ;previous test 189c : c917 > cmp #test_num > trap_ne ;test is out of sequence 189e : d0fe > bne * ;failed not equal (non zero) > 0018 = >test_num = test_num + 1 18a0 : a918 > lda #test_num ;*** next tests' number 18a2 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; LDA / STA - zp / abs / # set_stat 0 > load_flag 0 18a5 : a900 > lda #0 ;allow test to change I-flag (no mask) > 18a7 : 48 > pha ;use stack to load status 18a8 : 28 > plp 18a9 : a513 lda zp1 18ab : 08 php ;test stores do not alter flags 18ac : 49c3 eor #$c3 18ae : 28 plp 18af : 8d0302 sta abst 18b2 : 08 php ;flags after load/store sequence 18b3 : 49c3 eor #$c3 18b5 : c9c3 cmp #$c3 ;test result trap_ne 18b7 : d0fe > bne * ;failed not equal (non zero) 18b9 : 68 pla ;load status eor_flag 0 18ba : 4930 > eor #0|fao ;invert expected flags + always on bits 18bc : cd1c02 cmp fLDx ;test flags trap_ne 18bf : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 18c1 : a900 > lda #0 ;allow test to change I-flag (no mask) > 18c3 : 48 > pha ;use stack to load status 18c4 : 28 > plp 18c5 : a514 lda zp1+1 18c7 : 08 php ;test stores do not alter flags 18c8 : 49c3 eor #$c3 18ca : 28 plp 18cb : 8d0402 sta abst+1 18ce : 08 php ;flags after load/store sequence 18cf : 49c3 eor #$c3 18d1 : c982 cmp #$82 ;test result trap_ne 18d3 : d0fe > bne * ;failed not equal (non zero) 18d5 : 68 pla ;load status eor_flag 0 18d6 : 4930 > eor #0|fao ;invert expected flags + always on bits 18d8 : cd1d02 cmp fLDx+1 ;test flags trap_ne 18db : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 18dd : a900 > lda #0 ;allow test to change I-flag (no mask) > 18df : 48 > pha ;use stack to load status 18e0 : 28 > plp 18e1 : a515 lda zp1+2 18e3 : 08 php ;test stores do not alter flags 18e4 : 49c3 eor #$c3 18e6 : 28 plp 18e7 : 8d0502 sta abst+2 18ea : 08 php ;flags after load/store sequence 18eb : 49c3 eor #$c3 18ed : c941 cmp #$41 ;test result trap_ne 18ef : d0fe > bne * ;failed not equal (non zero) 18f1 : 68 pla ;load status eor_flag 0 18f2 : 4930 > eor #0|fao ;invert expected flags + always on bits 18f4 : cd1e02 cmp fLDx+2 ;test flags trap_ne 18f7 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 18f9 : a900 > lda #0 ;allow test to change I-flag (no mask) > 18fb : 48 > pha ;use stack to load status 18fc : 28 > plp 18fd : a516 lda zp1+3 18ff : 08 php ;test stores do not alter flags 1900 : 49c3 eor #$c3 1902 : 28 plp 1903 : 8d0602 sta abst+3 1906 : 08 php ;flags after load/store sequence 1907 : 49c3 eor #$c3 1909 : c900 cmp #0 ;test result trap_ne 190b : d0fe > bne * ;failed not equal (non zero) 190d : 68 pla ;load status eor_flag 0 190e : 4930 > eor #0|fao ;invert expected flags + always on bits 1910 : cd1f02 cmp fLDx+3 ;test flags trap_ne 1913 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1915 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1917 : 48 > pha ;use stack to load status 1918 : 28 > plp 1919 : a513 lda zp1 191b : 08 php ;test stores do not alter flags 191c : 49c3 eor #$c3 191e : 28 plp 191f : 8d0302 sta abst 1922 : 08 php ;flags after load/store sequence 1923 : 49c3 eor #$c3 1925 : c9c3 cmp #$c3 ;test result trap_ne 1927 : d0fe > bne * ;failed not equal (non zero) 1929 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 192a : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 192c : cd1c02 cmp fLDx ;test flags trap_ne 192f : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1931 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1933 : 48 > pha ;use stack to load status 1934 : 28 > plp 1935 : a514 lda zp1+1 1937 : 08 php ;test stores do not alter flags 1938 : 49c3 eor #$c3 193a : 28 plp 193b : 8d0402 sta abst+1 193e : 08 php ;flags after load/store sequence 193f : 49c3 eor #$c3 1941 : c982 cmp #$82 ;test result trap_ne 1943 : d0fe > bne * ;failed not equal (non zero) 1945 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1946 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1948 : cd1d02 cmp fLDx+1 ;test flags trap_ne 194b : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 194d : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 194f : 48 > pha ;use stack to load status 1950 : 28 > plp 1951 : a515 lda zp1+2 1953 : 08 php ;test stores do not alter flags 1954 : 49c3 eor #$c3 1956 : 28 plp 1957 : 8d0502 sta abst+2 195a : 08 php ;flags after load/store sequence 195b : 49c3 eor #$c3 195d : c941 cmp #$41 ;test result trap_ne 195f : d0fe > bne * ;failed not equal (non zero) 1961 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1962 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1964 : cd1e02 cmp fLDx+2 ;test flags trap_ne 1967 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1969 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 196b : 48 > pha ;use stack to load status 196c : 28 > plp 196d : a516 lda zp1+3 196f : 08 php ;test stores do not alter flags 1970 : 49c3 eor #$c3 1972 : 28 plp 1973 : 8d0602 sta abst+3 1976 : 08 php ;flags after load/store sequence 1977 : 49c3 eor #$c3 1979 : c900 cmp #0 ;test result trap_ne 197b : d0fe > bne * ;failed not equal (non zero) 197d : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 197e : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1980 : cd1f02 cmp fLDx+3 ;test flags trap_ne 1983 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1985 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1987 : 48 > pha ;use stack to load status 1988 : 28 > plp 1989 : ad1702 lda abs1 198c : 08 php ;test stores do not alter flags 198d : 49c3 eor #$c3 198f : 28 plp 1990 : 850c sta zpt 1992 : 08 php ;flags after load/store sequence 1993 : 49c3 eor #$c3 1995 : c513 cmp zp1 ;test result trap_ne 1997 : d0fe > bne * ;failed not equal (non zero) 1999 : 68 pla ;load status eor_flag 0 199a : 4930 > eor #0|fao ;invert expected flags + always on bits 199c : cd1c02 cmp fLDx ;test flags trap_ne 199f : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 19a1 : a900 > lda #0 ;allow test to change I-flag (no mask) > 19a3 : 48 > pha ;use stack to load status 19a4 : 28 > plp 19a5 : ad1802 lda abs1+1 19a8 : 08 php ;test stores do not alter flags 19a9 : 49c3 eor #$c3 19ab : 28 plp 19ac : 850d sta zpt+1 19ae : 08 php ;flags after load/store sequence 19af : 49c3 eor #$c3 19b1 : c514 cmp zp1+1 ;test result trap_ne 19b3 : d0fe > bne * ;failed not equal (non zero) 19b5 : 68 pla ;load status eor_flag 0 19b6 : 4930 > eor #0|fao ;invert expected flags + always on bits 19b8 : cd1d02 cmp fLDx+1 ;test flags trap_ne 19bb : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 19bd : a900 > lda #0 ;allow test to change I-flag (no mask) > 19bf : 48 > pha ;use stack to load status 19c0 : 28 > plp 19c1 : ad1902 lda abs1+2 19c4 : 08 php ;test stores do not alter flags 19c5 : 49c3 eor #$c3 19c7 : 28 plp 19c8 : 850e sta zpt+2 19ca : 08 php ;flags after load/store sequence 19cb : 49c3 eor #$c3 19cd : c515 cmp zp1+2 ;test result trap_ne 19cf : d0fe > bne * ;failed not equal (non zero) 19d1 : 68 pla ;load status eor_flag 0 19d2 : 4930 > eor #0|fao ;invert expected flags + always on bits 19d4 : cd1e02 cmp fLDx+2 ;test flags trap_ne 19d7 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 19d9 : a900 > lda #0 ;allow test to change I-flag (no mask) > 19db : 48 > pha ;use stack to load status 19dc : 28 > plp 19dd : ad1a02 lda abs1+3 19e0 : 08 php ;test stores do not alter flags 19e1 : 49c3 eor #$c3 19e3 : 28 plp 19e4 : 850f sta zpt+3 19e6 : 08 php ;flags after load/store sequence 19e7 : 49c3 eor #$c3 19e9 : c516 cmp zp1+3 ;test result trap_ne 19eb : d0fe > bne * ;failed not equal (non zero) 19ed : 68 pla ;load status eor_flag 0 19ee : 4930 > eor #0|fao ;invert expected flags + always on bits 19f0 : cd1f02 cmp fLDx+3 ;test flags trap_ne 19f3 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 19f5 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 19f7 : 48 > pha ;use stack to load status 19f8 : 28 > plp 19f9 : ad1702 lda abs1 19fc : 08 php ;test stores do not alter flags 19fd : 49c3 eor #$c3 19ff : 28 plp 1a00 : 850c sta zpt 1a02 : 08 php ;flags after load/store sequence 1a03 : 49c3 eor #$c3 1a05 : c513 cmp zp1 ;test result trap_ne 1a07 : d0fe > bne * ;failed not equal (non zero) 1a09 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1a0a : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1a0c : cd1c02 cmp fLDx ;test flags trap_ne 1a0f : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1a11 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1a13 : 48 > pha ;use stack to load status 1a14 : 28 > plp 1a15 : ad1802 lda abs1+1 1a18 : 08 php ;test stores do not alter flags 1a19 : 49c3 eor #$c3 1a1b : 28 plp 1a1c : 850d sta zpt+1 1a1e : 08 php ;flags after load/store sequence 1a1f : 49c3 eor #$c3 1a21 : c514 cmp zp1+1 ;test result trap_ne 1a23 : d0fe > bne * ;failed not equal (non zero) 1a25 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1a26 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1a28 : cd1d02 cmp fLDx+1 ;test flags trap_ne 1a2b : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1a2d : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1a2f : 48 > pha ;use stack to load status 1a30 : 28 > plp 1a31 : ad1902 lda abs1+2 1a34 : 08 php ;test stores do not alter flags 1a35 : 49c3 eor #$c3 1a37 : 28 plp 1a38 : 850e sta zpt+2 1a3a : 08 php ;flags after load/store sequence 1a3b : 49c3 eor #$c3 1a3d : c515 cmp zp1+2 ;test result trap_ne 1a3f : d0fe > bne * ;failed not equal (non zero) 1a41 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1a42 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1a44 : cd1e02 cmp fLDx+2 ;test flags trap_ne 1a47 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1a49 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1a4b : 48 > pha ;use stack to load status 1a4c : 28 > plp 1a4d : ad1a02 lda abs1+3 1a50 : 08 php ;test stores do not alter flags 1a51 : 49c3 eor #$c3 1a53 : 28 plp 1a54 : 850f sta zpt+3 1a56 : 08 php ;flags after load/store sequence 1a57 : 49c3 eor #$c3 1a59 : c516 cmp zp1+3 ;test result trap_ne 1a5b : d0fe > bne * ;failed not equal (non zero) 1a5d : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1a5e : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1a60 : cd1f02 cmp fLDx+3 ;test flags trap_ne 1a63 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1a65 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1a67 : 48 > pha ;use stack to load status 1a68 : 28 > plp 1a69 : a9c3 lda #$c3 1a6b : 08 php 1a6c : cd1702 cmp abs1 ;test result trap_ne 1a6f : d0fe > bne * ;failed not equal (non zero) 1a71 : 68 pla ;load status eor_flag 0 1a72 : 4930 > eor #0|fao ;invert expected flags + always on bits 1a74 : cd1c02 cmp fLDx ;test flags trap_ne 1a77 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1a79 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1a7b : 48 > pha ;use stack to load status 1a7c : 28 > plp 1a7d : a982 lda #$82 1a7f : 08 php 1a80 : cd1802 cmp abs1+1 ;test result trap_ne 1a83 : d0fe > bne * ;failed not equal (non zero) 1a85 : 68 pla ;load status eor_flag 0 1a86 : 4930 > eor #0|fao ;invert expected flags + always on bits 1a88 : cd1d02 cmp fLDx+1 ;test flags trap_ne 1a8b : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1a8d : a900 > lda #0 ;allow test to change I-flag (no mask) > 1a8f : 48 > pha ;use stack to load status 1a90 : 28 > plp 1a91 : a941 lda #$41 1a93 : 08 php 1a94 : cd1902 cmp abs1+2 ;test result trap_ne 1a97 : d0fe > bne * ;failed not equal (non zero) 1a99 : 68 pla ;load status eor_flag 0 1a9a : 4930 > eor #0|fao ;invert expected flags + always on bits 1a9c : cd1e02 cmp fLDx+2 ;test flags trap_ne 1a9f : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1aa1 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1aa3 : 48 > pha ;use stack to load status 1aa4 : 28 > plp 1aa5 : a900 lda #0 1aa7 : 08 php 1aa8 : cd1a02 cmp abs1+3 ;test result trap_ne 1aab : d0fe > bne * ;failed not equal (non zero) 1aad : 68 pla ;load status eor_flag 0 1aae : 4930 > eor #0|fao ;invert expected flags + always on bits 1ab0 : cd1f02 cmp fLDx+3 ;test flags trap_ne 1ab3 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1ab5 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1ab7 : 48 > pha ;use stack to load status 1ab8 : 28 > plp 1ab9 : a9c3 lda #$c3 1abb : 08 php 1abc : cd1702 cmp abs1 ;test result trap_ne 1abf : d0fe > bne * ;failed not equal (non zero) 1ac1 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1ac2 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1ac4 : cd1c02 cmp fLDx ;test flags trap_ne 1ac7 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1ac9 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1acb : 48 > pha ;use stack to load status 1acc : 28 > plp 1acd : a982 lda #$82 1acf : 08 php 1ad0 : cd1802 cmp abs1+1 ;test result trap_ne 1ad3 : d0fe > bne * ;failed not equal (non zero) 1ad5 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1ad6 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1ad8 : cd1d02 cmp fLDx+1 ;test flags trap_ne 1adb : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1add : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1adf : 48 > pha ;use stack to load status 1ae0 : 28 > plp 1ae1 : a941 lda #$41 1ae3 : 08 php 1ae4 : cd1902 cmp abs1+2 ;test result trap_ne 1ae7 : d0fe > bne * ;failed not equal (non zero) 1ae9 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1aea : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1aec : cd1e02 cmp fLDx+2 ;test flags trap_ne 1aef : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1af1 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1af3 : 48 > pha ;use stack to load status 1af4 : 28 > plp 1af5 : a900 lda #0 1af7 : 08 php 1af8 : cd1a02 cmp abs1+3 ;test result trap_ne 1afb : d0fe > bne * ;failed not equal (non zero) 1afd : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1afe : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits 1b00 : cd1f02 cmp fLDx+3 ;test flags trap_ne 1b03 : d0fe > bne * ;failed not equal (non zero) 1b05 : a200 ldx #0 1b07 : a50c lda zpt 1b09 : 49c3 eor #$c3 1b0b : c513 cmp zp1 trap_ne ;store to zp data 1b0d : d0fe > bne * ;failed not equal (non zero) 1b0f : 860c stx zpt ;clear 1b11 : ad0302 lda abst 1b14 : 49c3 eor #$c3 1b16 : cd1702 cmp abs1 trap_ne ;store to abs data 1b19 : d0fe > bne * ;failed not equal (non zero) 1b1b : 8e0302 stx abst ;clear 1b1e : a50d lda zpt+1 1b20 : 49c3 eor #$c3 1b22 : c514 cmp zp1+1 trap_ne ;store to zp data 1b24 : d0fe > bne * ;failed not equal (non zero) 1b26 : 860d stx zpt+1 ;clear 1b28 : ad0402 lda abst+1 1b2b : 49c3 eor #$c3 1b2d : cd1802 cmp abs1+1 trap_ne ;store to abs data 1b30 : d0fe > bne * ;failed not equal (non zero) 1b32 : 8e0402 stx abst+1 ;clear 1b35 : a50e lda zpt+2 1b37 : 49c3 eor #$c3 1b39 : c515 cmp zp1+2 trap_ne ;store to zp data 1b3b : d0fe > bne * ;failed not equal (non zero) 1b3d : 860e stx zpt+2 ;clear 1b3f : ad0502 lda abst+2 1b42 : 49c3 eor #$c3 1b44 : cd1902 cmp abs1+2 trap_ne ;store to abs data 1b47 : d0fe > bne * ;failed not equal (non zero) 1b49 : 8e0502 stx abst+2 ;clear 1b4c : a50f lda zpt+3 1b4e : 49c3 eor #$c3 1b50 : c516 cmp zp1+3 trap_ne ;store to zp data 1b52 : d0fe > bne * ;failed not equal (non zero) 1b54 : 860f stx zpt+3 ;clear 1b56 : ad0602 lda abst+3 1b59 : 49c3 eor #$c3 1b5b : cd1a02 cmp abs1+3 trap_ne ;store to abs data 1b5e : d0fe > bne * ;failed not equal (non zero) 1b60 : 8e0602 stx abst+3 ;clear next_test 1b63 : ad0002 > lda test_case ;previous test 1b66 : c918 > cmp #test_num > trap_ne ;test is out of sequence 1b68 : d0fe > bne * ;failed not equal (non zero) > 0019 = >test_num = test_num + 1 1b6a : a919 > lda #test_num ;*** next tests' number 1b6c : 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 1b6f : a900 > lda #0 ;allow test to change I-flag (no mask) > 1b71 : 48 > pha ;use stack to load status 1b72 : a9ff > lda #$ff ;precharge accu 1b74 : 28 > plp 1b75 : 2416 bit zp1+3 ;00 - should set Z / clear NV tst_a $ff,fz 1b77 : 08 > php ;save flags 1b78 : c9ff > cmp #$ff ;test result > trap_ne 1b7a : d0fe > bne * ;failed not equal (non zero) > 1b7c : 68 > pla ;load status 1b7d : 48 > pha > cmp_flag fz 1b7e : c932 > cmp #(fz |fao)&m8 ;expected flags + always on bits > > trap_ne 1b80 : d0fe > bne * ;failed not equal (non zero) > 1b82 : 28 > plp ;restore status set_a 1,0 > load_flag 0 1b83 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1b85 : 48 > pha ;use stack to load status 1b86 : a901 > lda #1 ;precharge accu 1b88 : 28 > plp 1b89 : 2415 bit zp1+2 ;41 - should set V (M6) / clear NZ tst_a 1,fv 1b8b : 08 > php ;save flags 1b8c : c901 > cmp #1 ;test result > trap_ne 1b8e : d0fe > bne * ;failed not equal (non zero) > 1b90 : 68 > pla ;load status 1b91 : 48 > pha > cmp_flag fv 1b92 : c970 > cmp #(fv|fao)&m8 ;expected flags + always on bits > > trap_ne 1b94 : d0fe > bne * ;failed not equal (non zero) > 1b96 : 28 > plp ;restore status set_a 1,0 > load_flag 0 1b97 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1b99 : 48 > pha ;use stack to load status 1b9a : a901 > lda #1 ;precharge accu 1b9c : 28 > plp 1b9d : 2414 bit zp1+1 ;82 - should set N (M7) & Z / clear V tst_a 1,fnz 1b9f : 08 > php ;save flags 1ba0 : c901 > cmp #1 ;test result > trap_ne 1ba2 : d0fe > bne * ;failed not equal (non zero) > 1ba4 : 68 > pla ;load status 1ba5 : 48 > pha > cmp_flag fnz 1ba6 : c9b2 > cmp #(fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 1ba8 : d0fe > bne * ;failed not equal (non zero) > 1baa : 28 > plp ;restore status set_a 1,0 > load_flag 0 1bab : a900 > lda #0 ;allow test to change I-flag (no mask) > 1bad : 48 > pha ;use stack to load status 1bae : a901 > lda #1 ;precharge accu 1bb0 : 28 > plp 1bb1 : 2413 bit zp1 ;c3 - should set N (M7) & V (M6) / clear Z tst_a 1,fnv 1bb3 : 08 > php ;save flags 1bb4 : c901 > cmp #1 ;test result > trap_ne 1bb6 : d0fe > bne * ;failed not equal (non zero) > 1bb8 : 68 > pla ;load status 1bb9 : 48 > pha > cmp_flag fnv 1bba : c9f0 > cmp #(fnv|fao)&m8 ;expected flags + always on bits > > trap_ne 1bbc : d0fe > bne * ;failed not equal (non zero) > 1bbe : 28 > plp ;restore status set_a $ff,$ff > load_flag $ff 1bbf : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1bc1 : 48 > pha ;use stack to load status 1bc2 : a9ff > lda #$ff ;precharge accu 1bc4 : 28 > plp 1bc5 : 2416 bit zp1+3 ;00 - should set Z / clear NV tst_a $ff,~fnv 1bc7 : 08 > php ;save flags 1bc8 : c9ff > cmp #$ff ;test result > trap_ne 1bca : d0fe > bne * ;failed not equal (non zero) > 1bcc : 68 > pla ;load status 1bcd : 48 > pha > cmp_flag ~fnv 1bce : c93f > cmp #(~fnv |fao)&m8 ;expected flags + always on bits > > trap_ne 1bd0 : d0fe > bne * ;failed not equal (non zero) > 1bd2 : 28 > plp ;restore status set_a 1,$ff > load_flag $ff 1bd3 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1bd5 : 48 > pha ;use stack to load status 1bd6 : a901 > lda #1 ;precharge accu 1bd8 : 28 > plp 1bd9 : 2415 bit zp1+2 ;41 - should set V (M6) / clear NZ tst_a 1,~fnz 1bdb : 08 > php ;save flags 1bdc : c901 > cmp #1 ;test result > trap_ne 1bde : d0fe > bne * ;failed not equal (non zero) > 1be0 : 68 > pla ;load status 1be1 : 48 > pha > cmp_flag ~fnz 1be2 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 1be4 : d0fe > bne * ;failed not equal (non zero) > 1be6 : 28 > plp ;restore status set_a 1,$ff > load_flag $ff 1be7 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1be9 : 48 > pha ;use stack to load status 1bea : a901 > lda #1 ;precharge accu 1bec : 28 > plp 1bed : 2414 bit zp1+1 ;82 - should set N (M7) & Z / clear V tst_a 1,~fv 1bef : 08 > php ;save flags 1bf0 : c901 > cmp #1 ;test result > trap_ne 1bf2 : d0fe > bne * ;failed not equal (non zero) > 1bf4 : 68 > pla ;load status 1bf5 : 48 > pha > cmp_flag ~fv 1bf6 : c9bf > cmp #(~fv|fao)&m8 ;expected flags + always on bits > > trap_ne 1bf8 : d0fe > bne * ;failed not equal (non zero) > 1bfa : 28 > plp ;restore status set_a 1,$ff > load_flag $ff 1bfb : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1bfd : 48 > pha ;use stack to load status 1bfe : a901 > lda #1 ;precharge accu 1c00 : 28 > plp 1c01 : 2413 bit zp1 ;c3 - should set N (M7) & V (M6) / clear Z tst_a 1,~fz 1c03 : 08 > php ;save flags 1c04 : c901 > cmp #1 ;test result > trap_ne 1c06 : d0fe > bne * ;failed not equal (non zero) > 1c08 : 68 > pla ;load status 1c09 : 48 > pha > cmp_flag ~fz 1c0a : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits > > trap_ne 1c0c : d0fe > bne * ;failed not equal (non zero) > 1c0e : 28 > plp ;restore status set_a $ff,0 > load_flag 0 1c0f : a900 > lda #0 ;allow test to change I-flag (no mask) > 1c11 : 48 > pha ;use stack to load status 1c12 : a9ff > lda #$ff ;precharge accu 1c14 : 28 > plp 1c15 : 2c1a02 bit abs1+3 ;00 - should set Z / clear NV tst_a $ff,fz 1c18 : 08 > php ;save flags 1c19 : c9ff > cmp #$ff ;test result > trap_ne 1c1b : d0fe > bne * ;failed not equal (non zero) > 1c1d : 68 > pla ;load status 1c1e : 48 > pha > cmp_flag fz 1c1f : c932 > cmp #(fz |fao)&m8 ;expected flags + always on bits > > trap_ne 1c21 : d0fe > bne * ;failed not equal (non zero) > 1c23 : 28 > plp ;restore status set_a 1,0 > load_flag 0 1c24 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1c26 : 48 > pha ;use stack to load status 1c27 : a901 > lda #1 ;precharge accu 1c29 : 28 > plp 1c2a : 2c1902 bit abs1+2 ;41 - should set V (M6) / clear NZ tst_a 1,fv 1c2d : 08 > php ;save flags 1c2e : c901 > cmp #1 ;test result > trap_ne 1c30 : d0fe > bne * ;failed not equal (non zero) > 1c32 : 68 > pla ;load status 1c33 : 48 > pha > cmp_flag fv 1c34 : c970 > cmp #(fv|fao)&m8 ;expected flags + always on bits > > trap_ne 1c36 : d0fe > bne * ;failed not equal (non zero) > 1c38 : 28 > plp ;restore status set_a 1,0 > load_flag 0 1c39 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1c3b : 48 > pha ;use stack to load status 1c3c : a901 > lda #1 ;precharge accu 1c3e : 28 > plp 1c3f : 2c1802 bit abs1+1 ;82 - should set N (M7) & Z / clear V tst_a 1,fnz 1c42 : 08 > php ;save flags 1c43 : c901 > cmp #1 ;test result > trap_ne 1c45 : d0fe > bne * ;failed not equal (non zero) > 1c47 : 68 > pla ;load status 1c48 : 48 > pha > cmp_flag fnz 1c49 : c9b2 > cmp #(fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 1c4b : d0fe > bne * ;failed not equal (non zero) > 1c4d : 28 > plp ;restore status set_a 1,0 > load_flag 0 1c4e : a900 > lda #0 ;allow test to change I-flag (no mask) > 1c50 : 48 > pha ;use stack to load status 1c51 : a901 > lda #1 ;precharge accu 1c53 : 28 > plp 1c54 : 2c1702 bit abs1 ;c3 - should set N (M7) & V (M6) / clear Z tst_a 1,fnv 1c57 : 08 > php ;save flags 1c58 : c901 > cmp #1 ;test result > trap_ne 1c5a : d0fe > bne * ;failed not equal (non zero) > 1c5c : 68 > pla ;load status 1c5d : 48 > pha > cmp_flag fnv 1c5e : c9f0 > cmp #(fnv|fao)&m8 ;expected flags + always on bits > > trap_ne 1c60 : d0fe > bne * ;failed not equal (non zero) > 1c62 : 28 > plp ;restore status set_a $ff,$ff > load_flag $ff 1c63 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1c65 : 48 > pha ;use stack to load status 1c66 : a9ff > lda #$ff ;precharge accu 1c68 : 28 > plp 1c69 : 2c1a02 bit abs1+3 ;00 - should set Z / clear NV tst_a $ff,~fnv 1c6c : 08 > php ;save flags 1c6d : c9ff > cmp #$ff ;test result > trap_ne 1c6f : d0fe > bne * ;failed not equal (non zero) > 1c71 : 68 > pla ;load status 1c72 : 48 > pha > cmp_flag ~fnv 1c73 : c93f > cmp #(~fnv |fao)&m8 ;expected flags + always on bits > > trap_ne 1c75 : d0fe > bne * ;failed not equal (non zero) > 1c77 : 28 > plp ;restore status set_a 1,$ff > load_flag $ff 1c78 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1c7a : 48 > pha ;use stack to load status 1c7b : a901 > lda #1 ;precharge accu 1c7d : 28 > plp 1c7e : 2c1902 bit abs1+2 ;41 - should set V (M6) / clear NZ tst_a 1,~fnz 1c81 : 08 > php ;save flags 1c82 : c901 > cmp #1 ;test result > trap_ne 1c84 : d0fe > bne * ;failed not equal (non zero) > 1c86 : 68 > pla ;load status 1c87 : 48 > pha > cmp_flag ~fnz 1c88 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 1c8a : d0fe > bne * ;failed not equal (non zero) > 1c8c : 28 > plp ;restore status set_a 1,$ff > load_flag $ff 1c8d : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1c8f : 48 > pha ;use stack to load status 1c90 : a901 > lda #1 ;precharge accu 1c92 : 28 > plp 1c93 : 2c1802 bit abs1+1 ;82 - should set N (M7) & Z / clear V tst_a 1,~fv 1c96 : 08 > php ;save flags 1c97 : c901 > cmp #1 ;test result > trap_ne 1c99 : d0fe > bne * ;failed not equal (non zero) > 1c9b : 68 > pla ;load status 1c9c : 48 > pha > cmp_flag ~fv 1c9d : c9bf > cmp #(~fv|fao)&m8 ;expected flags + always on bits > > trap_ne 1c9f : d0fe > bne * ;failed not equal (non zero) > 1ca1 : 28 > plp ;restore status set_a 1,$ff > load_flag $ff 1ca2 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1ca4 : 48 > pha ;use stack to load status 1ca5 : a901 > lda #1 ;precharge accu 1ca7 : 28 > plp 1ca8 : 2c1702 bit abs1 ;c3 - should set N (M7) & V (M6) / clear Z tst_a 1,~fz 1cab : 08 > php ;save flags 1cac : c901 > cmp #1 ;test result > trap_ne 1cae : d0fe > bne * ;failed not equal (non zero) > 1cb0 : 68 > pla ;load status 1cb1 : 48 > pha > cmp_flag ~fz 1cb2 : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits > > trap_ne 1cb4 : d0fe > bne * ;failed not equal (non zero) > 1cb6 : 28 > plp ;restore status next_test 1cb7 : ad0002 > lda test_case ;previous test 1cba : c919 > cmp #test_num > trap_ne ;test is out of sequence 1cbc : d0fe > bne * ;failed not equal (non zero) > 001a = >test_num = test_num + 1 1cbe : a91a > lda #test_num ;*** next tests' number 1cc0 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; CPX - zp / abs / # set_x $80,0 > load_flag 0 1cc3 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1cc5 : 48 > pha ;use stack to load status 1cc6 : a280 > ldx #$80 ;precharge index x 1cc8 : 28 > plp 1cc9 : e417 cpx zp7f tst_stat fc 1ccb : 08 > php ;save status 1ccc : 68 > pla ;use stack to retrieve status 1ccd : 48 > pha > cmp_flag fc 1cce : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits > > trap_ne 1cd0 : d0fe > bne * ;failed not equal (non zero) > 1cd2 : 28 > plp ;restore status 1cd3 : ca dex 1cd4 : e417 cpx zp7f tst_stat fzc 1cd6 : 08 > php ;save status 1cd7 : 68 > pla ;use stack to retrieve status 1cd8 : 48 > pha > cmp_flag fzc 1cd9 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 1cdb : d0fe > bne * ;failed not equal (non zero) > 1cdd : 28 > plp ;restore status 1cde : ca dex 1cdf : e417 cpx zp7f tst_x $7e,fn 1ce1 : 08 > php ;save flags 1ce2 : e07e > cpx #$7e ;test result > trap_ne 1ce4 : d0fe > bne * ;failed not equal (non zero) > 1ce6 : 68 > pla ;load status 1ce7 : 48 > pha > cmp_flag fn 1ce8 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 1cea : d0fe > bne * ;failed not equal (non zero) > 1cec : 28 > plp ;restore status set_x $80,$ff > load_flag $ff 1ced : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1cef : 48 > pha ;use stack to load status 1cf0 : a280 > ldx #$80 ;precharge index x 1cf2 : 28 > plp 1cf3 : e417 cpx zp7f tst_stat ~fnz 1cf5 : 08 > php ;save status 1cf6 : 68 > pla ;use stack to retrieve status 1cf7 : 48 > pha > cmp_flag ~fnz 1cf8 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 1cfa : d0fe > bne * ;failed not equal (non zero) > 1cfc : 28 > plp ;restore status 1cfd : ca dex 1cfe : e417 cpx zp7f tst_stat ~fn 1d00 : 08 > php ;save status 1d01 : 68 > pla ;use stack to retrieve status 1d02 : 48 > pha > cmp_flag ~fn 1d03 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits > > trap_ne 1d05 : d0fe > bne * ;failed not equal (non zero) > 1d07 : 28 > plp ;restore status 1d08 : ca dex 1d09 : e417 cpx zp7f tst_x $7e,~fzc 1d0b : 08 > php ;save flags 1d0c : e07e > cpx #$7e ;test result > trap_ne 1d0e : d0fe > bne * ;failed not equal (non zero) > 1d10 : 68 > pla ;load status 1d11 : 48 > pha > cmp_flag ~fzc 1d12 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 1d14 : d0fe > bne * ;failed not equal (non zero) > 1d16 : 28 > plp ;restore status set_x $80,0 > load_flag 0 1d17 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1d19 : 48 > pha ;use stack to load status 1d1a : a280 > ldx #$80 ;precharge index x 1d1c : 28 > plp 1d1d : ec1b02 cpx abs7f tst_stat fc 1d20 : 08 > php ;save status 1d21 : 68 > pla ;use stack to retrieve status 1d22 : 48 > pha > cmp_flag fc 1d23 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits > > trap_ne 1d25 : d0fe > bne * ;failed not equal (non zero) > 1d27 : 28 > plp ;restore status 1d28 : ca dex 1d29 : ec1b02 cpx abs7f tst_stat fzc 1d2c : 08 > php ;save status 1d2d : 68 > pla ;use stack to retrieve status 1d2e : 48 > pha > cmp_flag fzc 1d2f : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 1d31 : d0fe > bne * ;failed not equal (non zero) > 1d33 : 28 > plp ;restore status 1d34 : ca dex 1d35 : ec1b02 cpx abs7f tst_x $7e,fn 1d38 : 08 > php ;save flags 1d39 : e07e > cpx #$7e ;test result > trap_ne 1d3b : d0fe > bne * ;failed not equal (non zero) > 1d3d : 68 > pla ;load status 1d3e : 48 > pha > cmp_flag fn 1d3f : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 1d41 : d0fe > bne * ;failed not equal (non zero) > 1d43 : 28 > plp ;restore status set_x $80,$ff > load_flag $ff 1d44 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1d46 : 48 > pha ;use stack to load status 1d47 : a280 > ldx #$80 ;precharge index x 1d49 : 28 > plp 1d4a : ec1b02 cpx abs7f tst_stat ~fnz 1d4d : 08 > php ;save status 1d4e : 68 > pla ;use stack to retrieve status 1d4f : 48 > pha > cmp_flag ~fnz 1d50 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 1d52 : d0fe > bne * ;failed not equal (non zero) > 1d54 : 28 > plp ;restore status 1d55 : ca dex 1d56 : ec1b02 cpx abs7f tst_stat ~fn 1d59 : 08 > php ;save status 1d5a : 68 > pla ;use stack to retrieve status 1d5b : 48 > pha > cmp_flag ~fn 1d5c : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits > > trap_ne 1d5e : d0fe > bne * ;failed not equal (non zero) > 1d60 : 28 > plp ;restore status 1d61 : ca dex 1d62 : ec1b02 cpx abs7f tst_x $7e,~fzc 1d65 : 08 > php ;save flags 1d66 : e07e > cpx #$7e ;test result > trap_ne 1d68 : d0fe > bne * ;failed not equal (non zero) > 1d6a : 68 > pla ;load status 1d6b : 48 > pha > cmp_flag ~fzc 1d6c : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 1d6e : d0fe > bne * ;failed not equal (non zero) > 1d70 : 28 > plp ;restore status set_x $80,0 > load_flag 0 1d71 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1d73 : 48 > pha ;use stack to load status 1d74 : a280 > ldx #$80 ;precharge index x 1d76 : 28 > plp 1d77 : e07f cpx #$7f tst_stat fc 1d79 : 08 > php ;save status 1d7a : 68 > pla ;use stack to retrieve status 1d7b : 48 > pha > cmp_flag fc 1d7c : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits > > trap_ne 1d7e : d0fe > bne * ;failed not equal (non zero) > 1d80 : 28 > plp ;restore status 1d81 : ca dex 1d82 : e07f cpx #$7f tst_stat fzc 1d84 : 08 > php ;save status 1d85 : 68 > pla ;use stack to retrieve status 1d86 : 48 > pha > cmp_flag fzc 1d87 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 1d89 : d0fe > bne * ;failed not equal (non zero) > 1d8b : 28 > plp ;restore status 1d8c : ca dex 1d8d : e07f cpx #$7f tst_x $7e,fn 1d8f : 08 > php ;save flags 1d90 : e07e > cpx #$7e ;test result > trap_ne 1d92 : d0fe > bne * ;failed not equal (non zero) > 1d94 : 68 > pla ;load status 1d95 : 48 > pha > cmp_flag fn 1d96 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 1d98 : d0fe > bne * ;failed not equal (non zero) > 1d9a : 28 > plp ;restore status set_x $80,$ff > load_flag $ff 1d9b : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1d9d : 48 > pha ;use stack to load status 1d9e : a280 > ldx #$80 ;precharge index x 1da0 : 28 > plp 1da1 : e07f cpx #$7f tst_stat ~fnz 1da3 : 08 > php ;save status 1da4 : 68 > pla ;use stack to retrieve status 1da5 : 48 > pha > cmp_flag ~fnz 1da6 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 1da8 : d0fe > bne * ;failed not equal (non zero) > 1daa : 28 > plp ;restore status 1dab : ca dex 1dac : e07f cpx #$7f tst_stat ~fn 1dae : 08 > php ;save status 1daf : 68 > pla ;use stack to retrieve status 1db0 : 48 > pha > cmp_flag ~fn 1db1 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits > > trap_ne 1db3 : d0fe > bne * ;failed not equal (non zero) > 1db5 : 28 > plp ;restore status 1db6 : ca dex 1db7 : e07f cpx #$7f tst_x $7e,~fzc 1db9 : 08 > php ;save flags 1dba : e07e > cpx #$7e ;test result > trap_ne 1dbc : d0fe > bne * ;failed not equal (non zero) > 1dbe : 68 > pla ;load status 1dbf : 48 > pha > cmp_flag ~fzc 1dc0 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 1dc2 : d0fe > bne * ;failed not equal (non zero) > 1dc4 : 28 > plp ;restore status next_test 1dc5 : ad0002 > lda test_case ;previous test 1dc8 : c91a > cmp #test_num > trap_ne ;test is out of sequence 1dca : d0fe > bne * ;failed not equal (non zero) > 001b = >test_num = test_num + 1 1dcc : a91b > lda #test_num ;*** next tests' number 1dce : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; CPY - zp / abs / # set_y $80,0 > load_flag 0 1dd1 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1dd3 : 48 > pha ;use stack to load status 1dd4 : a080 > ldy #$80 ;precharge index y 1dd6 : 28 > plp 1dd7 : c417 cpy zp7f tst_stat fc 1dd9 : 08 > php ;save status 1dda : 68 > pla ;use stack to retrieve status 1ddb : 48 > pha > cmp_flag fc 1ddc : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits > > trap_ne 1dde : d0fe > bne * ;failed not equal (non zero) > 1de0 : 28 > plp ;restore status 1de1 : 88 dey 1de2 : c417 cpy zp7f tst_stat fzc 1de4 : 08 > php ;save status 1de5 : 68 > pla ;use stack to retrieve status 1de6 : 48 > pha > cmp_flag fzc 1de7 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 1de9 : d0fe > bne * ;failed not equal (non zero) > 1deb : 28 > plp ;restore status 1dec : 88 dey 1ded : c417 cpy zp7f tst_y $7e,fn 1def : 08 > php ;save flags 1df0 : c07e > cpy #$7e ;test result > trap_ne 1df2 : d0fe > bne * ;failed not equal (non zero) > 1df4 : 68 > pla ;load status 1df5 : 48 > pha > cmp_flag fn 1df6 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 1df8 : d0fe > bne * ;failed not equal (non zero) > 1dfa : 28 > plp ;restore status set_y $80,$ff > load_flag $ff 1dfb : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1dfd : 48 > pha ;use stack to load status 1dfe : a080 > ldy #$80 ;precharge index y 1e00 : 28 > plp 1e01 : c417 cpy zp7f tst_stat ~fnz 1e03 : 08 > php ;save status 1e04 : 68 > pla ;use stack to retrieve status 1e05 : 48 > pha > cmp_flag ~fnz 1e06 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 1e08 : d0fe > bne * ;failed not equal (non zero) > 1e0a : 28 > plp ;restore status 1e0b : 88 dey 1e0c : c417 cpy zp7f tst_stat ~fn 1e0e : 08 > php ;save status 1e0f : 68 > pla ;use stack to retrieve status 1e10 : 48 > pha > cmp_flag ~fn 1e11 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits > > trap_ne 1e13 : d0fe > bne * ;failed not equal (non zero) > 1e15 : 28 > plp ;restore status 1e16 : 88 dey 1e17 : c417 cpy zp7f tst_y $7e,~fzc 1e19 : 08 > php ;save flags 1e1a : c07e > cpy #$7e ;test result > trap_ne 1e1c : d0fe > bne * ;failed not equal (non zero) > 1e1e : 68 > pla ;load status 1e1f : 48 > pha > cmp_flag ~fzc 1e20 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 1e22 : d0fe > bne * ;failed not equal (non zero) > 1e24 : 28 > plp ;restore status set_y $80,0 > load_flag 0 1e25 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1e27 : 48 > pha ;use stack to load status 1e28 : a080 > ldy #$80 ;precharge index y 1e2a : 28 > plp 1e2b : cc1b02 cpy abs7f tst_stat fc 1e2e : 08 > php ;save status 1e2f : 68 > pla ;use stack to retrieve status 1e30 : 48 > pha > cmp_flag fc 1e31 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits > > trap_ne 1e33 : d0fe > bne * ;failed not equal (non zero) > 1e35 : 28 > plp ;restore status 1e36 : 88 dey 1e37 : cc1b02 cpy abs7f tst_stat fzc 1e3a : 08 > php ;save status 1e3b : 68 > pla ;use stack to retrieve status 1e3c : 48 > pha > cmp_flag fzc 1e3d : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 1e3f : d0fe > bne * ;failed not equal (non zero) > 1e41 : 28 > plp ;restore status 1e42 : 88 dey 1e43 : cc1b02 cpy abs7f tst_y $7e,fn 1e46 : 08 > php ;save flags 1e47 : c07e > cpy #$7e ;test result > trap_ne 1e49 : d0fe > bne * ;failed not equal (non zero) > 1e4b : 68 > pla ;load status 1e4c : 48 > pha > cmp_flag fn 1e4d : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 1e4f : d0fe > bne * ;failed not equal (non zero) > 1e51 : 28 > plp ;restore status set_y $80,$ff > load_flag $ff 1e52 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1e54 : 48 > pha ;use stack to load status 1e55 : a080 > ldy #$80 ;precharge index y 1e57 : 28 > plp 1e58 : cc1b02 cpy abs7f tst_stat ~fnz 1e5b : 08 > php ;save status 1e5c : 68 > pla ;use stack to retrieve status 1e5d : 48 > pha > cmp_flag ~fnz 1e5e : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 1e60 : d0fe > bne * ;failed not equal (non zero) > 1e62 : 28 > plp ;restore status 1e63 : 88 dey 1e64 : cc1b02 cpy abs7f tst_stat ~fn 1e67 : 08 > php ;save status 1e68 : 68 > pla ;use stack to retrieve status 1e69 : 48 > pha > cmp_flag ~fn 1e6a : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits > > trap_ne 1e6c : d0fe > bne * ;failed not equal (non zero) > 1e6e : 28 > plp ;restore status 1e6f : 88 dey 1e70 : cc1b02 cpy abs7f tst_y $7e,~fzc 1e73 : 08 > php ;save flags 1e74 : c07e > cpy #$7e ;test result > trap_ne 1e76 : d0fe > bne * ;failed not equal (non zero) > 1e78 : 68 > pla ;load status 1e79 : 48 > pha > cmp_flag ~fzc 1e7a : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 1e7c : d0fe > bne * ;failed not equal (non zero) > 1e7e : 28 > plp ;restore status set_y $80,0 > load_flag 0 1e7f : a900 > lda #0 ;allow test to change I-flag (no mask) > 1e81 : 48 > pha ;use stack to load status 1e82 : a080 > ldy #$80 ;precharge index y 1e84 : 28 > plp 1e85 : c07f cpy #$7f tst_stat fc 1e87 : 08 > php ;save status 1e88 : 68 > pla ;use stack to retrieve status 1e89 : 48 > pha > cmp_flag fc 1e8a : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits > > trap_ne 1e8c : d0fe > bne * ;failed not equal (non zero) > 1e8e : 28 > plp ;restore status 1e8f : 88 dey 1e90 : c07f cpy #$7f tst_stat fzc 1e92 : 08 > php ;save status 1e93 : 68 > pla ;use stack to retrieve status 1e94 : 48 > pha > cmp_flag fzc 1e95 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 1e97 : d0fe > bne * ;failed not equal (non zero) > 1e99 : 28 > plp ;restore status 1e9a : 88 dey 1e9b : c07f cpy #$7f tst_y $7e,fn 1e9d : 08 > php ;save flags 1e9e : c07e > cpy #$7e ;test result > trap_ne 1ea0 : d0fe > bne * ;failed not equal (non zero) > 1ea2 : 68 > pla ;load status 1ea3 : 48 > pha > cmp_flag fn 1ea4 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 1ea6 : d0fe > bne * ;failed not equal (non zero) > 1ea8 : 28 > plp ;restore status set_y $80,$ff > load_flag $ff 1ea9 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1eab : 48 > pha ;use stack to load status 1eac : a080 > ldy #$80 ;precharge index y 1eae : 28 > plp 1eaf : c07f cpy #$7f tst_stat ~fnz 1eb1 : 08 > php ;save status 1eb2 : 68 > pla ;use stack to retrieve status 1eb3 : 48 > pha > cmp_flag ~fnz 1eb4 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 1eb6 : d0fe > bne * ;failed not equal (non zero) > 1eb8 : 28 > plp ;restore status 1eb9 : 88 dey 1eba : c07f cpy #$7f tst_stat ~fn 1ebc : 08 > php ;save status 1ebd : 68 > pla ;use stack to retrieve status 1ebe : 48 > pha > cmp_flag ~fn 1ebf : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits > > trap_ne 1ec1 : d0fe > bne * ;failed not equal (non zero) > 1ec3 : 28 > plp ;restore status 1ec4 : 88 dey 1ec5 : c07f cpy #$7f tst_y $7e,~fzc 1ec7 : 08 > php ;save flags 1ec8 : c07e > cpy #$7e ;test result > trap_ne 1eca : d0fe > bne * ;failed not equal (non zero) > 1ecc : 68 > pla ;load status 1ecd : 48 > pha > cmp_flag ~fzc 1ece : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 1ed0 : d0fe > bne * ;failed not equal (non zero) > 1ed2 : 28 > plp ;restore status next_test 1ed3 : ad0002 > lda test_case ;previous test 1ed6 : c91b > cmp #test_num > trap_ne ;test is out of sequence 1ed8 : d0fe > bne * ;failed not equal (non zero) > 001c = >test_num = test_num + 1 1eda : a91c > lda #test_num ;*** next tests' number 1edc : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; CMP - zp / abs / # set_a $80,0 > load_flag 0 1edf : a900 > lda #0 ;allow test to change I-flag (no mask) > 1ee1 : 48 > pha ;use stack to load status 1ee2 : a980 > lda #$80 ;precharge accu 1ee4 : 28 > plp 1ee5 : c517 cmp zp7f tst_a $80,fc 1ee7 : 08 > php ;save flags 1ee8 : c980 > cmp #$80 ;test result > trap_ne 1eea : d0fe > bne * ;failed not equal (non zero) > 1eec : 68 > pla ;load status 1eed : 48 > pha > cmp_flag fc 1eee : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits > > trap_ne 1ef0 : d0fe > bne * ;failed not equal (non zero) > 1ef2 : 28 > plp ;restore status set_a $7f,0 > load_flag 0 1ef3 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1ef5 : 48 > pha ;use stack to load status 1ef6 : a97f > lda #$7f ;precharge accu 1ef8 : 28 > plp 1ef9 : c517 cmp zp7f tst_a $7f,fzc 1efb : 08 > php ;save flags 1efc : c97f > cmp #$7f ;test result > trap_ne 1efe : d0fe > bne * ;failed not equal (non zero) > 1f00 : 68 > pla ;load status 1f01 : 48 > pha > cmp_flag fzc 1f02 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 1f04 : d0fe > bne * ;failed not equal (non zero) > 1f06 : 28 > plp ;restore status set_a $7e,0 > load_flag 0 1f07 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1f09 : 48 > pha ;use stack to load status 1f0a : a97e > lda #$7e ;precharge accu 1f0c : 28 > plp 1f0d : c517 cmp zp7f tst_a $7e,fn 1f0f : 08 > php ;save flags 1f10 : c97e > cmp #$7e ;test result > trap_ne 1f12 : d0fe > bne * ;failed not equal (non zero) > 1f14 : 68 > pla ;load status 1f15 : 48 > pha > cmp_flag fn 1f16 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 1f18 : d0fe > bne * ;failed not equal (non zero) > 1f1a : 28 > plp ;restore status set_a $80,$ff > load_flag $ff 1f1b : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1f1d : 48 > pha ;use stack to load status 1f1e : a980 > lda #$80 ;precharge accu 1f20 : 28 > plp 1f21 : c517 cmp zp7f tst_a $80,~fnz 1f23 : 08 > php ;save flags 1f24 : c980 > cmp #$80 ;test result > trap_ne 1f26 : d0fe > bne * ;failed not equal (non zero) > 1f28 : 68 > pla ;load status 1f29 : 48 > pha > cmp_flag ~fnz 1f2a : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 1f2c : d0fe > bne * ;failed not equal (non zero) > 1f2e : 28 > plp ;restore status set_a $7f,$ff > load_flag $ff 1f2f : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1f31 : 48 > pha ;use stack to load status 1f32 : a97f > lda #$7f ;precharge accu 1f34 : 28 > plp 1f35 : c517 cmp zp7f tst_a $7f,~fn 1f37 : 08 > php ;save flags 1f38 : c97f > cmp #$7f ;test result > trap_ne 1f3a : d0fe > bne * ;failed not equal (non zero) > 1f3c : 68 > pla ;load status 1f3d : 48 > pha > cmp_flag ~fn 1f3e : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits > > trap_ne 1f40 : d0fe > bne * ;failed not equal (non zero) > 1f42 : 28 > plp ;restore status set_a $7e,$ff > load_flag $ff 1f43 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1f45 : 48 > pha ;use stack to load status 1f46 : a97e > lda #$7e ;precharge accu 1f48 : 28 > plp 1f49 : c517 cmp zp7f tst_a $7e,~fzc 1f4b : 08 > php ;save flags 1f4c : c97e > cmp #$7e ;test result > trap_ne 1f4e : d0fe > bne * ;failed not equal (non zero) > 1f50 : 68 > pla ;load status 1f51 : 48 > pha > cmp_flag ~fzc 1f52 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 1f54 : d0fe > bne * ;failed not equal (non zero) > 1f56 : 28 > plp ;restore status set_a $80,0 > load_flag 0 1f57 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1f59 : 48 > pha ;use stack to load status 1f5a : a980 > lda #$80 ;precharge accu 1f5c : 28 > plp 1f5d : cd1b02 cmp abs7f tst_a $80,fc 1f60 : 08 > php ;save flags 1f61 : c980 > cmp #$80 ;test result > trap_ne 1f63 : d0fe > bne * ;failed not equal (non zero) > 1f65 : 68 > pla ;load status 1f66 : 48 > pha > cmp_flag fc 1f67 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits > > trap_ne 1f69 : d0fe > bne * ;failed not equal (non zero) > 1f6b : 28 > plp ;restore status set_a $7f,0 > load_flag 0 1f6c : a900 > lda #0 ;allow test to change I-flag (no mask) > 1f6e : 48 > pha ;use stack to load status 1f6f : a97f > lda #$7f ;precharge accu 1f71 : 28 > plp 1f72 : cd1b02 cmp abs7f tst_a $7f,fzc 1f75 : 08 > php ;save flags 1f76 : c97f > cmp #$7f ;test result > trap_ne 1f78 : d0fe > bne * ;failed not equal (non zero) > 1f7a : 68 > pla ;load status 1f7b : 48 > pha > cmp_flag fzc 1f7c : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 1f7e : d0fe > bne * ;failed not equal (non zero) > 1f80 : 28 > plp ;restore status set_a $7e,0 > load_flag 0 1f81 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1f83 : 48 > pha ;use stack to load status 1f84 : a97e > lda #$7e ;precharge accu 1f86 : 28 > plp 1f87 : cd1b02 cmp abs7f tst_a $7e,fn 1f8a : 08 > php ;save flags 1f8b : c97e > cmp #$7e ;test result > trap_ne 1f8d : d0fe > bne * ;failed not equal (non zero) > 1f8f : 68 > pla ;load status 1f90 : 48 > pha > cmp_flag fn 1f91 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 1f93 : d0fe > bne * ;failed not equal (non zero) > 1f95 : 28 > plp ;restore status set_a $80,$ff > load_flag $ff 1f96 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1f98 : 48 > pha ;use stack to load status 1f99 : a980 > lda #$80 ;precharge accu 1f9b : 28 > plp 1f9c : cd1b02 cmp abs7f tst_a $80,~fnz 1f9f : 08 > php ;save flags 1fa0 : c980 > cmp #$80 ;test result > trap_ne 1fa2 : d0fe > bne * ;failed not equal (non zero) > 1fa4 : 68 > pla ;load status 1fa5 : 48 > pha > cmp_flag ~fnz 1fa6 : c97d > 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 $7f,$ff > load_flag $ff 1fab : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1fad : 48 > pha ;use stack to load status 1fae : a97f > lda #$7f ;precharge accu 1fb0 : 28 > plp 1fb1 : cd1b02 cmp abs7f tst_a $7f,~fn 1fb4 : 08 > php ;save flags 1fb5 : c97f > cmp #$7f ;test result > trap_ne 1fb7 : d0fe > bne * ;failed not equal (non zero) > 1fb9 : 68 > pla ;load status 1fba : 48 > pha > cmp_flag ~fn 1fbb : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits > > trap_ne 1fbd : d0fe > bne * ;failed not equal (non zero) > 1fbf : 28 > plp ;restore status set_a $7e,$ff > load_flag $ff 1fc0 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 1fc2 : 48 > pha ;use stack to load status 1fc3 : a97e > lda #$7e ;precharge accu 1fc5 : 28 > plp 1fc6 : cd1b02 cmp abs7f tst_a $7e,~fzc 1fc9 : 08 > php ;save flags 1fca : c97e > cmp #$7e ;test result > trap_ne 1fcc : d0fe > bne * ;failed not equal (non zero) > 1fce : 68 > pla ;load status 1fcf : 48 > pha > cmp_flag ~fzc 1fd0 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 1fd2 : d0fe > bne * ;failed not equal (non zero) > 1fd4 : 28 > plp ;restore status set_a $80,0 > load_flag 0 1fd5 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1fd7 : 48 > pha ;use stack to load status 1fd8 : a980 > lda #$80 ;precharge accu 1fda : 28 > plp 1fdb : c97f cmp #$7f tst_a $80,fc 1fdd : 08 > php ;save flags 1fde : c980 > cmp #$80 ;test result > trap_ne 1fe0 : d0fe > bne * ;failed not equal (non zero) > 1fe2 : 68 > pla ;load status 1fe3 : 48 > pha > cmp_flag fc 1fe4 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits > > trap_ne 1fe6 : d0fe > bne * ;failed not equal (non zero) > 1fe8 : 28 > plp ;restore status set_a $7f,0 > load_flag 0 1fe9 : a900 > lda #0 ;allow test to change I-flag (no mask) > 1feb : 48 > pha ;use stack to load status 1fec : a97f > lda #$7f ;precharge accu 1fee : 28 > plp 1fef : c97f cmp #$7f tst_a $7f,fzc 1ff1 : 08 > php ;save flags 1ff2 : c97f > cmp #$7f ;test result > trap_ne 1ff4 : d0fe > bne * ;failed not equal (non zero) > 1ff6 : 68 > pla ;load status 1ff7 : 48 > pha > cmp_flag fzc 1ff8 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 1ffa : d0fe > bne * ;failed not equal (non zero) > 1ffc : 28 > plp ;restore status set_a $7e,0 > load_flag 0 1ffd : a900 > lda #0 ;allow test to change I-flag (no mask) > 1fff : 48 > pha ;use stack to load status 2000 : a97e > lda #$7e ;precharge accu 2002 : 28 > plp 2003 : c97f cmp #$7f tst_a $7e,fn 2005 : 08 > php ;save flags 2006 : c97e > cmp #$7e ;test result > trap_ne 2008 : d0fe > bne * ;failed not equal (non zero) > 200a : 68 > pla ;load status 200b : 48 > pha > cmp_flag fn 200c : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 200e : d0fe > bne * ;failed not equal (non zero) > 2010 : 28 > plp ;restore status set_a $80,$ff > load_flag $ff 2011 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2013 : 48 > pha ;use stack to load status 2014 : a980 > lda #$80 ;precharge accu 2016 : 28 > plp 2017 : c97f cmp #$7f tst_a $80,~fnz 2019 : 08 > php ;save flags 201a : c980 > cmp #$80 ;test result > trap_ne 201c : d0fe > bne * ;failed not equal (non zero) > 201e : 68 > pla ;load status 201f : 48 > pha > cmp_flag ~fnz 2020 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 2022 : d0fe > bne * ;failed not equal (non zero) > 2024 : 28 > plp ;restore status set_a $7f,$ff > load_flag $ff 2025 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2027 : 48 > pha ;use stack to load status 2028 : a97f > lda #$7f ;precharge accu 202a : 28 > plp 202b : c97f cmp #$7f tst_a $7f,~fn 202d : 08 > php ;save flags 202e : c97f > cmp #$7f ;test result > trap_ne 2030 : d0fe > bne * ;failed not equal (non zero) > 2032 : 68 > pla ;load status 2033 : 48 > pha > cmp_flag ~fn 2034 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits > > trap_ne 2036 : d0fe > bne * ;failed not equal (non zero) > 2038 : 28 > plp ;restore status set_a $7e,$ff > load_flag $ff 2039 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 203b : 48 > pha ;use stack to load status 203c : a97e > lda #$7e ;precharge accu 203e : 28 > plp 203f : c97f cmp #$7f tst_a $7e,~fzc 2041 : 08 > php ;save flags 2042 : c97e > cmp #$7e ;test result > trap_ne 2044 : d0fe > bne * ;failed not equal (non zero) > 2046 : 68 > pla ;load status 2047 : 48 > pha > cmp_flag ~fzc 2048 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 204a : d0fe > bne * ;failed not equal (non zero) > 204c : 28 > plp ;restore status 204d : a204 ldx #4 ;with indexing by X set_a $80,0 > load_flag 0 204f : a900 > lda #0 ;allow test to change I-flag (no mask) > 2051 : 48 > pha ;use stack to load status 2052 : a980 > lda #$80 ;precharge accu 2054 : 28 > plp 2055 : d513 cmp zp1,x tst_a $80,fc 2057 : 08 > php ;save flags 2058 : c980 > cmp #$80 ;test result > trap_ne 205a : d0fe > bne * ;failed not equal (non zero) > 205c : 68 > pla ;load status 205d : 48 > pha > cmp_flag fc 205e : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits > > trap_ne 2060 : d0fe > bne * ;failed not equal (non zero) > 2062 : 28 > plp ;restore status set_a $7f,0 > load_flag 0 2063 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2065 : 48 > pha ;use stack to load status 2066 : a97f > lda #$7f ;precharge accu 2068 : 28 > plp 2069 : d513 cmp zp1,x tst_a $7f,fzc 206b : 08 > php ;save flags 206c : c97f > cmp #$7f ;test result > trap_ne 206e : d0fe > bne * ;failed not equal (non zero) > 2070 : 68 > pla ;load status 2071 : 48 > pha > cmp_flag fzc 2072 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 2074 : d0fe > bne * ;failed not equal (non zero) > 2076 : 28 > plp ;restore status set_a $7e,0 > load_flag 0 2077 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2079 : 48 > pha ;use stack to load status 207a : a97e > lda #$7e ;precharge accu 207c : 28 > plp 207d : d513 cmp zp1,x tst_a $7e,fn 207f : 08 > php ;save flags 2080 : c97e > cmp #$7e ;test result > trap_ne 2082 : d0fe > bne * ;failed not equal (non zero) > 2084 : 68 > pla ;load status 2085 : 48 > pha > cmp_flag fn 2086 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 2088 : d0fe > bne * ;failed not equal (non zero) > 208a : 28 > plp ;restore status set_a $80,$ff > load_flag $ff 208b : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 208d : 48 > pha ;use stack to load status 208e : a980 > lda #$80 ;precharge accu 2090 : 28 > plp 2091 : d513 cmp zp1,x tst_a $80,~fnz 2093 : 08 > php ;save flags 2094 : c980 > cmp #$80 ;test result > trap_ne 2096 : d0fe > bne * ;failed not equal (non zero) > 2098 : 68 > pla ;load status 2099 : 48 > pha > cmp_flag ~fnz 209a : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 209c : d0fe > bne * ;failed not equal (non zero) > 209e : 28 > plp ;restore status set_a $7f,$ff > load_flag $ff 209f : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 20a1 : 48 > pha ;use stack to load status 20a2 : a97f > lda #$7f ;precharge accu 20a4 : 28 > plp 20a5 : d513 cmp zp1,x tst_a $7f,~fn 20a7 : 08 > php ;save flags 20a8 : c97f > cmp #$7f ;test result > trap_ne 20aa : d0fe > bne * ;failed not equal (non zero) > 20ac : 68 > pla ;load status 20ad : 48 > pha > cmp_flag ~fn 20ae : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits > > trap_ne 20b0 : d0fe > bne * ;failed not equal (non zero) > 20b2 : 28 > plp ;restore status set_a $7e,$ff > load_flag $ff 20b3 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 20b5 : 48 > pha ;use stack to load status 20b6 : a97e > lda #$7e ;precharge accu 20b8 : 28 > plp 20b9 : d513 cmp zp1,x tst_a $7e,~fzc 20bb : 08 > php ;save flags 20bc : c97e > cmp #$7e ;test result > trap_ne 20be : d0fe > bne * ;failed not equal (non zero) > 20c0 : 68 > pla ;load status 20c1 : 48 > pha > cmp_flag ~fzc 20c2 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 20c4 : d0fe > bne * ;failed not equal (non zero) > 20c6 : 28 > plp ;restore status set_a $80,0 > load_flag 0 20c7 : a900 > lda #0 ;allow test to change I-flag (no mask) > 20c9 : 48 > pha ;use stack to load status 20ca : a980 > lda #$80 ;precharge accu 20cc : 28 > plp 20cd : dd1702 cmp abs1,x tst_a $80,fc 20d0 : 08 > php ;save flags 20d1 : c980 > cmp #$80 ;test result > trap_ne 20d3 : d0fe > bne * ;failed not equal (non zero) > 20d5 : 68 > pla ;load status 20d6 : 48 > pha > cmp_flag fc 20d7 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits > > trap_ne 20d9 : d0fe > bne * ;failed not equal (non zero) > 20db : 28 > plp ;restore status set_a $7f,0 > load_flag 0 20dc : a900 > lda #0 ;allow test to change I-flag (no mask) > 20de : 48 > pha ;use stack to load status 20df : a97f > lda #$7f ;precharge accu 20e1 : 28 > plp 20e2 : dd1702 cmp abs1,x tst_a $7f,fzc 20e5 : 08 > php ;save flags 20e6 : c97f > cmp #$7f ;test result > trap_ne 20e8 : d0fe > bne * ;failed not equal (non zero) > 20ea : 68 > pla ;load status 20eb : 48 > pha > cmp_flag fzc 20ec : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 20ee : d0fe > bne * ;failed not equal (non zero) > 20f0 : 28 > plp ;restore status set_a $7e,0 > load_flag 0 20f1 : a900 > lda #0 ;allow test to change I-flag (no mask) > 20f3 : 48 > pha ;use stack to load status 20f4 : a97e > lda #$7e ;precharge accu 20f6 : 28 > plp 20f7 : dd1702 cmp abs1,x tst_a $7e,fn 20fa : 08 > php ;save flags 20fb : c97e > cmp #$7e ;test result > trap_ne 20fd : d0fe > bne * ;failed not equal (non zero) > 20ff : 68 > pla ;load status 2100 : 48 > pha > cmp_flag fn 2101 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 2103 : d0fe > bne * ;failed not equal (non zero) > 2105 : 28 > plp ;restore status set_a $80,$ff > load_flag $ff 2106 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2108 : 48 > pha ;use stack to load status 2109 : a980 > lda #$80 ;precharge accu 210b : 28 > plp 210c : dd1702 cmp abs1,x tst_a $80,~fnz 210f : 08 > php ;save flags 2110 : c980 > cmp #$80 ;test result > trap_ne 2112 : d0fe > bne * ;failed not equal (non zero) > 2114 : 68 > pla ;load status 2115 : 48 > pha > cmp_flag ~fnz 2116 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 2118 : d0fe > bne * ;failed not equal (non zero) > 211a : 28 > plp ;restore status set_a $7f,$ff > load_flag $ff 211b : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 211d : 48 > pha ;use stack to load status 211e : a97f > lda #$7f ;precharge accu 2120 : 28 > plp 2121 : dd1702 cmp abs1,x tst_a $7f,~fn 2124 : 08 > php ;save flags 2125 : c97f > cmp #$7f ;test result > trap_ne 2127 : d0fe > bne * ;failed not equal (non zero) > 2129 : 68 > pla ;load status 212a : 48 > pha > cmp_flag ~fn 212b : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits > > trap_ne 212d : d0fe > bne * ;failed not equal (non zero) > 212f : 28 > plp ;restore status set_a $7e,$ff > load_flag $ff 2130 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2132 : 48 > pha ;use stack to load status 2133 : a97e > lda #$7e ;precharge accu 2135 : 28 > plp 2136 : dd1702 cmp abs1,x tst_a $7e,~fzc 2139 : 08 > php ;save flags 213a : c97e > cmp #$7e ;test result > trap_ne 213c : d0fe > bne * ;failed not equal (non zero) > 213e : 68 > pla ;load status 213f : 48 > pha > cmp_flag ~fzc 2140 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 2142 : d0fe > bne * ;failed not equal (non zero) > 2144 : 28 > plp ;restore status 2145 : a004 ldy #4 ;with indexing by Y 2147 : a208 ldx #8 ;with indexed indirect set_a $80,0 > load_flag 0 2149 : a900 > lda #0 ;allow test to change I-flag (no mask) > 214b : 48 > pha ;use stack to load status 214c : a980 > lda #$80 ;precharge accu 214e : 28 > plp 214f : d91702 cmp abs1,y tst_a $80,fc 2152 : 08 > php ;save flags 2153 : c980 > cmp #$80 ;test result > trap_ne 2155 : d0fe > bne * ;failed not equal (non zero) > 2157 : 68 > pla ;load status 2158 : 48 > pha > cmp_flag fc 2159 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits > > trap_ne 215b : d0fe > bne * ;failed not equal (non zero) > 215d : 28 > plp ;restore status set_a $7f,0 > load_flag 0 215e : a900 > lda #0 ;allow test to change I-flag (no mask) > 2160 : 48 > pha ;use stack to load status 2161 : a97f > lda #$7f ;precharge accu 2163 : 28 > plp 2164 : d91702 cmp abs1,y tst_a $7f,fzc 2167 : 08 > php ;save flags 2168 : c97f > cmp #$7f ;test result > trap_ne 216a : d0fe > bne * ;failed not equal (non zero) > 216c : 68 > pla ;load status 216d : 48 > pha > cmp_flag fzc 216e : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 2170 : d0fe > bne * ;failed not equal (non zero) > 2172 : 28 > plp ;restore status set_a $7e,0 > load_flag 0 2173 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2175 : 48 > pha ;use stack to load status 2176 : a97e > lda #$7e ;precharge accu 2178 : 28 > plp 2179 : d91702 cmp abs1,y tst_a $7e,fn 217c : 08 > php ;save flags 217d : c97e > cmp #$7e ;test result > trap_ne 217f : d0fe > bne * ;failed not equal (non zero) > 2181 : 68 > pla ;load status 2182 : 48 > pha > cmp_flag fn 2183 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 2185 : d0fe > bne * ;failed not equal (non zero) > 2187 : 28 > plp ;restore status set_a $80,$ff > load_flag $ff 2188 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 218a : 48 > pha ;use stack to load status 218b : a980 > lda #$80 ;precharge accu 218d : 28 > plp 218e : d91702 cmp abs1,y tst_a $80,~fnz 2191 : 08 > php ;save flags 2192 : c980 > cmp #$80 ;test result > trap_ne 2194 : d0fe > bne * ;failed not equal (non zero) > 2196 : 68 > pla ;load status 2197 : 48 > pha > cmp_flag ~fnz 2198 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 219a : d0fe > bne * ;failed not equal (non zero) > 219c : 28 > plp ;restore status set_a $7f,$ff > load_flag $ff 219d : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 219f : 48 > pha ;use stack to load status 21a0 : a97f > lda #$7f ;precharge accu 21a2 : 28 > plp 21a3 : d91702 cmp abs1,y tst_a $7f,~fn 21a6 : 08 > php ;save flags 21a7 : c97f > cmp #$7f ;test result > trap_ne 21a9 : d0fe > bne * ;failed not equal (non zero) > 21ab : 68 > pla ;load status 21ac : 48 > pha > cmp_flag ~fn 21ad : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits > > trap_ne 21af : d0fe > bne * ;failed not equal (non zero) > 21b1 : 28 > plp ;restore status set_a $7e,$ff > load_flag $ff 21b2 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 21b4 : 48 > pha ;use stack to load status 21b5 : a97e > lda #$7e ;precharge accu 21b7 : 28 > plp 21b8 : d91702 cmp abs1,y tst_a $7e,~fzc 21bb : 08 > php ;save flags 21bc : c97e > cmp #$7e ;test result > trap_ne 21be : d0fe > bne * ;failed not equal (non zero) > 21c0 : 68 > pla ;load status 21c1 : 48 > pha > cmp_flag ~fzc 21c2 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 21c4 : d0fe > bne * ;failed not equal (non zero) > 21c6 : 28 > plp ;restore status set_a $80,0 > load_flag 0 21c7 : a900 > lda #0 ;allow test to change I-flag (no mask) > 21c9 : 48 > pha ;use stack to load status 21ca : a980 > lda #$80 ;precharge accu 21cc : 28 > plp 21cd : c124 cmp (ind1,x) tst_a $80,fc 21cf : 08 > php ;save flags 21d0 : c980 > cmp #$80 ;test result > trap_ne 21d2 : d0fe > bne * ;failed not equal (non zero) > 21d4 : 68 > pla ;load status 21d5 : 48 > pha > cmp_flag fc 21d6 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits > > trap_ne 21d8 : d0fe > bne * ;failed not equal (non zero) > 21da : 28 > plp ;restore status set_a $7f,0 > load_flag 0 21db : a900 > lda #0 ;allow test to change I-flag (no mask) > 21dd : 48 > pha ;use stack to load status 21de : a97f > lda #$7f ;precharge accu 21e0 : 28 > plp 21e1 : c124 cmp (ind1,x) tst_a $7f,fzc 21e3 : 08 > php ;save flags 21e4 : c97f > cmp #$7f ;test result > trap_ne 21e6 : d0fe > bne * ;failed not equal (non zero) > 21e8 : 68 > pla ;load status 21e9 : 48 > pha > cmp_flag fzc 21ea : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 21ec : d0fe > bne * ;failed not equal (non zero) > 21ee : 28 > plp ;restore status set_a $7e,0 > load_flag 0 21ef : a900 > lda #0 ;allow test to change I-flag (no mask) > 21f1 : 48 > pha ;use stack to load status 21f2 : a97e > lda #$7e ;precharge accu 21f4 : 28 > plp 21f5 : c124 cmp (ind1,x) tst_a $7e,fn 21f7 : 08 > php ;save flags 21f8 : c97e > cmp #$7e ;test result > trap_ne 21fa : d0fe > bne * ;failed not equal (non zero) > 21fc : 68 > pla ;load status 21fd : 48 > pha > cmp_flag fn 21fe : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 2200 : d0fe > bne * ;failed not equal (non zero) > 2202 : 28 > plp ;restore status set_a $80,$ff > load_flag $ff 2203 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2205 : 48 > pha ;use stack to load status 2206 : a980 > lda #$80 ;precharge accu 2208 : 28 > plp 2209 : c124 cmp (ind1,x) tst_a $80,~fnz 220b : 08 > php ;save flags 220c : c980 > cmp #$80 ;test result > trap_ne 220e : d0fe > bne * ;failed not equal (non zero) > 2210 : 68 > pla ;load status 2211 : 48 > pha > cmp_flag ~fnz 2212 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 2214 : d0fe > bne * ;failed not equal (non zero) > 2216 : 28 > plp ;restore status set_a $7f,$ff > load_flag $ff 2217 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2219 : 48 > pha ;use stack to load status 221a : a97f > lda #$7f ;precharge accu 221c : 28 > plp 221d : c124 cmp (ind1,x) tst_a $7f,~fn 221f : 08 > php ;save flags 2220 : c97f > cmp #$7f ;test result > trap_ne 2222 : d0fe > bne * ;failed not equal (non zero) > 2224 : 68 > pla ;load status 2225 : 48 > pha > cmp_flag ~fn 2226 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits > > trap_ne 2228 : d0fe > bne * ;failed not equal (non zero) > 222a : 28 > plp ;restore status set_a $7e,$ff > load_flag $ff 222b : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 222d : 48 > pha ;use stack to load status 222e : a97e > lda #$7e ;precharge accu 2230 : 28 > plp 2231 : c124 cmp (ind1,x) tst_a $7e,~fzc 2233 : 08 > php ;save flags 2234 : c97e > cmp #$7e ;test result > trap_ne 2236 : d0fe > bne * ;failed not equal (non zero) > 2238 : 68 > pla ;load status 2239 : 48 > pha > cmp_flag ~fzc 223a : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 223c : d0fe > bne * ;failed not equal (non zero) > 223e : 28 > plp ;restore status set_a $80,0 > load_flag 0 223f : a900 > lda #0 ;allow test to change I-flag (no mask) > 2241 : 48 > pha ;use stack to load status 2242 : a980 > lda #$80 ;precharge accu 2244 : 28 > plp 2245 : d124 cmp (ind1),y tst_a $80,fc 2247 : 08 > php ;save flags 2248 : c980 > cmp #$80 ;test result > trap_ne 224a : d0fe > bne * ;failed not equal (non zero) > 224c : 68 > pla ;load status 224d : 48 > pha > cmp_flag fc 224e : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits > > trap_ne 2250 : d0fe > bne * ;failed not equal (non zero) > 2252 : 28 > plp ;restore status set_a $7f,0 > load_flag 0 2253 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2255 : 48 > pha ;use stack to load status 2256 : a97f > lda #$7f ;precharge accu 2258 : 28 > plp 2259 : d124 cmp (ind1),y tst_a $7f,fzc 225b : 08 > php ;save flags 225c : c97f > cmp #$7f ;test result > trap_ne 225e : d0fe > bne * ;failed not equal (non zero) > 2260 : 68 > pla ;load status 2261 : 48 > pha > cmp_flag fzc 2262 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 2264 : d0fe > bne * ;failed not equal (non zero) > 2266 : 28 > plp ;restore status set_a $7e,0 > load_flag 0 2267 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2269 : 48 > pha ;use stack to load status 226a : a97e > lda #$7e ;precharge accu 226c : 28 > plp 226d : d124 cmp (ind1),y tst_a $7e,fn 226f : 08 > php ;save flags 2270 : c97e > cmp #$7e ;test result > trap_ne 2272 : d0fe > bne * ;failed not equal (non zero) > 2274 : 68 > pla ;load status 2275 : 48 > pha > cmp_flag fn 2276 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits > > trap_ne 2278 : d0fe > bne * ;failed not equal (non zero) > 227a : 28 > plp ;restore status set_a $80,$ff > load_flag $ff 227b : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 227d : 48 > pha ;use stack to load status 227e : a980 > lda #$80 ;precharge accu 2280 : 28 > plp 2281 : d124 cmp (ind1),y tst_a $80,~fnz 2283 : 08 > php ;save flags 2284 : c980 > cmp #$80 ;test result > trap_ne 2286 : d0fe > bne * ;failed not equal (non zero) > 2288 : 68 > pla ;load status 2289 : 48 > pha > cmp_flag ~fnz 228a : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits > > trap_ne 228c : d0fe > bne * ;failed not equal (non zero) > 228e : 28 > plp ;restore status set_a $7f,$ff > load_flag $ff 228f : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2291 : 48 > pha ;use stack to load status 2292 : a97f > lda #$7f ;precharge accu 2294 : 28 > plp 2295 : d124 cmp (ind1),y tst_a $7f,~fn 2297 : 08 > php ;save flags 2298 : c97f > cmp #$7f ;test result > trap_ne 229a : d0fe > bne * ;failed not equal (non zero) > 229c : 68 > pla ;load status 229d : 48 > pha > cmp_flag ~fn 229e : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits > > trap_ne 22a0 : d0fe > bne * ;failed not equal (non zero) > 22a2 : 28 > plp ;restore status set_a $7e,$ff > load_flag $ff 22a3 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 22a5 : 48 > pha ;use stack to load status 22a6 : a97e > lda #$7e ;precharge accu 22a8 : 28 > plp 22a9 : d124 cmp (ind1),y tst_a $7e,~fzc 22ab : 08 > php ;save flags 22ac : c97e > cmp #$7e ;test result > trap_ne 22ae : d0fe > bne * ;failed not equal (non zero) > 22b0 : 68 > pla ;load status 22b1 : 48 > pha > cmp_flag ~fzc 22b2 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits > > trap_ne 22b4 : d0fe > bne * ;failed not equal (non zero) > 22b6 : 28 > plp ;restore status next_test 22b7 : ad0002 > lda test_case ;previous test 22ba : c91c > cmp #test_num > trap_ne ;test is out of sequence 22bc : d0fe > bne * ;failed not equal (non zero) > 001d = >test_num = test_num + 1 22be : a91d > lda #test_num ;*** next tests' number 22c0 : 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 22c3 : a203 ldx #3 22c5 : tasl set_ax zp1,0 > load_flag 0 22c5 : a900 > lda #0 ;allow test to change I-flag (no mask) > 22c7 : 48 > pha ;use stack to load status 22c8 : b513 > lda zp1,x ;precharge accu 22ca : 28 > plp 22cb : 0a asl a tst_ax rASL,fASL,0 22cc : 08 > php ;save flags 22cd : dd2002 > cmp rASL,x ;test result > trap_ne 22d0 : d0fe > bne * ;failed not equal (non zero) > 22d2 : 68 > pla ;load status > eor_flag 0 22d3 : 4930 > eor #0|fao ;invert expected flags + always on bits > 22d5 : dd3002 > cmp fASL,x ;test flags > trap_ne ; 22d8 : d0fe > bne * ;failed not equal (non zero) > 22da : ca dex 22db : 10e8 bpl tasl 22dd : a203 ldx #3 22df : tasl1 set_ax zp1,$ff > load_flag $ff 22df : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 22e1 : 48 > pha ;use stack to load status 22e2 : b513 > lda zp1,x ;precharge accu 22e4 : 28 > plp 22e5 : 0a asl a tst_ax rASL,fASL,$ff-fnzc 22e6 : 08 > php ;save flags 22e7 : dd2002 > cmp rASL,x ;test result > trap_ne 22ea : d0fe > bne * ;failed not equal (non zero) > 22ec : 68 > pla ;load status > eor_flag $ff-fnzc 22ed : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 22ef : dd3002 > cmp fASL,x ;test flags > trap_ne ; 22f2 : d0fe > bne * ;failed not equal (non zero) > 22f4 : ca dex 22f5 : 10e8 bpl tasl1 22f7 : a203 ldx #3 22f9 : tlsr set_ax zp1,0 > load_flag 0 22f9 : a900 > lda #0 ;allow test to change I-flag (no mask) > 22fb : 48 > pha ;use stack to load status 22fc : b513 > lda zp1,x ;precharge accu 22fe : 28 > plp 22ff : 4a lsr a tst_ax rLSR,fLSR,0 2300 : 08 > php ;save flags 2301 : dd2802 > cmp rLSR,x ;test result > trap_ne 2304 : d0fe > bne * ;failed not equal (non zero) > 2306 : 68 > pla ;load status > eor_flag 0 2307 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2309 : dd3802 > cmp fLSR,x ;test flags > trap_ne ; 230c : d0fe > bne * ;failed not equal (non zero) > 230e : ca dex 230f : 10e8 bpl tlsr 2311 : a203 ldx #3 2313 : tlsr1 set_ax zp1,$ff > load_flag $ff 2313 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2315 : 48 > pha ;use stack to load status 2316 : b513 > lda zp1,x ;precharge accu 2318 : 28 > plp 2319 : 4a lsr a tst_ax rLSR,fLSR,$ff-fnzc 231a : 08 > php ;save flags 231b : dd2802 > cmp rLSR,x ;test result > trap_ne 231e : d0fe > bne * ;failed not equal (non zero) > 2320 : 68 > pla ;load status > eor_flag $ff-fnzc 2321 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2323 : dd3802 > cmp fLSR,x ;test flags > trap_ne ; 2326 : d0fe > bne * ;failed not equal (non zero) > 2328 : ca dex 2329 : 10e8 bpl tlsr1 232b : a203 ldx #3 232d : trol set_ax zp1,0 > load_flag 0 232d : a900 > lda #0 ;allow test to change I-flag (no mask) > 232f : 48 > pha ;use stack to load status 2330 : b513 > lda zp1,x ;precharge accu 2332 : 28 > plp 2333 : 2a rol a tst_ax rROL,fROL,0 2334 : 08 > php ;save flags 2335 : dd2002 > cmp rROL,x ;test result > trap_ne 2338 : d0fe > bne * ;failed not equal (non zero) > 233a : 68 > pla ;load status > eor_flag 0 233b : 4930 > eor #0|fao ;invert expected flags + always on bits > 233d : dd3002 > cmp fROL,x ;test flags > trap_ne ; 2340 : d0fe > bne * ;failed not equal (non zero) > 2342 : ca dex 2343 : 10e8 bpl trol 2345 : a203 ldx #3 2347 : trol1 set_ax zp1,$ff-fc > load_flag $ff-fc 2347 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) > 2349 : 48 > pha ;use stack to load status 234a : b513 > lda zp1,x ;precharge accu 234c : 28 > plp 234d : 2a rol a tst_ax rROL,fROL,$ff-fnzc 234e : 08 > php ;save flags 234f : dd2002 > cmp rROL,x ;test result > trap_ne 2352 : d0fe > bne * ;failed not equal (non zero) > 2354 : 68 > pla ;load status > eor_flag $ff-fnzc 2355 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2357 : dd3002 > cmp fROL,x ;test flags > trap_ne ; 235a : d0fe > bne * ;failed not equal (non zero) > 235c : ca dex 235d : 10e8 bpl trol1 235f : a203 ldx #3 2361 : trolc set_ax zp1,fc > load_flag fc 2361 : a901 > lda #fc ;allow test to change I-flag (no mask) > 2363 : 48 > pha ;use stack to load status 2364 : b513 > lda zp1,x ;precharge accu 2366 : 28 > plp 2367 : 2a rol a tst_ax rROLc,fROLc,0 2368 : 08 > php ;save flags 2369 : dd2402 > cmp rROLc,x ;test result > trap_ne 236c : d0fe > bne * ;failed not equal (non zero) > 236e : 68 > pla ;load status > eor_flag 0 236f : 4930 > eor #0|fao ;invert expected flags + always on bits > 2371 : dd3402 > cmp fROLc,x ;test flags > trap_ne ; 2374 : d0fe > bne * ;failed not equal (non zero) > 2376 : ca dex 2377 : 10e8 bpl trolc 2379 : a203 ldx #3 237b : trolc1 set_ax zp1,$ff > load_flag $ff 237b : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 237d : 48 > pha ;use stack to load status 237e : b513 > lda zp1,x ;precharge accu 2380 : 28 > plp 2381 : 2a rol a tst_ax rROLc,fROLc,$ff-fnzc 2382 : 08 > php ;save flags 2383 : dd2402 > cmp rROLc,x ;test result > trap_ne 2386 : d0fe > bne * ;failed not equal (non zero) > 2388 : 68 > pla ;load status > eor_flag $ff-fnzc 2389 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 238b : dd3402 > cmp fROLc,x ;test flags > trap_ne ; 238e : d0fe > bne * ;failed not equal (non zero) > 2390 : ca dex 2391 : 10e8 bpl trolc1 2393 : a203 ldx #3 2395 : tror set_ax zp1,0 > load_flag 0 2395 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2397 : 48 > pha ;use stack to load status 2398 : b513 > lda zp1,x ;precharge accu 239a : 28 > plp 239b : 6a ror a tst_ax rROR,fROR,0 239c : 08 > php ;save flags 239d : dd2802 > cmp rROR,x ;test result > trap_ne 23a0 : d0fe > bne * ;failed not equal (non zero) > 23a2 : 68 > pla ;load status > eor_flag 0 23a3 : 4930 > eor #0|fao ;invert expected flags + always on bits > 23a5 : dd3802 > cmp fROR,x ;test flags > trap_ne ; 23a8 : d0fe > bne * ;failed not equal (non zero) > 23aa : ca dex 23ab : 10e8 bpl tror 23ad : a203 ldx #3 23af : tror1 set_ax zp1,$ff-fc > load_flag $ff-fc 23af : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) > 23b1 : 48 > pha ;use stack to load status 23b2 : b513 > lda zp1,x ;precharge accu 23b4 : 28 > plp 23b5 : 6a ror a tst_ax rROR,fROR,$ff-fnzc 23b6 : 08 > php ;save flags 23b7 : dd2802 > cmp rROR,x ;test result > trap_ne 23ba : d0fe > bne * ;failed not equal (non zero) > 23bc : 68 > pla ;load status > eor_flag $ff-fnzc 23bd : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 23bf : dd3802 > cmp fROR,x ;test flags > trap_ne ; 23c2 : d0fe > bne * ;failed not equal (non zero) > 23c4 : ca dex 23c5 : 10e8 bpl tror1 23c7 : a203 ldx #3 23c9 : trorc set_ax zp1,fc > load_flag fc 23c9 : a901 > lda #fc ;allow test to change I-flag (no mask) > 23cb : 48 > pha ;use stack to load status 23cc : b513 > lda zp1,x ;precharge accu 23ce : 28 > plp 23cf : 6a ror a tst_ax rRORc,fRORc,0 23d0 : 08 > php ;save flags 23d1 : dd2c02 > cmp rRORc,x ;test result > trap_ne 23d4 : d0fe > bne * ;failed not equal (non zero) > 23d6 : 68 > pla ;load status > eor_flag 0 23d7 : 4930 > eor #0|fao ;invert expected flags + always on bits > 23d9 : dd3c02 > cmp fRORc,x ;test flags > trap_ne ; 23dc : d0fe > bne * ;failed not equal (non zero) > 23de : ca dex 23df : 10e8 bpl trorc 23e1 : a203 ldx #3 23e3 : trorc1 set_ax zp1,$ff > load_flag $ff 23e3 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 23e5 : 48 > pha ;use stack to load status 23e6 : b513 > lda zp1,x ;precharge accu 23e8 : 28 > plp 23e9 : 6a ror a tst_ax rRORc,fRORc,$ff-fnzc 23ea : 08 > php ;save flags 23eb : dd2c02 > cmp rRORc,x ;test result > trap_ne 23ee : d0fe > bne * ;failed not equal (non zero) > 23f0 : 68 > pla ;load status > eor_flag $ff-fnzc 23f1 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 23f3 : dd3c02 > cmp fRORc,x ;test flags > trap_ne ; 23f6 : d0fe > bne * ;failed not equal (non zero) > 23f8 : ca dex 23f9 : 10e8 bpl trorc1 next_test 23fb : ad0002 > lda test_case ;previous test 23fe : c91d > cmp #test_num > trap_ne ;test is out of sequence 2400 : d0fe > bne * ;failed not equal (non zero) > 001e = >test_num = test_num + 1 2402 : a91e > lda #test_num ;*** next tests' number 2404 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; shifts - zeropage 2407 : a203 ldx #3 2409 : tasl2 set_z zp1,0 > load_flag 0 2409 : a900 > lda #0 ;allow test to change I-flag (no mask) > 240b : 48 > pha ;use stack to load status 240c : b513 > lda zp1,x ;load to zeropage 240e : 850c > sta zpt 2410 : 28 > plp 2411 : 060c asl zpt tst_z rASL,fASL,0 2413 : 08 > php ;save flags 2414 : a50c > lda zpt 2416 : dd2002 > cmp rASL,x ;test result > trap_ne 2419 : d0fe > bne * ;failed not equal (non zero) > 241b : 68 > pla ;load status > eor_flag 0 241c : 4930 > eor #0|fao ;invert expected flags + always on bits > 241e : dd3002 > cmp fASL,x ;test flags > trap_ne 2421 : d0fe > bne * ;failed not equal (non zero) > 2423 : ca dex 2424 : 10e3 bpl tasl2 2426 : a203 ldx #3 2428 : tasl3 set_z zp1,$ff > load_flag $ff 2428 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 242a : 48 > pha ;use stack to load status 242b : b513 > lda zp1,x ;load to zeropage 242d : 850c > sta zpt 242f : 28 > plp 2430 : 060c asl zpt tst_z rASL,fASL,$ff-fnzc 2432 : 08 > php ;save flags 2433 : a50c > lda zpt 2435 : dd2002 > cmp rASL,x ;test result > trap_ne 2438 : d0fe > bne * ;failed not equal (non zero) > 243a : 68 > pla ;load status > eor_flag $ff-fnzc 243b : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 243d : dd3002 > cmp fASL,x ;test flags > trap_ne 2440 : d0fe > bne * ;failed not equal (non zero) > 2442 : ca dex 2443 : 10e3 bpl tasl3 2445 : a203 ldx #3 2447 : tlsr2 set_z zp1,0 > load_flag 0 2447 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2449 : 48 > pha ;use stack to load status 244a : b513 > lda zp1,x ;load to zeropage 244c : 850c > sta zpt 244e : 28 > plp 244f : 460c lsr zpt tst_z rLSR,fLSR,0 2451 : 08 > php ;save flags 2452 : a50c > lda zpt 2454 : dd2802 > cmp rLSR,x ;test result > trap_ne 2457 : d0fe > bne * ;failed not equal (non zero) > 2459 : 68 > pla ;load status > eor_flag 0 245a : 4930 > eor #0|fao ;invert expected flags + always on bits > 245c : dd3802 > cmp fLSR,x ;test flags > trap_ne 245f : d0fe > bne * ;failed not equal (non zero) > 2461 : ca dex 2462 : 10e3 bpl tlsr2 2464 : a203 ldx #3 2466 : tlsr3 set_z zp1,$ff > load_flag $ff 2466 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2468 : 48 > pha ;use stack to load status 2469 : b513 > lda zp1,x ;load to zeropage 246b : 850c > sta zpt 246d : 28 > plp 246e : 460c lsr zpt tst_z rLSR,fLSR,$ff-fnzc 2470 : 08 > php ;save flags 2471 : a50c > lda zpt 2473 : dd2802 > cmp rLSR,x ;test result > trap_ne 2476 : d0fe > bne * ;failed not equal (non zero) > 2478 : 68 > pla ;load status > eor_flag $ff-fnzc 2479 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 247b : dd3802 > cmp fLSR,x ;test flags > trap_ne 247e : d0fe > bne * ;failed not equal (non zero) > 2480 : ca dex 2481 : 10e3 bpl tlsr3 2483 : a203 ldx #3 2485 : trol2 set_z zp1,0 > load_flag 0 2485 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2487 : 48 > pha ;use stack to load status 2488 : b513 > lda zp1,x ;load to zeropage 248a : 850c > sta zpt 248c : 28 > plp 248d : 260c rol zpt tst_z rROL,fROL,0 248f : 08 > php ;save flags 2490 : a50c > lda zpt 2492 : dd2002 > cmp rROL,x ;test result > trap_ne 2495 : d0fe > bne * ;failed not equal (non zero) > 2497 : 68 > pla ;load status > eor_flag 0 2498 : 4930 > eor #0|fao ;invert expected flags + always on bits > 249a : dd3002 > cmp fROL,x ;test flags > trap_ne 249d : d0fe > bne * ;failed not equal (non zero) > 249f : ca dex 24a0 : 10e3 bpl trol2 24a2 : a203 ldx #3 24a4 : trol3 set_z zp1,$ff-fc > load_flag $ff-fc 24a4 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) > 24a6 : 48 > pha ;use stack to load status 24a7 : b513 > lda zp1,x ;load to zeropage 24a9 : 850c > sta zpt 24ab : 28 > plp 24ac : 260c rol zpt tst_z rROL,fROL,$ff-fnzc 24ae : 08 > php ;save flags 24af : a50c > lda zpt 24b1 : dd2002 > cmp rROL,x ;test result > trap_ne 24b4 : d0fe > bne * ;failed not equal (non zero) > 24b6 : 68 > pla ;load status > eor_flag $ff-fnzc 24b7 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 24b9 : dd3002 > cmp fROL,x ;test flags > trap_ne 24bc : d0fe > bne * ;failed not equal (non zero) > 24be : ca dex 24bf : 10e3 bpl trol3 24c1 : a203 ldx #3 24c3 : trolc2 set_z zp1,fc > load_flag fc 24c3 : a901 > lda #fc ;allow test to change I-flag (no mask) > 24c5 : 48 > pha ;use stack to load status 24c6 : b513 > lda zp1,x ;load to zeropage 24c8 : 850c > sta zpt 24ca : 28 > plp 24cb : 260c rol zpt tst_z rROLc,fROLc,0 24cd : 08 > php ;save flags 24ce : a50c > lda zpt 24d0 : dd2402 > cmp rROLc,x ;test result > trap_ne 24d3 : d0fe > bne * ;failed not equal (non zero) > 24d5 : 68 > pla ;load status > eor_flag 0 24d6 : 4930 > eor #0|fao ;invert expected flags + always on bits > 24d8 : dd3402 > cmp fROLc,x ;test flags > trap_ne 24db : d0fe > bne * ;failed not equal (non zero) > 24dd : ca dex 24de : 10e3 bpl trolc2 24e0 : a203 ldx #3 24e2 : trolc3 set_z zp1,$ff > load_flag $ff 24e2 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 24e4 : 48 > pha ;use stack to load status 24e5 : b513 > lda zp1,x ;load to zeropage 24e7 : 850c > sta zpt 24e9 : 28 > plp 24ea : 260c rol zpt tst_z rROLc,fROLc,$ff-fnzc 24ec : 08 > php ;save flags 24ed : a50c > lda zpt 24ef : dd2402 > cmp rROLc,x ;test result > trap_ne 24f2 : d0fe > bne * ;failed not equal (non zero) > 24f4 : 68 > pla ;load status > eor_flag $ff-fnzc 24f5 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 24f7 : dd3402 > cmp fROLc,x ;test flags > trap_ne 24fa : d0fe > bne * ;failed not equal (non zero) > 24fc : ca dex 24fd : 10e3 bpl trolc3 24ff : a203 ldx #3 2501 : tror2 set_z zp1,0 > load_flag 0 2501 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2503 : 48 > pha ;use stack to load status 2504 : b513 > lda zp1,x ;load to zeropage 2506 : 850c > sta zpt 2508 : 28 > plp 2509 : 660c ror zpt tst_z rROR,fROR,0 250b : 08 > php ;save flags 250c : a50c > lda zpt 250e : dd2802 > cmp rROR,x ;test result > trap_ne 2511 : d0fe > bne * ;failed not equal (non zero) > 2513 : 68 > pla ;load status > eor_flag 0 2514 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2516 : dd3802 > cmp fROR,x ;test flags > trap_ne 2519 : d0fe > bne * ;failed not equal (non zero) > 251b : ca dex 251c : 10e3 bpl tror2 251e : a203 ldx #3 2520 : tror3 set_z zp1,$ff-fc > load_flag $ff-fc 2520 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) > 2522 : 48 > pha ;use stack to load status 2523 : b513 > lda zp1,x ;load to zeropage 2525 : 850c > sta zpt 2527 : 28 > plp 2528 : 660c ror zpt tst_z rROR,fROR,$ff-fnzc 252a : 08 > php ;save flags 252b : a50c > lda zpt 252d : dd2802 > cmp rROR,x ;test result > trap_ne 2530 : d0fe > bne * ;failed not equal (non zero) > 2532 : 68 > pla ;load status > eor_flag $ff-fnzc 2533 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2535 : dd3802 > cmp fROR,x ;test flags > trap_ne 2538 : d0fe > bne * ;failed not equal (non zero) > 253a : ca dex 253b : 10e3 bpl tror3 253d : a203 ldx #3 253f : trorc2 set_z zp1,fc > load_flag fc 253f : a901 > lda #fc ;allow test to change I-flag (no mask) > 2541 : 48 > pha ;use stack to load status 2542 : b513 > lda zp1,x ;load to zeropage 2544 : 850c > sta zpt 2546 : 28 > plp 2547 : 660c ror zpt tst_z rRORc,fRORc,0 2549 : 08 > php ;save flags 254a : a50c > lda zpt 254c : dd2c02 > cmp rRORc,x ;test result > trap_ne 254f : d0fe > bne * ;failed not equal (non zero) > 2551 : 68 > pla ;load status > eor_flag 0 2552 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2554 : dd3c02 > cmp fRORc,x ;test flags > trap_ne 2557 : d0fe > bne * ;failed not equal (non zero) > 2559 : ca dex 255a : 10e3 bpl trorc2 255c : a203 ldx #3 255e : trorc3 set_z zp1,$ff > load_flag $ff 255e : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2560 : 48 > pha ;use stack to load status 2561 : b513 > lda zp1,x ;load to zeropage 2563 : 850c > sta zpt 2565 : 28 > plp 2566 : 660c ror zpt tst_z rRORc,fRORc,$ff-fnzc 2568 : 08 > php ;save flags 2569 : a50c > lda zpt 256b : dd2c02 > cmp rRORc,x ;test result > trap_ne 256e : d0fe > bne * ;failed not equal (non zero) > 2570 : 68 > pla ;load status > eor_flag $ff-fnzc 2571 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2573 : dd3c02 > cmp fRORc,x ;test flags > trap_ne 2576 : d0fe > bne * ;failed not equal (non zero) > 2578 : ca dex 2579 : 10e3 bpl trorc3 next_test 257b : ad0002 > lda test_case ;previous test 257e : c91e > cmp #test_num > trap_ne ;test is out of sequence 2580 : d0fe > bne * ;failed not equal (non zero) > 001f = >test_num = test_num + 1 2582 : a91f > lda #test_num ;*** next tests' number 2584 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; shifts - absolute 2587 : a203 ldx #3 2589 : tasl4 set_abs zp1,0 > load_flag 0 2589 : a900 > lda #0 ;allow test to change I-flag (no mask) > 258b : 48 > pha ;use stack to load status 258c : b513 > lda zp1,x ;load to memory 258e : 8d0302 > sta abst 2591 : 28 > plp 2592 : 0e0302 asl abst tst_abs rASL,fASL,0 2595 : 08 > php ;save flags 2596 : ad0302 > lda abst 2599 : dd2002 > cmp rASL,x ;test result > trap_ne 259c : d0fe > bne * ;failed not equal (non zero) > 259e : 68 > pla ;load status > eor_flag 0 259f : 4930 > eor #0|fao ;invert expected flags + always on bits > 25a1 : dd3002 > cmp fASL,x ;test flags > trap_ne 25a4 : d0fe > bne * ;failed not equal (non zero) > 25a6 : ca dex 25a7 : 10e0 bpl tasl4 25a9 : a203 ldx #3 25ab : tasl5 set_abs zp1,$ff > load_flag $ff 25ab : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 25ad : 48 > pha ;use stack to load status 25ae : b513 > lda zp1,x ;load to memory 25b0 : 8d0302 > sta abst 25b3 : 28 > plp 25b4 : 0e0302 asl abst tst_abs rASL,fASL,$ff-fnzc 25b7 : 08 > php ;save flags 25b8 : ad0302 > lda abst 25bb : dd2002 > cmp rASL,x ;test result > trap_ne 25be : d0fe > bne * ;failed not equal (non zero) > 25c0 : 68 > pla ;load status > eor_flag $ff-fnzc 25c1 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 25c3 : dd3002 > cmp fASL,x ;test flags > trap_ne 25c6 : d0fe > bne * ;failed not equal (non zero) > 25c8 : ca dex 25c9 : 10e0 bpl tasl5 25cb : a203 ldx #3 25cd : tlsr4 set_abs zp1,0 > load_flag 0 25cd : a900 > lda #0 ;allow test to change I-flag (no mask) > 25cf : 48 > pha ;use stack to load status 25d0 : b513 > lda zp1,x ;load to memory 25d2 : 8d0302 > sta abst 25d5 : 28 > plp 25d6 : 4e0302 lsr abst tst_abs rLSR,fLSR,0 25d9 : 08 > php ;save flags 25da : ad0302 > lda abst 25dd : dd2802 > cmp rLSR,x ;test result > trap_ne 25e0 : d0fe > bne * ;failed not equal (non zero) > 25e2 : 68 > pla ;load status > eor_flag 0 25e3 : 4930 > eor #0|fao ;invert expected flags + always on bits > 25e5 : dd3802 > cmp fLSR,x ;test flags > trap_ne 25e8 : d0fe > bne * ;failed not equal (non zero) > 25ea : ca dex 25eb : 10e0 bpl tlsr4 25ed : a203 ldx #3 25ef : tlsr5 set_abs zp1,$ff > load_flag $ff 25ef : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 25f1 : 48 > pha ;use stack to load status 25f2 : b513 > lda zp1,x ;load to memory 25f4 : 8d0302 > sta abst 25f7 : 28 > plp 25f8 : 4e0302 lsr abst tst_abs rLSR,fLSR,$ff-fnzc 25fb : 08 > php ;save flags 25fc : ad0302 > lda abst 25ff : dd2802 > cmp rLSR,x ;test result > trap_ne 2602 : d0fe > bne * ;failed not equal (non zero) > 2604 : 68 > pla ;load status > eor_flag $ff-fnzc 2605 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2607 : dd3802 > cmp fLSR,x ;test flags > trap_ne 260a : d0fe > bne * ;failed not equal (non zero) > 260c : ca dex 260d : 10e0 bpl tlsr5 260f : a203 ldx #3 2611 : trol4 set_abs zp1,0 > load_flag 0 2611 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2613 : 48 > pha ;use stack to load status 2614 : b513 > lda zp1,x ;load to memory 2616 : 8d0302 > sta abst 2619 : 28 > plp 261a : 2e0302 rol abst tst_abs rROL,fROL,0 261d : 08 > php ;save flags 261e : ad0302 > lda abst 2621 : dd2002 > cmp rROL,x ;test result > trap_ne 2624 : d0fe > bne * ;failed not equal (non zero) > 2626 : 68 > pla ;load status > eor_flag 0 2627 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2629 : dd3002 > cmp fROL,x ;test flags > trap_ne 262c : d0fe > bne * ;failed not equal (non zero) > 262e : ca dex 262f : 10e0 bpl trol4 2631 : a203 ldx #3 2633 : trol5 set_abs zp1,$ff-fc > load_flag $ff-fc 2633 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) > 2635 : 48 > pha ;use stack to load status 2636 : b513 > lda zp1,x ;load to memory 2638 : 8d0302 > sta abst 263b : 28 > plp 263c : 2e0302 rol abst tst_abs rROL,fROL,$ff-fnzc 263f : 08 > php ;save flags 2640 : ad0302 > lda abst 2643 : dd2002 > cmp rROL,x ;test result > trap_ne 2646 : d0fe > bne * ;failed not equal (non zero) > 2648 : 68 > pla ;load status > eor_flag $ff-fnzc 2649 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 264b : dd3002 > cmp fROL,x ;test flags > trap_ne 264e : d0fe > bne * ;failed not equal (non zero) > 2650 : ca dex 2651 : 10e0 bpl trol5 2653 : a203 ldx #3 2655 : trolc4 set_abs zp1,fc > load_flag fc 2655 : a901 > lda #fc ;allow test to change I-flag (no mask) > 2657 : 48 > pha ;use stack to load status 2658 : b513 > lda zp1,x ;load to memory 265a : 8d0302 > sta abst 265d : 28 > plp 265e : 2e0302 rol abst tst_abs rROLc,fROLc,0 2661 : 08 > php ;save flags 2662 : ad0302 > lda abst 2665 : dd2402 > cmp rROLc,x ;test result > trap_ne 2668 : d0fe > bne * ;failed not equal (non zero) > 266a : 68 > pla ;load status > eor_flag 0 266b : 4930 > eor #0|fao ;invert expected flags + always on bits > 266d : dd3402 > cmp fROLc,x ;test flags > trap_ne 2670 : d0fe > bne * ;failed not equal (non zero) > 2672 : ca dex 2673 : 10e0 bpl trolc4 2675 : a203 ldx #3 2677 : trolc5 set_abs zp1,$ff > load_flag $ff 2677 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2679 : 48 > pha ;use stack to load status 267a : b513 > lda zp1,x ;load to memory 267c : 8d0302 > sta abst 267f : 28 > plp 2680 : 2e0302 rol abst tst_abs rROLc,fROLc,$ff-fnzc 2683 : 08 > php ;save flags 2684 : ad0302 > lda abst 2687 : dd2402 > cmp rROLc,x ;test result > trap_ne 268a : d0fe > bne * ;failed not equal (non zero) > 268c : 68 > pla ;load status > eor_flag $ff-fnzc 268d : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 268f : dd3402 > cmp fROLc,x ;test flags > trap_ne 2692 : d0fe > bne * ;failed not equal (non zero) > 2694 : ca dex 2695 : 10e0 bpl trolc5 2697 : a203 ldx #3 2699 : tror4 set_abs zp1,0 > load_flag 0 2699 : a900 > lda #0 ;allow test to change I-flag (no mask) > 269b : 48 > pha ;use stack to load status 269c : b513 > lda zp1,x ;load to memory 269e : 8d0302 > sta abst 26a1 : 28 > plp 26a2 : 6e0302 ror abst tst_abs rROR,fROR,0 26a5 : 08 > php ;save flags 26a6 : ad0302 > lda abst 26a9 : dd2802 > cmp rROR,x ;test result > trap_ne 26ac : d0fe > bne * ;failed not equal (non zero) > 26ae : 68 > pla ;load status > eor_flag 0 26af : 4930 > eor #0|fao ;invert expected flags + always on bits > 26b1 : dd3802 > cmp fROR,x ;test flags > trap_ne 26b4 : d0fe > bne * ;failed not equal (non zero) > 26b6 : ca dex 26b7 : 10e0 bpl tror4 26b9 : a203 ldx #3 26bb : tror5 set_abs zp1,$ff-fc > load_flag $ff-fc 26bb : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) > 26bd : 48 > pha ;use stack to load status 26be : b513 > lda zp1,x ;load to memory 26c0 : 8d0302 > sta abst 26c3 : 28 > plp 26c4 : 6e0302 ror abst tst_abs rROR,fROR,$ff-fnzc 26c7 : 08 > php ;save flags 26c8 : ad0302 > lda abst 26cb : dd2802 > cmp rROR,x ;test result > trap_ne 26ce : d0fe > bne * ;failed not equal (non zero) > 26d0 : 68 > pla ;load status > eor_flag $ff-fnzc 26d1 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 26d3 : dd3802 > cmp fROR,x ;test flags > trap_ne 26d6 : d0fe > bne * ;failed not equal (non zero) > 26d8 : ca dex 26d9 : 10e0 bpl tror5 26db : a203 ldx #3 26dd : trorc4 set_abs zp1,fc > load_flag fc 26dd : a901 > lda #fc ;allow test to change I-flag (no mask) > 26df : 48 > pha ;use stack to load status 26e0 : b513 > lda zp1,x ;load to memory 26e2 : 8d0302 > sta abst 26e5 : 28 > plp 26e6 : 6e0302 ror abst tst_abs rRORc,fRORc,0 26e9 : 08 > php ;save flags 26ea : ad0302 > lda abst 26ed : dd2c02 > cmp rRORc,x ;test result > trap_ne 26f0 : d0fe > bne * ;failed not equal (non zero) > 26f2 : 68 > pla ;load status > eor_flag 0 26f3 : 4930 > eor #0|fao ;invert expected flags + always on bits > 26f5 : dd3c02 > cmp fRORc,x ;test flags > trap_ne 26f8 : d0fe > bne * ;failed not equal (non zero) > 26fa : ca dex 26fb : 10e0 bpl trorc4 26fd : a203 ldx #3 26ff : trorc5 set_abs zp1,$ff > load_flag $ff 26ff : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2701 : 48 > pha ;use stack to load status 2702 : b513 > lda zp1,x ;load to memory 2704 : 8d0302 > sta abst 2707 : 28 > plp 2708 : 6e0302 ror abst tst_abs rRORc,fRORc,$ff-fnzc 270b : 08 > php ;save flags 270c : ad0302 > lda abst 270f : dd2c02 > cmp rRORc,x ;test result > trap_ne 2712 : d0fe > bne * ;failed not equal (non zero) > 2714 : 68 > pla ;load status > eor_flag $ff-fnzc 2715 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2717 : dd3c02 > cmp fRORc,x ;test flags > trap_ne 271a : d0fe > bne * ;failed not equal (non zero) > 271c : ca dex 271d : 10e0 bpl trorc5 next_test 271f : ad0002 > lda test_case ;previous test 2722 : c91f > cmp #test_num > trap_ne ;test is out of sequence 2724 : d0fe > bne * ;failed not equal (non zero) > 0020 = >test_num = test_num + 1 2726 : a920 > lda #test_num ;*** next tests' number 2728 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; shifts - zp indexed 272b : a203 ldx #3 272d : tasl6 set_zx 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 : b513 > lda zp1,x ;load to indexed zeropage 2732 : 950c > sta zpt,x 2734 : 28 > plp 2735 : 160c asl zpt,x tst_zx rASL,fASL,0 2737 : 08 > php ;save flags 2738 : b50c > lda zpt,x 273a : dd2002 > cmp rASL,x ;test result > trap_ne 273d : d0fe > bne * ;failed not equal (non zero) > 273f : 68 > pla ;load status > eor_flag 0 2740 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2742 : dd3002 > cmp fASL,x ;test flags > trap_ne 2745 : d0fe > bne * ;failed not equal (non zero) > 2747 : ca dex 2748 : 10e3 bpl tasl6 274a : a203 ldx #3 274c : tasl7 set_zx zp1,$ff > load_flag $ff 274c : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 274e : 48 > pha ;use stack to load status 274f : b513 > lda zp1,x ;load to indexed zeropage 2751 : 950c > sta zpt,x 2753 : 28 > plp 2754 : 160c asl zpt,x tst_zx rASL,fASL,$ff-fnzc 2756 : 08 > php ;save flags 2757 : b50c > lda zpt,x 2759 : dd2002 > cmp rASL,x ;test result > trap_ne 275c : d0fe > bne * ;failed not equal (non zero) > 275e : 68 > pla ;load status > eor_flag $ff-fnzc 275f : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2761 : dd3002 > cmp fASL,x ;test flags > trap_ne 2764 : d0fe > bne * ;failed not equal (non zero) > 2766 : ca dex 2767 : 10e3 bpl tasl7 2769 : a203 ldx #3 276b : tlsr6 set_zx zp1,0 > load_flag 0 276b : a900 > lda #0 ;allow test to change I-flag (no mask) > 276d : 48 > pha ;use stack to load status 276e : b513 > lda zp1,x ;load to indexed zeropage 2770 : 950c > sta zpt,x 2772 : 28 > plp 2773 : 560c lsr zpt,x tst_zx rLSR,fLSR,0 2775 : 08 > php ;save flags 2776 : b50c > lda zpt,x 2778 : dd2802 > cmp rLSR,x ;test result > trap_ne 277b : d0fe > bne * ;failed not equal (non zero) > 277d : 68 > pla ;load status > eor_flag 0 277e : 4930 > eor #0|fao ;invert expected flags + always on bits > 2780 : dd3802 > cmp fLSR,x ;test flags > trap_ne 2783 : d0fe > bne * ;failed not equal (non zero) > 2785 : ca dex 2786 : 10e3 bpl tlsr6 2788 : a203 ldx #3 278a : tlsr7 set_zx zp1,$ff > load_flag $ff 278a : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 278c : 48 > pha ;use stack to load status 278d : b513 > lda zp1,x ;load to indexed zeropage 278f : 950c > sta zpt,x 2791 : 28 > plp 2792 : 560c lsr zpt,x tst_zx rLSR,fLSR,$ff-fnzc 2794 : 08 > php ;save flags 2795 : b50c > lda zpt,x 2797 : dd2802 > cmp rLSR,x ;test result > trap_ne 279a : d0fe > bne * ;failed not equal (non zero) > 279c : 68 > pla ;load status > eor_flag $ff-fnzc 279d : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 279f : dd3802 > cmp fLSR,x ;test flags > trap_ne 27a2 : d0fe > bne * ;failed not equal (non zero) > 27a4 : ca dex 27a5 : 10e3 bpl tlsr7 27a7 : a203 ldx #3 27a9 : trol6 set_zx zp1,0 > load_flag 0 27a9 : a900 > lda #0 ;allow test to change I-flag (no mask) > 27ab : 48 > pha ;use stack to load status 27ac : b513 > lda zp1,x ;load to indexed zeropage 27ae : 950c > sta zpt,x 27b0 : 28 > plp 27b1 : 360c rol zpt,x tst_zx rROL,fROL,0 27b3 : 08 > php ;save flags 27b4 : b50c > lda zpt,x 27b6 : dd2002 > cmp rROL,x ;test result > trap_ne 27b9 : d0fe > bne * ;failed not equal (non zero) > 27bb : 68 > pla ;load status > eor_flag 0 27bc : 4930 > eor #0|fao ;invert expected flags + always on bits > 27be : dd3002 > cmp fROL,x ;test flags > trap_ne 27c1 : d0fe > bne * ;failed not equal (non zero) > 27c3 : ca dex 27c4 : 10e3 bpl trol6 27c6 : a203 ldx #3 27c8 : trol7 set_zx zp1,$ff-fc > load_flag $ff-fc 27c8 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) > 27ca : 48 > pha ;use stack to load status 27cb : b513 > lda zp1,x ;load to indexed zeropage 27cd : 950c > sta zpt,x 27cf : 28 > plp 27d0 : 360c rol zpt,x tst_zx rROL,fROL,$ff-fnzc 27d2 : 08 > php ;save flags 27d3 : b50c > lda zpt,x 27d5 : dd2002 > cmp rROL,x ;test result > trap_ne 27d8 : d0fe > bne * ;failed not equal (non zero) > 27da : 68 > pla ;load status > eor_flag $ff-fnzc 27db : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 27dd : dd3002 > cmp fROL,x ;test flags > trap_ne 27e0 : d0fe > bne * ;failed not equal (non zero) > 27e2 : ca dex 27e3 : 10e3 bpl trol7 27e5 : a203 ldx #3 27e7 : trolc6 set_zx zp1,fc > load_flag fc 27e7 : a901 > lda #fc ;allow test to change I-flag (no mask) > 27e9 : 48 > pha ;use stack to load status 27ea : b513 > lda zp1,x ;load to indexed zeropage 27ec : 950c > sta zpt,x 27ee : 28 > plp 27ef : 360c rol zpt,x tst_zx rROLc,fROLc,0 27f1 : 08 > php ;save flags 27f2 : b50c > lda zpt,x 27f4 : dd2402 > cmp rROLc,x ;test result > trap_ne 27f7 : d0fe > bne * ;failed not equal (non zero) > 27f9 : 68 > pla ;load status > eor_flag 0 27fa : 4930 > eor #0|fao ;invert expected flags + always on bits > 27fc : dd3402 > cmp fROLc,x ;test flags > trap_ne 27ff : d0fe > bne * ;failed not equal (non zero) > 2801 : ca dex 2802 : 10e3 bpl trolc6 2804 : a203 ldx #3 2806 : trolc7 set_zx zp1,$ff > load_flag $ff 2806 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2808 : 48 > pha ;use stack to load status 2809 : b513 > lda zp1,x ;load to indexed zeropage 280b : 950c > sta zpt,x 280d : 28 > plp 280e : 360c rol zpt,x tst_zx rROLc,fROLc,$ff-fnzc 2810 : 08 > php ;save flags 2811 : b50c > lda zpt,x 2813 : dd2402 > cmp rROLc,x ;test result > trap_ne 2816 : d0fe > bne * ;failed not equal (non zero) > 2818 : 68 > pla ;load status > eor_flag $ff-fnzc 2819 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 281b : dd3402 > cmp fROLc,x ;test flags > trap_ne 281e : d0fe > bne * ;failed not equal (non zero) > 2820 : ca dex 2821 : 10e3 bpl trolc7 2823 : a203 ldx #3 2825 : tror6 set_zx zp1,0 > load_flag 0 2825 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2827 : 48 > pha ;use stack to load status 2828 : b513 > lda zp1,x ;load to indexed zeropage 282a : 950c > sta zpt,x 282c : 28 > plp 282d : 760c ror zpt,x tst_zx rROR,fROR,0 282f : 08 > php ;save flags 2830 : b50c > lda zpt,x 2832 : dd2802 > cmp rROR,x ;test result > trap_ne 2835 : d0fe > bne * ;failed not equal (non zero) > 2837 : 68 > pla ;load status > eor_flag 0 2838 : 4930 > eor #0|fao ;invert expected flags + always on bits > 283a : dd3802 > cmp fROR,x ;test flags > trap_ne 283d : d0fe > bne * ;failed not equal (non zero) > 283f : ca dex 2840 : 10e3 bpl tror6 2842 : a203 ldx #3 2844 : tror7 set_zx zp1,$ff-fc > load_flag $ff-fc 2844 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) > 2846 : 48 > pha ;use stack to load status 2847 : b513 > lda zp1,x ;load to indexed zeropage 2849 : 950c > sta zpt,x 284b : 28 > plp 284c : 760c ror zpt,x tst_zx rROR,fROR,$ff-fnzc 284e : 08 > php ;save flags 284f : b50c > lda zpt,x 2851 : dd2802 > cmp rROR,x ;test result > trap_ne 2854 : d0fe > bne * ;failed not equal (non zero) > 2856 : 68 > pla ;load status > eor_flag $ff-fnzc 2857 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2859 : dd3802 > cmp fROR,x ;test flags > trap_ne 285c : d0fe > bne * ;failed not equal (non zero) > 285e : ca dex 285f : 10e3 bpl tror7 2861 : a203 ldx #3 2863 : trorc6 set_zx zp1,fc > load_flag fc 2863 : a901 > lda #fc ;allow test to change I-flag (no mask) > 2865 : 48 > pha ;use stack to load status 2866 : b513 > lda zp1,x ;load to indexed zeropage 2868 : 950c > sta zpt,x 286a : 28 > plp 286b : 760c ror zpt,x tst_zx rRORc,fRORc,0 286d : 08 > php ;save flags 286e : b50c > lda zpt,x 2870 : dd2c02 > cmp rRORc,x ;test result > trap_ne 2873 : d0fe > bne * ;failed not equal (non zero) > 2875 : 68 > pla ;load status > eor_flag 0 2876 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2878 : dd3c02 > cmp fRORc,x ;test flags > trap_ne 287b : d0fe > bne * ;failed not equal (non zero) > 287d : ca dex 287e : 10e3 bpl trorc6 2880 : a203 ldx #3 2882 : trorc7 set_zx zp1,$ff > load_flag $ff 2882 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2884 : 48 > pha ;use stack to load status 2885 : b513 > lda zp1,x ;load to indexed zeropage 2887 : 950c > sta zpt,x 2889 : 28 > plp 288a : 760c ror zpt,x tst_zx rRORc,fRORc,$ff-fnzc 288c : 08 > php ;save flags 288d : b50c > lda zpt,x 288f : dd2c02 > cmp rRORc,x ;test result > trap_ne 2892 : d0fe > bne * ;failed not equal (non zero) > 2894 : 68 > pla ;load status > eor_flag $ff-fnzc 2895 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2897 : dd3c02 > cmp fRORc,x ;test flags > trap_ne 289a : d0fe > bne * ;failed not equal (non zero) > 289c : ca dex 289d : 10e3 bpl trorc7 next_test 289f : ad0002 > lda test_case ;previous test 28a2 : c920 > cmp #test_num > trap_ne ;test is out of sequence 28a4 : d0fe > bne * ;failed not equal (non zero) > 0021 = >test_num = test_num + 1 28a6 : a921 > lda #test_num ;*** next tests' number 28a8 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; shifts - abs indexed 28ab : a203 ldx #3 28ad : tasl8 set_absx zp1,0 > load_flag 0 28ad : a900 > lda #0 ;allow test to change I-flag (no mask) > 28af : 48 > pha ;use stack to load status 28b0 : b513 > lda zp1,x ;load to indexed memory 28b2 : 9d0302 > sta abst,x 28b5 : 28 > plp 28b6 : 1e0302 asl abst,x tst_absx rASL,fASL,0 28b9 : 08 > php ;save flags 28ba : bd0302 > lda abst,x 28bd : dd2002 > cmp rASL,x ;test result > trap_ne 28c0 : d0fe > bne * ;failed not equal (non zero) > 28c2 : 68 > pla ;load status > eor_flag 0 28c3 : 4930 > eor #0|fao ;invert expected flags + always on bits > 28c5 : dd3002 > cmp fASL,x ;test flags > trap_ne 28c8 : d0fe > bne * ;failed not equal (non zero) > 28ca : ca dex 28cb : 10e0 bpl tasl8 28cd : a203 ldx #3 28cf : tasl9 set_absx zp1,$ff > load_flag $ff 28cf : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 28d1 : 48 > pha ;use stack to load status 28d2 : b513 > lda zp1,x ;load to indexed memory 28d4 : 9d0302 > sta abst,x 28d7 : 28 > plp 28d8 : 1e0302 asl abst,x tst_absx rASL,fASL,$ff-fnzc 28db : 08 > php ;save flags 28dc : bd0302 > lda abst,x 28df : dd2002 > cmp rASL,x ;test result > trap_ne 28e2 : d0fe > bne * ;failed not equal (non zero) > 28e4 : 68 > pla ;load status > eor_flag $ff-fnzc 28e5 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 28e7 : dd3002 > cmp fASL,x ;test flags > trap_ne 28ea : d0fe > bne * ;failed not equal (non zero) > 28ec : ca dex 28ed : 10e0 bpl tasl9 28ef : a203 ldx #3 28f1 : tlsr8 set_absx zp1,0 > load_flag 0 28f1 : a900 > lda #0 ;allow test to change I-flag (no mask) > 28f3 : 48 > pha ;use stack to load status 28f4 : b513 > lda zp1,x ;load to indexed memory 28f6 : 9d0302 > sta abst,x 28f9 : 28 > plp 28fa : 5e0302 lsr abst,x tst_absx rLSR,fLSR,0 28fd : 08 > php ;save flags 28fe : bd0302 > lda abst,x 2901 : dd2802 > cmp rLSR,x ;test result > trap_ne 2904 : d0fe > bne * ;failed not equal (non zero) > 2906 : 68 > pla ;load status > eor_flag 0 2907 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2909 : dd3802 > cmp fLSR,x ;test flags > trap_ne 290c : d0fe > bne * ;failed not equal (non zero) > 290e : ca dex 290f : 10e0 bpl tlsr8 2911 : a203 ldx #3 2913 : tlsr9 set_absx zp1,$ff > load_flag $ff 2913 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2915 : 48 > pha ;use stack to load status 2916 : b513 > lda zp1,x ;load to indexed memory 2918 : 9d0302 > sta abst,x 291b : 28 > plp 291c : 5e0302 lsr abst,x tst_absx rLSR,fLSR,$ff-fnzc 291f : 08 > php ;save flags 2920 : bd0302 > lda abst,x 2923 : dd2802 > cmp rLSR,x ;test result > trap_ne 2926 : d0fe > bne * ;failed not equal (non zero) > 2928 : 68 > pla ;load status > eor_flag $ff-fnzc 2929 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 292b : dd3802 > cmp fLSR,x ;test flags > trap_ne 292e : d0fe > bne * ;failed not equal (non zero) > 2930 : ca dex 2931 : 10e0 bpl tlsr9 2933 : a203 ldx #3 2935 : trol8 set_absx zp1,0 > load_flag 0 2935 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2937 : 48 > pha ;use stack to load status 2938 : b513 > lda zp1,x ;load to indexed memory 293a : 9d0302 > sta abst,x 293d : 28 > plp 293e : 3e0302 rol abst,x tst_absx rROL,fROL,0 2941 : 08 > php ;save flags 2942 : bd0302 > lda abst,x 2945 : dd2002 > cmp rROL,x ;test result > trap_ne 2948 : d0fe > bne * ;failed not equal (non zero) > 294a : 68 > pla ;load status > eor_flag 0 294b : 4930 > eor #0|fao ;invert expected flags + always on bits > 294d : dd3002 > cmp fROL,x ;test flags > trap_ne 2950 : d0fe > bne * ;failed not equal (non zero) > 2952 : ca dex 2953 : 10e0 bpl trol8 2955 : a203 ldx #3 2957 : trol9 set_absx zp1,$ff-fc > load_flag $ff-fc 2957 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) > 2959 : 48 > pha ;use stack to load status 295a : b513 > lda zp1,x ;load to indexed memory 295c : 9d0302 > sta abst,x 295f : 28 > plp 2960 : 3e0302 rol abst,x tst_absx rROL,fROL,$ff-fnzc 2963 : 08 > php ;save flags 2964 : bd0302 > lda abst,x 2967 : dd2002 > cmp rROL,x ;test result > trap_ne 296a : d0fe > bne * ;failed not equal (non zero) > 296c : 68 > pla ;load status > eor_flag $ff-fnzc 296d : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 296f : dd3002 > cmp fROL,x ;test flags > trap_ne 2972 : d0fe > bne * ;failed not equal (non zero) > 2974 : ca dex 2975 : 10e0 bpl trol9 2977 : a203 ldx #3 2979 : trolc8 set_absx zp1,fc > load_flag fc 2979 : a901 > lda #fc ;allow test to change I-flag (no mask) > 297b : 48 > pha ;use stack to load status 297c : b513 > lda zp1,x ;load to indexed memory 297e : 9d0302 > sta abst,x 2981 : 28 > plp 2982 : 3e0302 rol abst,x tst_absx rROLc,fROLc,0 2985 : 08 > php ;save flags 2986 : bd0302 > lda abst,x 2989 : dd2402 > cmp rROLc,x ;test result > trap_ne 298c : d0fe > bne * ;failed not equal (non zero) > 298e : 68 > pla ;load status > eor_flag 0 298f : 4930 > eor #0|fao ;invert expected flags + always on bits > 2991 : dd3402 > cmp fROLc,x ;test flags > trap_ne 2994 : d0fe > bne * ;failed not equal (non zero) > 2996 : ca dex 2997 : 10e0 bpl trolc8 2999 : a203 ldx #3 299b : trolc9 set_absx zp1,$ff > load_flag $ff 299b : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 299d : 48 > pha ;use stack to load status 299e : b513 > lda zp1,x ;load to indexed memory 29a0 : 9d0302 > sta abst,x 29a3 : 28 > plp 29a4 : 3e0302 rol abst,x tst_absx rROLc,fROLc,$ff-fnzc 29a7 : 08 > php ;save flags 29a8 : bd0302 > lda abst,x 29ab : dd2402 > cmp rROLc,x ;test result > trap_ne 29ae : d0fe > bne * ;failed not equal (non zero) > 29b0 : 68 > pla ;load status > eor_flag $ff-fnzc 29b1 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 29b3 : dd3402 > cmp fROLc,x ;test flags > trap_ne 29b6 : d0fe > bne * ;failed not equal (non zero) > 29b8 : ca dex 29b9 : 10e0 bpl trolc9 29bb : a203 ldx #3 29bd : tror8 set_absx zp1,0 > load_flag 0 29bd : a900 > lda #0 ;allow test to change I-flag (no mask) > 29bf : 48 > pha ;use stack to load status 29c0 : b513 > lda zp1,x ;load to indexed memory 29c2 : 9d0302 > sta abst,x 29c5 : 28 > plp 29c6 : 7e0302 ror abst,x tst_absx rROR,fROR,0 29c9 : 08 > php ;save flags 29ca : bd0302 > lda abst,x 29cd : dd2802 > cmp rROR,x ;test result > trap_ne 29d0 : d0fe > bne * ;failed not equal (non zero) > 29d2 : 68 > pla ;load status > eor_flag 0 29d3 : 4930 > eor #0|fao ;invert expected flags + always on bits > 29d5 : dd3802 > cmp fROR,x ;test flags > trap_ne 29d8 : d0fe > bne * ;failed not equal (non zero) > 29da : ca dex 29db : 10e0 bpl tror8 29dd : a203 ldx #3 29df : tror9 set_absx zp1,$ff-fc > load_flag $ff-fc 29df : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) > 29e1 : 48 > pha ;use stack to load status 29e2 : b513 > lda zp1,x ;load to indexed memory 29e4 : 9d0302 > sta abst,x 29e7 : 28 > plp 29e8 : 7e0302 ror abst,x tst_absx rROR,fROR,$ff-fnzc 29eb : 08 > php ;save flags 29ec : bd0302 > lda abst,x 29ef : dd2802 > cmp rROR,x ;test result > trap_ne 29f2 : d0fe > bne * ;failed not equal (non zero) > 29f4 : 68 > pla ;load status > eor_flag $ff-fnzc 29f5 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 29f7 : dd3802 > cmp fROR,x ;test flags > trap_ne 29fa : d0fe > bne * ;failed not equal (non zero) > 29fc : ca dex 29fd : 10e0 bpl tror9 29ff : a203 ldx #3 2a01 : trorc8 set_absx zp1,fc > load_flag fc 2a01 : a901 > lda #fc ;allow test to change I-flag (no mask) > 2a03 : 48 > pha ;use stack to load status 2a04 : b513 > lda zp1,x ;load to indexed memory 2a06 : 9d0302 > sta abst,x 2a09 : 28 > plp 2a0a : 7e0302 ror abst,x tst_absx rRORc,fRORc,0 2a0d : 08 > php ;save flags 2a0e : bd0302 > lda abst,x 2a11 : dd2c02 > cmp rRORc,x ;test result > trap_ne 2a14 : d0fe > bne * ;failed not equal (non zero) > 2a16 : 68 > pla ;load status > eor_flag 0 2a17 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2a19 : dd3c02 > cmp fRORc,x ;test flags > trap_ne 2a1c : d0fe > bne * ;failed not equal (non zero) > 2a1e : ca dex 2a1f : 10e0 bpl trorc8 2a21 : a203 ldx #3 2a23 : trorc9 set_absx zp1,$ff > load_flag $ff 2a23 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2a25 : 48 > pha ;use stack to load status 2a26 : b513 > lda zp1,x ;load to indexed memory 2a28 : 9d0302 > sta abst,x 2a2b : 28 > plp 2a2c : 7e0302 ror abst,x tst_absx rRORc,fRORc,$ff-fnzc 2a2f : 08 > php ;save flags 2a30 : bd0302 > lda abst,x 2a33 : dd2c02 > cmp rRORc,x ;test result > trap_ne 2a36 : d0fe > bne * ;failed not equal (non zero) > 2a38 : 68 > pla ;load status > eor_flag $ff-fnzc 2a39 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits > 2a3b : dd3c02 > cmp fRORc,x ;test flags > trap_ne 2a3e : d0fe > bne * ;failed not equal (non zero) > 2a40 : ca dex 2a41 : 10e0 bpl trorc9 next_test 2a43 : ad0002 > lda test_case ;previous test 2a46 : c921 > cmp #test_num > trap_ne ;test is out of sequence 2a48 : d0fe > bne * ;failed not equal (non zero) > 0022 = >test_num = test_num + 1 2a4a : a922 > lda #test_num ;*** next tests' number 2a4c : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; testing memory increment/decrement - INC DEC all addressing modes ; zeropage 2a4f : a200 ldx #0 2a51 : a97e lda #$7e 2a53 : 850c sta zpt 2a55 : tinc set_stat 0 > load_flag 0 2a55 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2a57 : 48 > pha ;use stack to load status 2a58 : 28 > plp 2a59 : e60c inc zpt tst_z rINC,fINC,0 2a5b : 08 > php ;save flags 2a5c : a50c > lda zpt 2a5e : dd4002 > cmp rINC,x ;test result > trap_ne 2a61 : d0fe > bne * ;failed not equal (non zero) > 2a63 : 68 > pla ;load status > eor_flag 0 2a64 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2a66 : dd4502 > cmp fINC,x ;test flags > trap_ne 2a69 : d0fe > bne * ;failed not equal (non zero) > 2a6b : e8 inx 2a6c : e002 cpx #2 2a6e : d004 bne tinc1 2a70 : a9fe lda #$fe 2a72 : 850c sta zpt 2a74 : e005 tinc1 cpx #5 2a76 : d0dd bne tinc 2a78 : ca dex 2a79 : e60c inc zpt 2a7b : tdec set_stat 0 > load_flag 0 2a7b : a900 > lda #0 ;allow test to change I-flag (no mask) > 2a7d : 48 > pha ;use stack to load status 2a7e : 28 > plp 2a7f : c60c dec zpt tst_z rINC,fINC,0 2a81 : 08 > php ;save flags 2a82 : a50c > lda zpt 2a84 : dd4002 > cmp rINC,x ;test result > trap_ne 2a87 : d0fe > bne * ;failed not equal (non zero) > 2a89 : 68 > pla ;load status > eor_flag 0 2a8a : 4930 > eor #0|fao ;invert expected flags + always on bits > 2a8c : dd4502 > cmp fINC,x ;test flags > trap_ne 2a8f : d0fe > bne * ;failed not equal (non zero) > 2a91 : ca dex 2a92 : 300a bmi tdec1 2a94 : e001 cpx #1 2a96 : d0e3 bne tdec 2a98 : a981 lda #$81 2a9a : 850c sta zpt 2a9c : d0dd bne tdec 2a9e : tdec1 2a9e : a200 ldx #0 2aa0 : a97e lda #$7e 2aa2 : 850c sta zpt 2aa4 : tinc10 set_stat $ff > load_flag $ff 2aa4 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2aa6 : 48 > pha ;use stack to load status 2aa7 : 28 > plp 2aa8 : e60c inc zpt tst_z rINC,fINC,$ff-fnz 2aaa : 08 > php ;save flags 2aab : a50c > lda zpt 2aad : dd4002 > cmp rINC,x ;test result > trap_ne 2ab0 : d0fe > bne * ;failed not equal (non zero) > 2ab2 : 68 > pla ;load status > eor_flag $ff-fnz 2ab3 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 2ab5 : dd4502 > cmp fINC,x ;test flags > trap_ne 2ab8 : d0fe > bne * ;failed not equal (non zero) > 2aba : e8 inx 2abb : e002 cpx #2 2abd : d004 bne tinc11 2abf : a9fe lda #$fe 2ac1 : 850c sta zpt 2ac3 : e005 tinc11 cpx #5 2ac5 : d0dd bne tinc10 2ac7 : ca dex 2ac8 : e60c inc zpt 2aca : tdec10 set_stat $ff > load_flag $ff 2aca : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2acc : 48 > pha ;use stack to load status 2acd : 28 > plp 2ace : c60c dec zpt tst_z rINC,fINC,$ff-fnz 2ad0 : 08 > php ;save flags 2ad1 : a50c > lda zpt 2ad3 : dd4002 > cmp rINC,x ;test result > trap_ne 2ad6 : d0fe > bne * ;failed not equal (non zero) > 2ad8 : 68 > pla ;load status > eor_flag $ff-fnz 2ad9 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 2adb : dd4502 > cmp fINC,x ;test flags > trap_ne 2ade : d0fe > bne * ;failed not equal (non zero) > 2ae0 : ca dex 2ae1 : 300a bmi tdec11 2ae3 : e001 cpx #1 2ae5 : d0e3 bne tdec10 2ae7 : a981 lda #$81 2ae9 : 850c sta zpt 2aeb : d0dd bne tdec10 2aed : tdec11 next_test 2aed : ad0002 > lda test_case ;previous test 2af0 : c922 > cmp #test_num > trap_ne ;test is out of sequence 2af2 : d0fe > bne * ;failed not equal (non zero) > 0023 = >test_num = test_num + 1 2af4 : a923 > lda #test_num ;*** next tests' number 2af6 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; absolute memory 2af9 : a200 ldx #0 2afb : a97e lda #$7e 2afd : 8d0302 sta abst 2b00 : tinc2 set_stat 0 > load_flag 0 2b00 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2b02 : 48 > pha ;use stack to load status 2b03 : 28 > plp 2b04 : ee0302 inc abst tst_abs rINC,fINC,0 2b07 : 08 > php ;save flags 2b08 : ad0302 > lda abst 2b0b : dd4002 > cmp rINC,x ;test result > trap_ne 2b0e : d0fe > bne * ;failed not equal (non zero) > 2b10 : 68 > pla ;load status > eor_flag 0 2b11 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2b13 : dd4502 > cmp fINC,x ;test flags > trap_ne 2b16 : d0fe > bne * ;failed not equal (non zero) > 2b18 : e8 inx 2b19 : e002 cpx #2 2b1b : d005 bne tinc3 2b1d : a9fe lda #$fe 2b1f : 8d0302 sta abst 2b22 : e005 tinc3 cpx #5 2b24 : d0da bne tinc2 2b26 : ca dex 2b27 : ee0302 inc abst 2b2a : tdec2 set_stat 0 > load_flag 0 2b2a : a900 > lda #0 ;allow test to change I-flag (no mask) > 2b2c : 48 > pha ;use stack to load status 2b2d : 28 > plp 2b2e : ce0302 dec abst tst_abs rINC,fINC,0 2b31 : 08 > php ;save flags 2b32 : ad0302 > lda abst 2b35 : dd4002 > cmp rINC,x ;test result > trap_ne 2b38 : d0fe > bne * ;failed not equal (non zero) > 2b3a : 68 > pla ;load status > eor_flag 0 2b3b : 4930 > eor #0|fao ;invert expected flags + always on bits > 2b3d : dd4502 > cmp fINC,x ;test flags > trap_ne 2b40 : d0fe > bne * ;failed not equal (non zero) > 2b42 : ca dex 2b43 : 300b bmi tdec3 2b45 : e001 cpx #1 2b47 : d0e1 bne tdec2 2b49 : a981 lda #$81 2b4b : 8d0302 sta abst 2b4e : d0da bne tdec2 2b50 : tdec3 2b50 : a200 ldx #0 2b52 : a97e lda #$7e 2b54 : 8d0302 sta abst 2b57 : tinc12 set_stat $ff > load_flag $ff 2b57 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2b59 : 48 > pha ;use stack to load status 2b5a : 28 > plp 2b5b : ee0302 inc abst tst_abs rINC,fINC,$ff-fnz 2b5e : 08 > php ;save flags 2b5f : ad0302 > lda abst 2b62 : dd4002 > cmp rINC,x ;test result > trap_ne 2b65 : d0fe > bne * ;failed not equal (non zero) > 2b67 : 68 > pla ;load status > eor_flag $ff-fnz 2b68 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 2b6a : dd4502 > cmp fINC,x ;test flags > trap_ne 2b6d : d0fe > bne * ;failed not equal (non zero) > 2b6f : e8 inx 2b70 : e002 cpx #2 2b72 : d005 bne tinc13 2b74 : a9fe lda #$fe 2b76 : 8d0302 sta abst 2b79 : e005 tinc13 cpx #5 2b7b : d0da bne tinc12 2b7d : ca dex 2b7e : ee0302 inc abst 2b81 : tdec12 set_stat $ff > load_flag $ff 2b81 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2b83 : 48 > pha ;use stack to load status 2b84 : 28 > plp 2b85 : ce0302 dec abst tst_abs rINC,fINC,$ff-fnz 2b88 : 08 > php ;save flags 2b89 : ad0302 > lda abst 2b8c : dd4002 > cmp rINC,x ;test result > trap_ne 2b8f : d0fe > bne * ;failed not equal (non zero) > 2b91 : 68 > pla ;load status > eor_flag $ff-fnz 2b92 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 2b94 : dd4502 > cmp fINC,x ;test flags > trap_ne 2b97 : d0fe > bne * ;failed not equal (non zero) > 2b99 : ca dex 2b9a : 300b bmi tdec13 2b9c : e001 cpx #1 2b9e : d0e1 bne tdec12 2ba0 : a981 lda #$81 2ba2 : 8d0302 sta abst 2ba5 : d0da bne tdec12 2ba7 : tdec13 next_test 2ba7 : ad0002 > lda test_case ;previous test 2baa : c923 > cmp #test_num > trap_ne ;test is out of sequence 2bac : d0fe > bne * ;failed not equal (non zero) > 0024 = >test_num = test_num + 1 2bae : a924 > lda #test_num ;*** next tests' number 2bb0 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; zeropage indexed 2bb3 : a200 ldx #0 2bb5 : a97e lda #$7e 2bb7 : 950c tinc4 sta zpt,x set_stat 0 > load_flag 0 2bb9 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2bbb : 48 > pha ;use stack to load status 2bbc : 28 > plp 2bbd : f60c inc zpt,x tst_zx rINC,fINC,0 2bbf : 08 > php ;save flags 2bc0 : b50c > lda zpt,x 2bc2 : dd4002 > cmp rINC,x ;test result > trap_ne 2bc5 : d0fe > bne * ;failed not equal (non zero) > 2bc7 : 68 > pla ;load status > eor_flag 0 2bc8 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2bca : dd4502 > cmp fINC,x ;test flags > trap_ne 2bcd : d0fe > bne * ;failed not equal (non zero) > 2bcf : b50c lda zpt,x 2bd1 : e8 inx 2bd2 : e002 cpx #2 2bd4 : d002 bne tinc5 2bd6 : a9fe lda #$fe 2bd8 : e005 tinc5 cpx #5 2bda : d0db bne tinc4 2bdc : ca dex 2bdd : a902 lda #2 2bdf : 950c tdec4 sta zpt,x set_stat 0 > load_flag 0 2be1 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2be3 : 48 > pha ;use stack to load status 2be4 : 28 > plp 2be5 : d60c dec zpt,x tst_zx rINC,fINC,0 2be7 : 08 > php ;save flags 2be8 : b50c > lda zpt,x 2bea : dd4002 > cmp rINC,x ;test result > trap_ne 2bed : d0fe > bne * ;failed not equal (non zero) > 2bef : 68 > pla ;load status > eor_flag 0 2bf0 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2bf2 : dd4502 > cmp fINC,x ;test flags > trap_ne 2bf5 : d0fe > bne * ;failed not equal (non zero) > 2bf7 : b50c lda zpt,x 2bf9 : ca dex 2bfa : 3008 bmi tdec5 2bfc : e001 cpx #1 2bfe : d0df bne tdec4 2c00 : a981 lda #$81 2c02 : d0db bne tdec4 2c04 : tdec5 2c04 : a200 ldx #0 2c06 : a97e lda #$7e 2c08 : 950c tinc14 sta zpt,x set_stat $ff > load_flag $ff 2c0a : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2c0c : 48 > pha ;use stack to load status 2c0d : 28 > plp 2c0e : f60c inc zpt,x tst_zx rINC,fINC,$ff-fnz 2c10 : 08 > php ;save flags 2c11 : b50c > lda zpt,x 2c13 : dd4002 > cmp rINC,x ;test result > trap_ne 2c16 : d0fe > bne * ;failed not equal (non zero) > 2c18 : 68 > pla ;load status > eor_flag $ff-fnz 2c19 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 2c1b : dd4502 > cmp fINC,x ;test flags > trap_ne 2c1e : d0fe > bne * ;failed not equal (non zero) > 2c20 : b50c lda zpt,x 2c22 : e8 inx 2c23 : e002 cpx #2 2c25 : d002 bne tinc15 2c27 : a9fe lda #$fe 2c29 : e005 tinc15 cpx #5 2c2b : d0db bne tinc14 2c2d : ca dex 2c2e : a902 lda #2 2c30 : 950c tdec14 sta zpt,x set_stat $ff > load_flag $ff 2c32 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2c34 : 48 > pha ;use stack to load status 2c35 : 28 > plp 2c36 : d60c dec zpt,x tst_zx rINC,fINC,$ff-fnz 2c38 : 08 > php ;save flags 2c39 : b50c > lda zpt,x 2c3b : dd4002 > cmp rINC,x ;test result > trap_ne 2c3e : d0fe > bne * ;failed not equal (non zero) > 2c40 : 68 > pla ;load status > eor_flag $ff-fnz 2c41 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 2c43 : dd4502 > cmp fINC,x ;test flags > trap_ne 2c46 : d0fe > bne * ;failed not equal (non zero) > 2c48 : b50c lda zpt,x 2c4a : ca dex 2c4b : 3008 bmi tdec15 2c4d : e001 cpx #1 2c4f : d0df bne tdec14 2c51 : a981 lda #$81 2c53 : d0db bne tdec14 2c55 : tdec15 next_test 2c55 : ad0002 > lda test_case ;previous test 2c58 : c924 > cmp #test_num > trap_ne ;test is out of sequence 2c5a : d0fe > bne * ;failed not equal (non zero) > 0025 = >test_num = test_num + 1 2c5c : a925 > lda #test_num ;*** next tests' number 2c5e : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; memory indexed 2c61 : a200 ldx #0 2c63 : a97e lda #$7e 2c65 : 9d0302 tinc6 sta abst,x set_stat 0 > load_flag 0 2c68 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2c6a : 48 > pha ;use stack to load status 2c6b : 28 > plp 2c6c : fe0302 inc abst,x tst_absx rINC,fINC,0 2c6f : 08 > php ;save flags 2c70 : bd0302 > lda abst,x 2c73 : dd4002 > cmp rINC,x ;test result > trap_ne 2c76 : d0fe > bne * ;failed not equal (non zero) > 2c78 : 68 > pla ;load status > eor_flag 0 2c79 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2c7b : dd4502 > cmp fINC,x ;test flags > trap_ne 2c7e : d0fe > bne * ;failed not equal (non zero) > 2c80 : bd0302 lda abst,x 2c83 : e8 inx 2c84 : e002 cpx #2 2c86 : d002 bne tinc7 2c88 : a9fe lda #$fe 2c8a : e005 tinc7 cpx #5 2c8c : d0d7 bne tinc6 2c8e : ca dex 2c8f : a902 lda #2 2c91 : 9d0302 tdec6 sta abst,x set_stat 0 > load_flag 0 2c94 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2c96 : 48 > pha ;use stack to load status 2c97 : 28 > plp 2c98 : de0302 dec abst,x tst_absx rINC,fINC,0 2c9b : 08 > php ;save flags 2c9c : bd0302 > lda abst,x 2c9f : dd4002 > cmp rINC,x ;test result > trap_ne 2ca2 : d0fe > bne * ;failed not equal (non zero) > 2ca4 : 68 > pla ;load status > eor_flag 0 2ca5 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2ca7 : dd4502 > cmp fINC,x ;test flags > trap_ne 2caa : d0fe > bne * ;failed not equal (non zero) > 2cac : bd0302 lda abst,x 2caf : ca dex 2cb0 : 3008 bmi tdec7 2cb2 : e001 cpx #1 2cb4 : d0db bne tdec6 2cb6 : a981 lda #$81 2cb8 : d0d7 bne tdec6 2cba : tdec7 2cba : a200 ldx #0 2cbc : a97e lda #$7e 2cbe : 9d0302 tinc16 sta abst,x set_stat $ff > load_flag $ff 2cc1 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2cc3 : 48 > pha ;use stack to load status 2cc4 : 28 > plp 2cc5 : fe0302 inc abst,x tst_absx rINC,fINC,$ff-fnz 2cc8 : 08 > php ;save flags 2cc9 : bd0302 > lda abst,x 2ccc : dd4002 > cmp rINC,x ;test result > trap_ne 2ccf : d0fe > bne * ;failed not equal (non zero) > 2cd1 : 68 > pla ;load status > eor_flag $ff-fnz 2cd2 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 2cd4 : dd4502 > cmp fINC,x ;test flags > trap_ne 2cd7 : d0fe > bne * ;failed not equal (non zero) > 2cd9 : bd0302 lda abst,x 2cdc : e8 inx 2cdd : e002 cpx #2 2cdf : d002 bne tinc17 2ce1 : a9fe lda #$fe 2ce3 : e005 tinc17 cpx #5 2ce5 : d0d7 bne tinc16 2ce7 : ca dex 2ce8 : a902 lda #2 2cea : 9d0302 tdec16 sta abst,x set_stat $ff > load_flag $ff 2ced : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2cef : 48 > pha ;use stack to load status 2cf0 : 28 > plp 2cf1 : de0302 dec abst,x tst_absx rINC,fINC,$ff-fnz 2cf4 : 08 > php ;save flags 2cf5 : bd0302 > lda abst,x 2cf8 : dd4002 > cmp rINC,x ;test result > trap_ne 2cfb : d0fe > bne * ;failed not equal (non zero) > 2cfd : 68 > pla ;load status > eor_flag $ff-fnz 2cfe : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 2d00 : dd4502 > cmp fINC,x ;test flags > trap_ne 2d03 : d0fe > bne * ;failed not equal (non zero) > 2d05 : bd0302 lda abst,x 2d08 : ca dex 2d09 : 3008 bmi tdec17 2d0b : e001 cpx #1 2d0d : d0db bne tdec16 2d0f : a981 lda #$81 2d11 : d0d7 bne tdec16 2d13 : tdec17 next_test 2d13 : ad0002 > lda test_case ;previous test 2d16 : c925 > cmp #test_num > trap_ne ;test is out of sequence 2d18 : d0fe > bne * ;failed not equal (non zero) > 0026 = >test_num = test_num + 1 2d1a : a926 > lda #test_num ;*** next tests' number 2d1c : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; testing logical instructions - AND EOR ORA all addressing modes ; AND 2d1f : a203 ldx #3 ;immediate 2d21 : b51c tand lda zpAN,x 2d23 : 8d0902 sta ex_andi+1 ;set AND # operand set_ax absANa,0 > load_flag 0 2d26 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2d28 : 48 > pha ;use stack to load status 2d29 : bd5a02 > lda absANa,x ;precharge accu 2d2c : 28 > plp 2d2d : 200802 jsr ex_andi ;execute AND # in RAM tst_ax absrlo,absflo,0 2d30 : 08 > php ;save flags 2d31 : dd6202 > cmp absrlo,x ;test result > trap_ne 2d34 : d0fe > bne * ;failed not equal (non zero) > 2d36 : 68 > pla ;load status > eor_flag 0 2d37 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2d39 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2d3c : d0fe > bne * ;failed not equal (non zero) > 2d3e : ca dex 2d3f : 10e0 bpl tand 2d41 : a203 ldx #3 2d43 : b51c tand1 lda zpAN,x 2d45 : 8d0902 sta ex_andi+1 ;set AND # operand set_ax absANa,$ff > load_flag $ff 2d48 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2d4a : 48 > pha ;use stack to load status 2d4b : bd5a02 > lda absANa,x ;precharge accu 2d4e : 28 > plp 2d4f : 200802 jsr ex_andi ;execute AND # in RAM tst_ax absrlo,absflo,$ff-fnz 2d52 : 08 > php ;save flags 2d53 : dd6202 > cmp absrlo,x ;test result > trap_ne 2d56 : d0fe > bne * ;failed not equal (non zero) > 2d58 : 68 > pla ;load status > eor_flag $ff-fnz 2d59 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 2d5b : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2d5e : d0fe > bne * ;failed not equal (non zero) > 2d60 : ca dex 2d61 : 10e0 bpl tand1 2d63 : a203 ldx #3 ;zp 2d65 : b51c tand2 lda zpAN,x 2d67 : 850c sta zpt set_ax absANa,0 > load_flag 0 2d69 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2d6b : 48 > pha ;use stack to load status 2d6c : bd5a02 > lda absANa,x ;precharge accu 2d6f : 28 > plp 2d70 : 250c and zpt tst_ax absrlo,absflo,0 2d72 : 08 > php ;save flags 2d73 : dd6202 > cmp absrlo,x ;test result > trap_ne 2d76 : d0fe > bne * ;failed not equal (non zero) > 2d78 : 68 > pla ;load status > eor_flag 0 2d79 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2d7b : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2d7e : d0fe > bne * ;failed not equal (non zero) > 2d80 : ca dex 2d81 : 10e2 bpl tand2 2d83 : a203 ldx #3 2d85 : b51c tand3 lda zpAN,x 2d87 : 850c sta zpt set_ax absANa,$ff > load_flag $ff 2d89 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2d8b : 48 > pha ;use stack to load status 2d8c : bd5a02 > lda absANa,x ;precharge accu 2d8f : 28 > plp 2d90 : 250c and zpt tst_ax absrlo,absflo,$ff-fnz 2d92 : 08 > php ;save flags 2d93 : dd6202 > cmp absrlo,x ;test result > trap_ne 2d96 : d0fe > bne * ;failed not equal (non zero) > 2d98 : 68 > pla ;load status > eor_flag $ff-fnz 2d99 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 2d9b : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2d9e : d0fe > bne * ;failed not equal (non zero) > 2da0 : ca dex 2da1 : 10e2 bpl tand3 2da3 : a203 ldx #3 ;abs 2da5 : b51c tand4 lda zpAN,x 2da7 : 8d0302 sta abst set_ax absANa,0 > load_flag 0 2daa : a900 > lda #0 ;allow test to change I-flag (no mask) > 2dac : 48 > pha ;use stack to load status 2dad : bd5a02 > lda absANa,x ;precharge accu 2db0 : 28 > plp 2db1 : 2d0302 and abst tst_ax absrlo,absflo,0 2db4 : 08 > php ;save flags 2db5 : dd6202 > cmp absrlo,x ;test result > trap_ne 2db8 : d0fe > bne * ;failed not equal (non zero) > 2dba : 68 > pla ;load status > eor_flag 0 2dbb : 4930 > eor #0|fao ;invert expected flags + always on bits > 2dbd : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2dc0 : d0fe > bne * ;failed not equal (non zero) > 2dc2 : ca dex 2dc3 : 10e0 bpl tand4 2dc5 : a203 ldx #3 2dc7 : b51c tand5 lda zpAN,x 2dc9 : 8d0302 sta abst set_ax absANa,$ff > load_flag $ff 2dcc : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2dce : 48 > pha ;use stack to load status 2dcf : bd5a02 > lda absANa,x ;precharge accu 2dd2 : 28 > plp 2dd3 : 2d0302 and abst tst_ax absrlo,absflo,$ff-fnz 2dd6 : 08 > php ;save flags 2dd7 : dd6202 > cmp absrlo,x ;test result > trap_ne 2dda : d0fe > bne * ;failed not equal (non zero) > 2ddc : 68 > pla ;load status > eor_flag $ff-fnz 2ddd : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 2ddf : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2de2 : d0fe > bne * ;failed not equal (non zero) > 2de4 : ca dex 2de5 : 1002 bpl tand6 2de7 : a203 ldx #3 ;zp,x 2de9 : tand6 set_ax absANa,0 > load_flag 0 2de9 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2deb : 48 > pha ;use stack to load status 2dec : bd5a02 > lda absANa,x ;precharge accu 2def : 28 > plp 2df0 : 351c and zpAN,x tst_ax absrlo,absflo,0 2df2 : 08 > php ;save flags 2df3 : dd6202 > cmp absrlo,x ;test result > trap_ne 2df6 : d0fe > bne * ;failed not equal (non zero) > 2df8 : 68 > pla ;load status > eor_flag 0 2df9 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2dfb : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2dfe : d0fe > bne * ;failed not equal (non zero) > 2e00 : ca dex 2e01 : 10e6 bpl tand6 2e03 : a203 ldx #3 2e05 : tand7 set_ax absANa,$ff > load_flag $ff 2e05 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2e07 : 48 > pha ;use stack to load status 2e08 : bd5a02 > lda absANa,x ;precharge accu 2e0b : 28 > plp 2e0c : 351c and zpAN,x tst_ax absrlo,absflo,$ff-fnz 2e0e : 08 > php ;save flags 2e0f : dd6202 > cmp absrlo,x ;test result > trap_ne 2e12 : d0fe > bne * ;failed not equal (non zero) > 2e14 : 68 > pla ;load status > eor_flag $ff-fnz 2e15 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 2e17 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2e1a : d0fe > bne * ;failed not equal (non zero) > 2e1c : ca dex 2e1d : 10e6 bpl tand7 2e1f : a203 ldx #3 ;abs,x 2e21 : tand8 set_ax absANa,0 > load_flag 0 2e21 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2e23 : 48 > pha ;use stack to load status 2e24 : bd5a02 > lda absANa,x ;precharge accu 2e27 : 28 > plp 2e28 : 3d4e02 and absAN,x tst_ax absrlo,absflo,0 2e2b : 08 > php ;save flags 2e2c : dd6202 > cmp absrlo,x ;test result > trap_ne 2e2f : d0fe > bne * ;failed not equal (non zero) > 2e31 : 68 > pla ;load status > eor_flag 0 2e32 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2e34 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2e37 : d0fe > bne * ;failed not equal (non zero) > 2e39 : ca dex 2e3a : 10e5 bpl tand8 2e3c : a203 ldx #3 2e3e : tand9 set_ax absANa,$ff > load_flag $ff 2e3e : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2e40 : 48 > pha ;use stack to load status 2e41 : bd5a02 > lda absANa,x ;precharge accu 2e44 : 28 > plp 2e45 : 3d4e02 and absAN,x tst_ax absrlo,absflo,$ff-fnz 2e48 : 08 > php ;save flags 2e49 : dd6202 > cmp absrlo,x ;test result > trap_ne 2e4c : d0fe > bne * ;failed not equal (non zero) > 2e4e : 68 > pla ;load status > eor_flag $ff-fnz 2e4f : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 2e51 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2e54 : d0fe > bne * ;failed not equal (non zero) > 2e56 : ca dex 2e57 : 10e5 bpl tand9 2e59 : a003 ldy #3 ;abs,y 2e5b : tand10 set_ay absANa,0 > load_flag 0 2e5b : a900 > lda #0 ;allow test to change I-flag (no mask) > 2e5d : 48 > pha ;use stack to load status 2e5e : b95a02 > lda absANa,y ;precharge accu 2e61 : 28 > plp 2e62 : 394e02 and absAN,y tst_ay absrlo,absflo,0 2e65 : 08 > php ;save flags 2e66 : d96202 > cmp absrlo,y ;test result > trap_ne ; 2e69 : d0fe > bne * ;failed not equal (non zero) > 2e6b : 68 > pla ;load status > eor_flag 0 2e6c : 4930 > eor #0|fao ;invert expected flags + always on bits > 2e6e : d96602 > cmp absflo,y ;test flags > trap_ne 2e71 : d0fe > bne * ;failed not equal (non zero) > 2e73 : 88 dey 2e74 : 10e5 bpl tand10 2e76 : a003 ldy #3 2e78 : tand11 set_ay absANa,$ff > load_flag $ff 2e78 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2e7a : 48 > pha ;use stack to load status 2e7b : b95a02 > lda absANa,y ;precharge accu 2e7e : 28 > plp 2e7f : 394e02 and absAN,y tst_ay absrlo,absflo,$ff-fnz 2e82 : 08 > php ;save flags 2e83 : d96202 > cmp absrlo,y ;test result > trap_ne ; 2e86 : d0fe > bne * ;failed not equal (non zero) > 2e88 : 68 > pla ;load status > eor_flag $ff-fnz 2e89 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 2e8b : d96602 > cmp absflo,y ;test flags > trap_ne 2e8e : d0fe > bne * ;failed not equal (non zero) > 2e90 : 88 dey 2e91 : 10e5 bpl tand11 2e93 : a206 ldx #6 ;(zp,x) 2e95 : a003 ldy #3 2e97 : tand12 set_ay absANa,0 > load_flag 0 2e97 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2e99 : 48 > pha ;use stack to load status 2e9a : b95a02 > lda absANa,y ;precharge accu 2e9d : 28 > plp 2e9e : 213a and (indAN,x) tst_ay absrlo,absflo,0 2ea0 : 08 > php ;save flags 2ea1 : d96202 > cmp absrlo,y ;test result > trap_ne ; 2ea4 : d0fe > bne * ;failed not equal (non zero) > 2ea6 : 68 > pla ;load status > eor_flag 0 2ea7 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2ea9 : d96602 > cmp absflo,y ;test flags > trap_ne 2eac : d0fe > bne * ;failed not equal (non zero) > 2eae : ca dex 2eaf : ca dex 2eb0 : 88 dey 2eb1 : 10e4 bpl tand12 2eb3 : a206 ldx #6 2eb5 : a003 ldy #3 2eb7 : tand13 set_ay absANa,$ff > load_flag $ff 2eb7 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2eb9 : 48 > pha ;use stack to load status 2eba : b95a02 > lda absANa,y ;precharge accu 2ebd : 28 > plp 2ebe : 213a and (indAN,x) tst_ay absrlo,absflo,$ff-fnz 2ec0 : 08 > php ;save flags 2ec1 : d96202 > cmp absrlo,y ;test result > trap_ne ; 2ec4 : d0fe > bne * ;failed not equal (non zero) > 2ec6 : 68 > pla ;load status > eor_flag $ff-fnz 2ec7 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 2ec9 : d96602 > cmp absflo,y ;test flags > trap_ne 2ecc : d0fe > bne * ;failed not equal (non zero) > 2ece : ca dex 2ecf : ca dex 2ed0 : 88 dey 2ed1 : 10e4 bpl tand13 2ed3 : a003 ldy #3 ;(zp),y 2ed5 : tand14 set_ay absANa,0 > load_flag 0 2ed5 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2ed7 : 48 > pha ;use stack to load status 2ed8 : b95a02 > lda absANa,y ;precharge accu 2edb : 28 > plp 2edc : 313a and (indAN),y tst_ay absrlo,absflo,0 2ede : 08 > php ;save flags 2edf : d96202 > cmp absrlo,y ;test result > trap_ne ; 2ee2 : d0fe > bne * ;failed not equal (non zero) > 2ee4 : 68 > pla ;load status > eor_flag 0 2ee5 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2ee7 : d96602 > cmp absflo,y ;test flags > trap_ne 2eea : d0fe > bne * ;failed not equal (non zero) > 2eec : 88 dey 2eed : 10e6 bpl tand14 2eef : a003 ldy #3 2ef1 : tand15 set_ay absANa,$ff > load_flag $ff 2ef1 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2ef3 : 48 > pha ;use stack to load status 2ef4 : b95a02 > lda absANa,y ;precharge accu 2ef7 : 28 > plp 2ef8 : 313a and (indAN),y tst_ay absrlo,absflo,$ff-fnz 2efa : 08 > php ;save flags 2efb : d96202 > cmp absrlo,y ;test result > trap_ne ; 2efe : d0fe > bne * ;failed not equal (non zero) > 2f00 : 68 > pla ;load status > eor_flag $ff-fnz 2f01 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 2f03 : d96602 > cmp absflo,y ;test flags > trap_ne 2f06 : d0fe > bne * ;failed not equal (non zero) > 2f08 : 88 dey 2f09 : 10e6 bpl tand15 next_test 2f0b : ad0002 > lda test_case ;previous test 2f0e : c926 > cmp #test_num > trap_ne ;test is out of sequence 2f10 : d0fe > bne * ;failed not equal (non zero) > 0027 = >test_num = test_num + 1 2f12 : a927 > lda #test_num ;*** next tests' number 2f14 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; EOR 2f17 : a203 ldx #3 ;immediate - self modifying code 2f19 : b520 teor lda zpEO,x 2f1b : 8d0c02 sta ex_eori+1 ;set EOR # operand set_ax absEOa,0 > load_flag 0 2f1e : a900 > lda #0 ;allow test to change I-flag (no mask) > 2f20 : 48 > pha ;use stack to load status 2f21 : bd5e02 > lda absEOa,x ;precharge accu 2f24 : 28 > plp 2f25 : 200b02 jsr ex_eori ;execute EOR # in RAM tst_ax absrlo,absflo,0 2f28 : 08 > php ;save flags 2f29 : dd6202 > cmp absrlo,x ;test result > trap_ne 2f2c : d0fe > bne * ;failed not equal (non zero) > 2f2e : 68 > pla ;load status > eor_flag 0 2f2f : 4930 > eor #0|fao ;invert expected flags + always on bits > 2f31 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2f34 : d0fe > bne * ;failed not equal (non zero) > 2f36 : ca dex 2f37 : 10e0 bpl teor 2f39 : a203 ldx #3 2f3b : b520 teor1 lda zpEO,x 2f3d : 8d0c02 sta ex_eori+1 ;set EOR # operand set_ax absEOa,$ff > load_flag $ff 2f40 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2f42 : 48 > pha ;use stack to load status 2f43 : bd5e02 > lda absEOa,x ;precharge accu 2f46 : 28 > plp 2f47 : 200b02 jsr ex_eori ;execute EOR # in RAM tst_ax absrlo,absflo,$ff-fnz 2f4a : 08 > php ;save flags 2f4b : dd6202 > cmp absrlo,x ;test result > trap_ne 2f4e : d0fe > bne * ;failed not equal (non zero) > 2f50 : 68 > pla ;load status > eor_flag $ff-fnz 2f51 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 2f53 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2f56 : d0fe > bne * ;failed not equal (non zero) > 2f58 : ca dex 2f59 : 10e0 bpl teor1 2f5b : a203 ldx #3 ;zp 2f5d : b520 teor2 lda zpEO,x 2f5f : 850c sta zpt set_ax absEOa,0 > load_flag 0 2f61 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2f63 : 48 > pha ;use stack to load status 2f64 : bd5e02 > lda absEOa,x ;precharge accu 2f67 : 28 > plp 2f68 : 450c eor zpt tst_ax absrlo,absflo,0 2f6a : 08 > php ;save flags 2f6b : dd6202 > cmp absrlo,x ;test result > trap_ne 2f6e : d0fe > bne * ;failed not equal (non zero) > 2f70 : 68 > pla ;load status > eor_flag 0 2f71 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2f73 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2f76 : d0fe > bne * ;failed not equal (non zero) > 2f78 : ca dex 2f79 : 10e2 bpl teor2 2f7b : a203 ldx #3 2f7d : b520 teor3 lda zpEO,x 2f7f : 850c sta zpt set_ax absEOa,$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 : bd5e02 > lda absEOa,x ;precharge accu 2f87 : 28 > plp 2f88 : 450c eor zpt tst_ax absrlo,absflo,$ff-fnz 2f8a : 08 > php ;save flags 2f8b : dd6202 > cmp absrlo,x ;test result > trap_ne 2f8e : d0fe > bne * ;failed not equal (non zero) > 2f90 : 68 > pla ;load status > eor_flag $ff-fnz 2f91 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 2f93 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2f96 : d0fe > bne * ;failed not equal (non zero) > 2f98 : ca dex 2f99 : 10e2 bpl teor3 2f9b : a203 ldx #3 ;abs 2f9d : b520 teor4 lda zpEO,x 2f9f : 8d0302 sta abst set_ax absEOa,0 > load_flag 0 2fa2 : a900 > lda #0 ;allow test to change I-flag (no mask) > 2fa4 : 48 > pha ;use stack to load status 2fa5 : bd5e02 > lda absEOa,x ;precharge accu 2fa8 : 28 > plp 2fa9 : 4d0302 eor abst tst_ax absrlo,absflo,0 2fac : 08 > php ;save flags 2fad : dd6202 > cmp absrlo,x ;test result > trap_ne 2fb0 : d0fe > bne * ;failed not equal (non zero) > 2fb2 : 68 > pla ;load status > eor_flag 0 2fb3 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2fb5 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2fb8 : d0fe > bne * ;failed not equal (non zero) > 2fba : ca dex 2fbb : 10e0 bpl teor4 2fbd : a203 ldx #3 2fbf : b520 teor5 lda zpEO,x 2fc1 : 8d0302 sta abst set_ax absEOa,$ff > load_flag $ff 2fc4 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2fc6 : 48 > pha ;use stack to load status 2fc7 : bd5e02 > lda absEOa,x ;precharge accu 2fca : 28 > plp 2fcb : 4d0302 eor abst tst_ax absrlo,absflo,$ff-fnz 2fce : 08 > php ;save flags 2fcf : dd6202 > cmp absrlo,x ;test result > trap_ne 2fd2 : d0fe > bne * ;failed not equal (non zero) > 2fd4 : 68 > pla ;load status > eor_flag $ff-fnz 2fd5 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 2fd7 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2fda : d0fe > bne * ;failed not equal (non zero) > 2fdc : ca dex 2fdd : 1002 bpl teor6 2fdf : a203 ldx #3 ;zp,x 2fe1 : teor6 set_ax absEOa,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 : bd5e02 > lda absEOa,x ;precharge accu 2fe7 : 28 > plp 2fe8 : 5520 eor zpEO,x tst_ax absrlo,absflo,0 2fea : 08 > php ;save flags 2feb : dd6202 > cmp absrlo,x ;test result > trap_ne 2fee : d0fe > bne * ;failed not equal (non zero) > 2ff0 : 68 > pla ;load status > eor_flag 0 2ff1 : 4930 > eor #0|fao ;invert expected flags + always on bits > 2ff3 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2ff6 : d0fe > bne * ;failed not equal (non zero) > 2ff8 : ca dex 2ff9 : 10e6 bpl teor6 2ffb : a203 ldx #3 2ffd : teor7 set_ax absEOa,$ff > load_flag $ff 2ffd : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 2fff : 48 > pha ;use stack to load status 3000 : bd5e02 > lda absEOa,x ;precharge accu 3003 : 28 > plp 3004 : 5520 eor zpEO,x tst_ax absrlo,absflo,$ff-fnz 3006 : 08 > php ;save flags 3007 : dd6202 > cmp absrlo,x ;test result > trap_ne 300a : d0fe > bne * ;failed not equal (non zero) > 300c : 68 > pla ;load status > eor_flag $ff-fnz 300d : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 300f : dd6602 > cmp absflo,x ;test flags > trap_ne ; 3012 : d0fe > bne * ;failed not equal (non zero) > 3014 : ca dex 3015 : 10e6 bpl teor7 3017 : a203 ldx #3 ;abs,x 3019 : teor8 set_ax absEOa,0 > load_flag 0 3019 : a900 > lda #0 ;allow test to change I-flag (no mask) > 301b : 48 > pha ;use stack to load status 301c : bd5e02 > lda absEOa,x ;precharge accu 301f : 28 > plp 3020 : 5d5202 eor absEO,x tst_ax absrlo,absflo,0 3023 : 08 > php ;save flags 3024 : dd6202 > cmp absrlo,x ;test result > trap_ne 3027 : d0fe > bne * ;failed not equal (non zero) > 3029 : 68 > pla ;load status > eor_flag 0 302a : 4930 > eor #0|fao ;invert expected flags + always on bits > 302c : dd6602 > cmp absflo,x ;test flags > trap_ne ; 302f : d0fe > bne * ;failed not equal (non zero) > 3031 : ca dex 3032 : 10e5 bpl teor8 3034 : a203 ldx #3 3036 : teor9 set_ax absEOa,$ff > load_flag $ff 3036 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 3038 : 48 > pha ;use stack to load status 3039 : bd5e02 > lda absEOa,x ;precharge accu 303c : 28 > plp 303d : 5d5202 eor absEO,x tst_ax absrlo,absflo,$ff-fnz 3040 : 08 > php ;save flags 3041 : dd6202 > cmp absrlo,x ;test result > trap_ne 3044 : d0fe > bne * ;failed not equal (non zero) > 3046 : 68 > pla ;load status > eor_flag $ff-fnz 3047 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 3049 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 304c : d0fe > bne * ;failed not equal (non zero) > 304e : ca dex 304f : 10e5 bpl teor9 3051 : a003 ldy #3 ;abs,y 3053 : teor10 set_ay absEOa,0 > load_flag 0 3053 : a900 > lda #0 ;allow test to change I-flag (no mask) > 3055 : 48 > pha ;use stack to load status 3056 : b95e02 > lda absEOa,y ;precharge accu 3059 : 28 > plp 305a : 595202 eor absEO,y tst_ay absrlo,absflo,0 305d : 08 > php ;save flags 305e : d96202 > cmp absrlo,y ;test result > trap_ne ; 3061 : d0fe > bne * ;failed not equal (non zero) > 3063 : 68 > pla ;load status > eor_flag 0 3064 : 4930 > eor #0|fao ;invert expected flags + always on bits > 3066 : d96602 > cmp absflo,y ;test flags > trap_ne 3069 : d0fe > bne * ;failed not equal (non zero) > 306b : 88 dey 306c : 10e5 bpl teor10 306e : a003 ldy #3 3070 : teor11 set_ay absEOa,$ff > load_flag $ff 3070 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 3072 : 48 > pha ;use stack to load status 3073 : b95e02 > lda absEOa,y ;precharge accu 3076 : 28 > plp 3077 : 595202 eor absEO,y tst_ay absrlo,absflo,$ff-fnz 307a : 08 > php ;save flags 307b : d96202 > cmp absrlo,y ;test result > trap_ne ; 307e : d0fe > bne * ;failed not equal (non zero) > 3080 : 68 > pla ;load status > eor_flag $ff-fnz 3081 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 3083 : d96602 > cmp absflo,y ;test flags > trap_ne 3086 : d0fe > bne * ;failed not equal (non zero) > 3088 : 88 dey 3089 : 10e5 bpl teor11 308b : a206 ldx #6 ;(zp,x) 308d : a003 ldy #3 308f : teor12 set_ay absEOa,0 > load_flag 0 308f : a900 > lda #0 ;allow test to change I-flag (no mask) > 3091 : 48 > pha ;use stack to load status 3092 : b95e02 > lda absEOa,y ;precharge accu 3095 : 28 > plp 3096 : 4142 eor (indEO,x) tst_ay absrlo,absflo,0 3098 : 08 > php ;save flags 3099 : d96202 > cmp absrlo,y ;test result > trap_ne ; 309c : d0fe > bne * ;failed not equal (non zero) > 309e : 68 > pla ;load status > eor_flag 0 309f : 4930 > eor #0|fao ;invert expected flags + always on bits > 30a1 : d96602 > cmp absflo,y ;test flags > trap_ne 30a4 : d0fe > bne * ;failed not equal (non zero) > 30a6 : ca dex 30a7 : ca dex 30a8 : 88 dey 30a9 : 10e4 bpl teor12 30ab : a206 ldx #6 30ad : a003 ldy #3 30af : teor13 set_ay absEOa,$ff > load_flag $ff 30af : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 30b1 : 48 > pha ;use stack to load status 30b2 : b95e02 > lda absEOa,y ;precharge accu 30b5 : 28 > plp 30b6 : 4142 eor (indEO,x) tst_ay absrlo,absflo,$ff-fnz 30b8 : 08 > php ;save flags 30b9 : d96202 > cmp absrlo,y ;test result > trap_ne ; 30bc : d0fe > bne * ;failed not equal (non zero) > 30be : 68 > pla ;load status > eor_flag $ff-fnz 30bf : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 30c1 : d96602 > cmp absflo,y ;test flags > trap_ne 30c4 : d0fe > bne * ;failed not equal (non zero) > 30c6 : ca dex 30c7 : ca dex 30c8 : 88 dey 30c9 : 10e4 bpl teor13 30cb : a003 ldy #3 ;(zp),y 30cd : teor14 set_ay absEOa,0 > load_flag 0 30cd : a900 > lda #0 ;allow test to change I-flag (no mask) > 30cf : 48 > pha ;use stack to load status 30d0 : b95e02 > lda absEOa,y ;precharge accu 30d3 : 28 > plp 30d4 : 5142 eor (indEO),y tst_ay absrlo,absflo,0 30d6 : 08 > php ;save flags 30d7 : d96202 > cmp absrlo,y ;test result > trap_ne ; 30da : d0fe > bne * ;failed not equal (non zero) > 30dc : 68 > pla ;load status > eor_flag 0 30dd : 4930 > eor #0|fao ;invert expected flags + always on bits > 30df : d96602 > cmp absflo,y ;test flags > trap_ne 30e2 : d0fe > bne * ;failed not equal (non zero) > 30e4 : 88 dey 30e5 : 10e6 bpl teor14 30e7 : a003 ldy #3 30e9 : teor15 set_ay absEOa,$ff > load_flag $ff 30e9 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 30eb : 48 > pha ;use stack to load status 30ec : b95e02 > lda absEOa,y ;precharge accu 30ef : 28 > plp 30f0 : 5142 eor (indEO),y tst_ay absrlo,absflo,$ff-fnz 30f2 : 08 > php ;save flags 30f3 : d96202 > cmp absrlo,y ;test result > trap_ne ; 30f6 : d0fe > bne * ;failed not equal (non zero) > 30f8 : 68 > pla ;load status > eor_flag $ff-fnz 30f9 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 30fb : d96602 > cmp absflo,y ;test flags > trap_ne 30fe : d0fe > bne * ;failed not equal (non zero) > 3100 : 88 dey 3101 : 10e6 bpl teor15 next_test 3103 : ad0002 > lda test_case ;previous test 3106 : c927 > cmp #test_num > trap_ne ;test is out of sequence 3108 : d0fe > bne * ;failed not equal (non zero) > 0028 = >test_num = test_num + 1 310a : a928 > lda #test_num ;*** next tests' number 310c : 8d0002 > sta test_case > ;check_ram ;uncomment to find altered RAM after each test ; OR 310f : a203 ldx #3 ;immediate - self modifying code 3111 : b518 tora lda zpOR,x 3113 : 8d0f02 sta ex_orai+1 ;set ORA # operand set_ax absORa,0 > load_flag 0 3116 : a900 > lda #0 ;allow test to change I-flag (no mask) > 3118 : 48 > pha ;use stack to load status 3119 : bd5602 > lda absORa,x ;precharge accu 311c : 28 > plp 311d : 200e02 jsr ex_orai ;execute ORA # in RAM tst_ax absrlo,absflo,0 3120 : 08 > php ;save flags 3121 : dd6202 > cmp absrlo,x ;test result > trap_ne 3124 : d0fe > bne * ;failed not equal (non zero) > 3126 : 68 > pla ;load status > eor_flag 0 3127 : 4930 > eor #0|fao ;invert expected flags + always on bits > 3129 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 312c : d0fe > bne * ;failed not equal (non zero) > 312e : ca dex 312f : 10e0 bpl tora 3131 : a203 ldx #3 3133 : b518 tora1 lda zpOR,x 3135 : 8d0f02 sta ex_orai+1 ;set ORA # operand set_ax absORa,$ff > load_flag $ff 3138 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 313a : 48 > pha ;use stack to load status 313b : bd5602 > lda absORa,x ;precharge accu 313e : 28 > plp 313f : 200e02 jsr ex_orai ;execute ORA # in RAM tst_ax absrlo,absflo,$ff-fnz 3142 : 08 > php ;save flags 3143 : dd6202 > cmp absrlo,x ;test result > trap_ne 3146 : d0fe > bne * ;failed not equal (non zero) > 3148 : 68 > pla ;load status > eor_flag $ff-fnz 3149 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 314b : dd6602 > cmp absflo,x ;test flags > trap_ne ; 314e : d0fe > bne * ;failed not equal (non zero) > 3150 : ca dex 3151 : 10e0 bpl tora1 3153 : a203 ldx #3 ;zp 3155 : b518 tora2 lda zpOR,x 3157 : 850c sta zpt set_ax absORa,0 > load_flag 0 3159 : a900 > lda #0 ;allow test to change I-flag (no mask) > 315b : 48 > pha ;use stack to load status 315c : bd5602 > lda absORa,x ;precharge accu 315f : 28 > plp 3160 : 050c ora zpt tst_ax absrlo,absflo,0 3162 : 08 > php ;save flags 3163 : dd6202 > cmp absrlo,x ;test result > trap_ne 3166 : d0fe > bne * ;failed not equal (non zero) > 3168 : 68 > pla ;load status > eor_flag 0 3169 : 4930 > eor #0|fao ;invert expected flags + always on bits > 316b : dd6602 > cmp absflo,x ;test flags > trap_ne ; 316e : d0fe > bne * ;failed not equal (non zero) > 3170 : ca dex 3171 : 10e2 bpl tora2 3173 : a203 ldx #3 3175 : b518 tora3 lda zpOR,x 3177 : 850c sta zpt set_ax absORa,$ff > load_flag $ff 3179 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 317b : 48 > pha ;use stack to load status 317c : bd5602 > lda absORa,x ;precharge accu 317f : 28 > plp 3180 : 050c ora zpt tst_ax absrlo,absflo,$ff-fnz 3182 : 08 > php ;save flags 3183 : dd6202 > cmp absrlo,x ;test result > trap_ne 3186 : d0fe > bne * ;failed not equal (non zero) > 3188 : 68 > pla ;load status > eor_flag $ff-fnz 3189 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 318b : dd6602 > cmp absflo,x ;test flags > trap_ne ; 318e : d0fe > bne * ;failed not equal (non zero) > 3190 : ca dex 3191 : 10e2 bpl tora3 3193 : a203 ldx #3 ;abs 3195 : b518 tora4 lda zpOR,x 3197 : 8d0302 sta abst set_ax absORa,0 > load_flag 0 319a : a900 > lda #0 ;allow test to change I-flag (no mask) > 319c : 48 > pha ;use stack to load status 319d : bd5602 > lda absORa,x ;precharge accu 31a0 : 28 > plp 31a1 : 0d0302 ora abst tst_ax absrlo,absflo,0 31a4 : 08 > php ;save flags 31a5 : dd6202 > cmp absrlo,x ;test result > trap_ne 31a8 : d0fe > bne * ;failed not equal (non zero) > 31aa : 68 > pla ;load status > eor_flag 0 31ab : 4930 > eor #0|fao ;invert expected flags + always on bits > 31ad : dd6602 > cmp absflo,x ;test flags > trap_ne ; 31b0 : d0fe > bne * ;failed not equal (non zero) > 31b2 : ca dex 31b3 : 10e0 bpl tora4 31b5 : a203 ldx #3 31b7 : b518 tora5 lda zpOR,x 31b9 : 8d0302 sta abst set_ax absORa,$ff > load_flag $ff 31bc : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 31be : 48 > pha ;use stack to load status 31bf : bd5602 > lda absORa,x ;precharge accu 31c2 : 28 > plp 31c3 : 0d0302 ora abst tst_ax absrlo,absflo,$ff-fnz 31c6 : 08 > php ;save flags 31c7 : dd6202 > cmp absrlo,x ;test result > trap_ne 31ca : d0fe > bne * ;failed not equal (non zero) > 31cc : 68 > pla ;load status > eor_flag $ff-fnz 31cd : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 31cf : dd6602 > cmp absflo,x ;test flags > trap_ne ; 31d2 : d0fe > bne * ;failed not equal (non zero) > 31d4 : ca dex 31d5 : 1002 bpl tora6 31d7 : a203 ldx #3 ;zp,x 31d9 : tora6 set_ax absORa,0 > load_flag 0 31d9 : a900 > lda #0 ;allow test to change I-flag (no mask) > 31db : 48 > pha ;use stack to load status 31dc : bd5602 > lda absORa,x ;precharge accu 31df : 28 > plp 31e0 : 1518 ora zpOR,x tst_ax absrlo,absflo,0 31e2 : 08 > php ;save flags 31e3 : dd6202 > cmp absrlo,x ;test result > trap_ne 31e6 : d0fe > bne * ;failed not equal (non zero) > 31e8 : 68 > pla ;load status > eor_flag 0 31e9 : 4930 > eor #0|fao ;invert expected flags + always on bits > 31eb : dd6602 > cmp absflo,x ;test flags > trap_ne ; 31ee : d0fe > bne * ;failed not equal (non zero) > 31f0 : ca dex 31f1 : 10e6 bpl tora6 31f3 : a203 ldx #3 31f5 : tora7 set_ax absORa,$ff > load_flag $ff 31f5 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 31f7 : 48 > pha ;use stack to load status 31f8 : bd5602 > lda absORa,x ;precharge accu 31fb : 28 > plp 31fc : 1518 ora zpOR,x tst_ax absrlo,absflo,$ff-fnz 31fe : 08 > php ;save flags 31ff : dd6202 > cmp absrlo,x ;test result > trap_ne 3202 : d0fe > bne * ;failed not equal (non zero) > 3204 : 68 > pla ;load status > eor_flag $ff-fnz 3205 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 3207 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 320a : d0fe > bne * ;failed not equal (non zero) > 320c : ca dex 320d : 10e6 bpl tora7 320f : a203 ldx #3 ;abs,x 3211 : tora8 set_ax absORa,0 > load_flag 0 3211 : a900 > lda #0 ;allow test to change I-flag (no mask) > 3213 : 48 > pha ;use stack to load status 3214 : bd5602 > lda absORa,x ;precharge accu 3217 : 28 > plp 3218 : 1d4a02 ora absOR,x tst_ax absrlo,absflo,0 321b : 08 > php ;save flags 321c : dd6202 > cmp absrlo,x ;test result > trap_ne 321f : d0fe > bne * ;failed not equal (non zero) > 3221 : 68 > pla ;load status > eor_flag 0 3222 : 4930 > eor #0|fao ;invert expected flags + always on bits > 3224 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 3227 : d0fe > bne * ;failed not equal (non zero) > 3229 : ca dex 322a : 10e5 bpl tora8 322c : a203 ldx #3 322e : tora9 set_ax absORa,$ff > load_flag $ff 322e : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 3230 : 48 > pha ;use stack to load status 3231 : bd5602 > lda absORa,x ;precharge accu 3234 : 28 > plp 3235 : 1d4a02 ora absOR,x tst_ax absrlo,absflo,$ff-fnz 3238 : 08 > php ;save flags 3239 : dd6202 > cmp absrlo,x ;test result > trap_ne 323c : d0fe > bne * ;failed not equal (non zero) > 323e : 68 > pla ;load status > eor_flag $ff-fnz 323f : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 3241 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 3244 : d0fe > bne * ;failed not equal (non zero) > 3246 : ca dex 3247 : 10e5 bpl tora9 3249 : a003 ldy #3 ;abs,y 324b : tora10 set_ay absORa,0 > load_flag 0 324b : a900 > lda #0 ;allow test to change I-flag (no mask) > 324d : 48 > pha ;use stack to load status 324e : b95602 > lda absORa,y ;precharge accu 3251 : 28 > plp 3252 : 194a02 ora absOR,y tst_ay absrlo,absflo,0 3255 : 08 > php ;save flags 3256 : d96202 > cmp absrlo,y ;test result > trap_ne ; 3259 : d0fe > bne * ;failed not equal (non zero) > 325b : 68 > pla ;load status > eor_flag 0 325c : 4930 > eor #0|fao ;invert expected flags + always on bits > 325e : d96602 > cmp absflo,y ;test flags > trap_ne 3261 : d0fe > bne * ;failed not equal (non zero) > 3263 : 88 dey 3264 : 10e5 bpl tora10 3266 : a003 ldy #3 3268 : tora11 set_ay absORa,$ff > load_flag $ff 3268 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 326a : 48 > pha ;use stack to load status 326b : b95602 > lda absORa,y ;precharge accu 326e : 28 > plp 326f : 194a02 ora absOR,y tst_ay absrlo,absflo,$ff-fnz 3272 : 08 > php ;save flags 3273 : d96202 > cmp absrlo,y ;test result > trap_ne ; 3276 : d0fe > bne * ;failed not equal (non zero) > 3278 : 68 > pla ;load status > eor_flag $ff-fnz 3279 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 327b : d96602 > cmp absflo,y ;test flags > trap_ne 327e : d0fe > bne * ;failed not equal (non zero) > 3280 : 88 dey 3281 : 10e5 bpl tora11 3283 : a206 ldx #6 ;(zp,x) 3285 : a003 ldy #3 3287 : tora12 set_ay absORa,0 > load_flag 0 3287 : a900 > lda #0 ;allow test to change I-flag (no mask) > 3289 : 48 > pha ;use stack to load status 328a : b95602 > lda absORa,y ;precharge accu 328d : 28 > plp 328e : 014a ora (indOR,x) tst_ay absrlo,absflo,0 3290 : 08 > php ;save flags 3291 : d96202 > cmp absrlo,y ;test result > trap_ne ; 3294 : d0fe > bne * ;failed not equal (non zero) > 3296 : 68 > pla ;load status > eor_flag 0 3297 : 4930 > eor #0|fao ;invert expected flags + always on bits > 3299 : d96602 > cmp absflo,y ;test flags > trap_ne 329c : d0fe > bne * ;failed not equal (non zero) > 329e : ca dex 329f : ca dex 32a0 : 88 dey 32a1 : 10e4 bpl tora12 32a3 : a206 ldx #6 32a5 : a003 ldy #3 32a7 : tora13 set_ay absORa,$ff > load_flag $ff 32a7 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 32a9 : 48 > pha ;use stack to load status 32aa : b95602 > lda absORa,y ;precharge accu 32ad : 28 > plp 32ae : 014a ora (indOR,x) tst_ay absrlo,absflo,$ff-fnz 32b0 : 08 > php ;save flags 32b1 : d96202 > cmp absrlo,y ;test result > trap_ne ; 32b4 : d0fe > bne * ;failed not equal (non zero) > 32b6 : 68 > pla ;load status > eor_flag $ff-fnz 32b7 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 32b9 : d96602 > cmp absflo,y ;test flags > trap_ne 32bc : d0fe > bne * ;failed not equal (non zero) > 32be : ca dex 32bf : ca dex 32c0 : 88 dey 32c1 : 10e4 bpl tora13 32c3 : a003 ldy #3 ;(zp),y 32c5 : tora14 set_ay absORa,0 > load_flag 0 32c5 : a900 > lda #0 ;allow test to change I-flag (no mask) > 32c7 : 48 > pha ;use stack to load status 32c8 : b95602 > lda absORa,y ;precharge accu 32cb : 28 > plp 32cc : 114a ora (indOR),y tst_ay absrlo,absflo,0 32ce : 08 > php ;save flags 32cf : d96202 > cmp absrlo,y ;test result > trap_ne ; 32d2 : d0fe > bne * ;failed not equal (non zero) > 32d4 : 68 > pla ;load status > eor_flag 0 32d5 : 4930 > eor #0|fao ;invert expected flags + always on bits > 32d7 : d96602 > cmp absflo,y ;test flags > trap_ne 32da : d0fe > bne * ;failed not equal (non zero) > 32dc : 88 dey 32dd : 10e6 bpl tora14 32df : a003 ldy #3 32e1 : tora15 set_ay absORa,$ff > load_flag $ff 32e1 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 32e3 : 48 > pha ;use stack to load status 32e4 : b95602 > lda absORa,y ;precharge accu 32e7 : 28 > plp 32e8 : 114a ora (indOR),y tst_ay absrlo,absflo,$ff-fnz 32ea : 08 > php ;save flags 32eb : d96202 > cmp absrlo,y ;test result > trap_ne ; 32ee : d0fe > bne * ;failed not equal (non zero) > 32f0 : 68 > pla ;load status > eor_flag $ff-fnz 32f1 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits > 32f3 : d96602 > cmp absflo,y ;test flags > trap_ne 32f6 : d0fe > bne * ;failed not equal (non zero) > 32f8 : 88 dey 32f9 : 10e6 bpl tora15 if I_flag = 3 32fb : 58 cli endif next_test 32fc : ad0002 > lda test_case ;previous test 32ff : c928 > cmp #test_num > trap_ne ;test is out of sequence 3301 : d0fe > bne * ;failed not equal (non zero) > 0029 = >test_num = test_num + 1 3303 : a929 > lda #test_num ;*** next tests' number 3305 : 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 3308 : d8 cld 3309 : a20e ldx #ad2 ;for indexed test 330b : a0ff ldy #$ff ;max range 330d : a900 lda #0 ;start with adding zeroes & no carry 330f : 850c sta adfc ;carry in - for diag 3311 : 850d sta ad1 ;operand 1 - accumulator 3313 : 850e sta ad2 ;operand 2 - memory or immediate 3315 : 8d0302 sta ada2 ;non zp 3318 : 850f sta adrl ;expected result bits 0-7 331a : 8510 sta adrh ;expected result bit 8 (carry out) 331c : a9ff lda #$ff ;complemented operand 2 for subtract 331e : 8512 sta sb2 3320 : 8d0402 sta sba2 ;non zp 3323 : a902 lda #2 ;expected Z-flag 3325 : 8511 sta adrf 3327 : 18 tadd clc ;test with carry clear 3328 : 20a235 jsr chkadd 332b : e60c inc adfc ;now with carry 332d : e60f inc adrl ;result +1 332f : 08 php ;save N & Z from low result 3330 : 08 php 3331 : 68 pla ;accu holds expected flags 3332 : 2982 and #$82 ;mask N & Z 3334 : 28 plp 3335 : d002 bne tadd1 3337 : e610 inc adrh ;result bit 8 - carry 3339 : 0510 tadd1 ora adrh ;merge C to expected flags 333b : 8511 sta adrf ;save expected flags except overflow 333d : 38 sec ;test with carry set 333e : 20a235 jsr chkadd 3341 : c60c dec adfc ;same for operand +1 but no carry 3343 : e60d inc ad1 3345 : d0e0 bne tadd ;iterate op1 3347 : a900 lda #0 ;preset result to op2 when op1 = 0 3349 : 8510 sta adrh 334b : ee0302 inc ada2 334e : e60e inc ad2 3350 : 08 php ;save NZ as operand 2 becomes the new result 3351 : 68 pla 3352 : 2982 and #$82 ;mask N00000Z0 3354 : 8511 sta adrf ;no need to check carry as we are adding to 0 3356 : c612 dec sb2 ;complement subtract operand 2 3358 : ce0402 dec sba2 335b : a50e lda ad2 335d : 850f sta adrl 335f : d0c6 bne tadd ;iterate op2 if disable_decimal < 1 next_test 3361 : ad0002 > lda test_case ;previous test 3364 : c929 > cmp #test_num > trap_ne ;test is out of sequence 3366 : d0fe > bne * ;failed not equal (non zero) > 002a = >test_num = test_num + 1 3368 : a92a > lda #test_num ;*** next tests' number 336a : 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 336d : f8 sed 336e : a20e ldx #ad2 ;for indexed test 3370 : a0ff ldy #$ff ;max range 3372 : a999 lda #$99 ;start with adding 99 to 99 with carry 3374 : 850d sta ad1 ;operand 1 - accumulator 3376 : 850e sta ad2 ;operand 2 - memory or immediate 3378 : 8d0302 sta ada2 ;non zp 337b : 850f sta adrl ;expected result bits 0-7 337d : a901 lda #1 ;set carry in & out 337f : 850c sta adfc ;carry in - for diag 3381 : 8510 sta adrh ;expected result bit 8 (carry out) 3383 : a900 lda #0 ;complemented operand 2 for subtract 3385 : 8512 sta sb2 3387 : 8d0402 sta sba2 ;non zp 338a : 38 tdad sec ;test with carry set 338b : 206f34 jsr chkdad 338e : c60c dec adfc ;now with carry clear 3390 : a50f lda adrl ;decimal adjust result 3392 : d008 bne tdad1 ;skip clear carry & preset result 99 (9A-1) 3394 : c610 dec adrh 3396 : a999 lda #$99 3398 : 850f sta adrl 339a : d012 bne tdad3 339c : 290f tdad1 and #$f ;lower nibble mask 339e : d00c bne tdad2 ;no decimal adjust needed 33a0 : c60f dec adrl ;decimal adjust (?0-6) 33a2 : c60f dec adrl 33a4 : c60f dec adrl 33a6 : c60f dec adrl 33a8 : c60f dec adrl 33aa : c60f dec adrl 33ac : c60f tdad2 dec adrl ;result -1 33ae : 18 tdad3 clc ;test with carry clear 33af : 206f34 jsr chkdad 33b2 : e60c inc adfc ;same for operand -1 but with carry 33b4 : a50d lda ad1 ;decimal adjust operand 1 33b6 : f015 beq tdad5 ;iterate operand 2 33b8 : 290f and #$f ;lower nibble mask 33ba : d00c bne tdad4 ;skip decimal adjust 33bc : c60d dec ad1 ;decimal adjust (?0-6) 33be : c60d dec ad1 33c0 : c60d dec ad1 33c2 : c60d dec ad1 33c4 : c60d dec ad1 33c6 : c60d dec ad1 33c8 : c60d tdad4 dec ad1 ;operand 1 -1 33ca : 4c8a33 jmp tdad ;iterate op1 33cd : a999 tdad5 lda #$99 ;precharge op1 max 33cf : 850d sta ad1 33d1 : a50e lda ad2 ;decimal adjust operand 2 33d3 : f030 beq tdad7 ;end of iteration 33d5 : 290f and #$f ;lower nibble mask 33d7 : d018 bne tdad6 ;skip decimal adjust 33d9 : c60e dec ad2 ;decimal adjust (?0-6) 33db : c60e dec ad2 33dd : c60e dec ad2 33df : c60e dec ad2 33e1 : c60e dec ad2 33e3 : c60e dec ad2 33e5 : e612 inc sb2 ;complemented decimal adjust for subtract (?9+6) 33e7 : e612 inc sb2 33e9 : e612 inc sb2 33eb : e612 inc sb2 33ed : e612 inc sb2 33ef : e612 inc sb2 33f1 : c60e tdad6 dec ad2 ;operand 2 -1 33f3 : e612 inc sb2 ;complemented operand for subtract 33f5 : a512 lda sb2 33f7 : 8d0402 sta sba2 ;copy as non zp operand 33fa : a50e lda ad2 33fc : 8d0302 sta ada2 ;copy as non zp operand 33ff : 850f sta adrl ;new result since op1+carry=00+carry +op2=op2 3401 : e610 inc adrh ;result carry 3403 : d085 bne tdad ;iterate op2 3405 : tdad7 next_test 3405 : ad0002 > lda test_case ;previous test 3408 : c92a > cmp #test_num > trap_ne ;test is out of sequence 340a : d0fe > bne * ;failed not equal (non zero) > 002b = >test_num = test_num + 1 340c : a92b > lda #test_num ;*** next tests' number 340e : 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 3411 : 18 clc 3412 : d8 cld 3413 : 08 php 3414 : a955 lda #$55 3416 : 6955 adc #$55 3418 : c9aa cmp #$aa trap_ne ;expected binary result after cld 341a : d0fe > bne * ;failed not equal (non zero) 341c : 18 clc 341d : f8 sed 341e : 08 php 341f : a955 lda #$55 3421 : 6955 adc #$55 3423 : c910 cmp #$10 trap_ne ;expected decimal result after sed 3425 : d0fe > bne * ;failed not equal (non zero) 3427 : d8 cld 3428 : 28 plp 3429 : a955 lda #$55 342b : 6955 adc #$55 342d : c910 cmp #$10 trap_ne ;expected decimal result after plp D=1 342f : d0fe > bne * ;failed not equal (non zero) 3431 : 28 plp 3432 : a955 lda #$55 3434 : 6955 adc #$55 3436 : c9aa cmp #$aa trap_ne ;expected binary result after plp D=0 3438 : d0fe > bne * ;failed not equal (non zero) 343a : 18 clc 343b : a934 lda #hi bin_rti_ret ;emulated interrupt for rti 343d : 48 pha 343e : a955 lda #lo bin_rti_ret 3440 : 48 pha 3441 : 08 php 3442 : f8 sed 3443 : a934 lda #hi dec_rti_ret ;emulated interrupt for rti 3445 : 48 pha 3446 : a94c lda #lo dec_rti_ret 3448 : 48 pha 3449 : 08 php 344a : d8 cld 344b : 40 rti 344c : dec_rti_ret 344c : a955 lda #$55 344e : 6955 adc #$55 3450 : c910 cmp #$10 trap_ne ;expected decimal result after rti D=1 3452 : d0fe > bne * ;failed not equal (non zero) 3454 : 40 rti 3455 : bin_rti_ret 3455 : a955 lda #$55 3457 : 6955 adc #$55 3459 : c9aa cmp #$aa trap_ne ;expected binary result after rti D=0 345b : d0fe > bne * ;failed not equal (non zero) endif 345d : ad0002 lda test_case 3460 : c92b cmp #test_num trap_ne ;previous test is out of sequence 3462 : d0fe > bne * ;failed not equal (non zero) 3464 : a9f0 lda #$f0 ;mark opcode testing complete 3466 : 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 3469 : 4c6934 > jmp * ;test passed, no errors ; ------------- ; S U C C E S S ************************************************ 346c : 4c0004 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 346f : chkdad ; decimal ADC / SBC zp 346f : 08 php ;save carry for subtract 3470 : a50d lda ad1 3472 : 650e adc ad2 ;perform add 3474 : 08 php 3475 : c50f cmp adrl ;check result trap_ne ;bad result 3477 : d0fe > bne * ;failed not equal (non zero) 3479 : 68 pla ;check flags 347a : 2901 and #1 ;mask carry 347c : c510 cmp adrh trap_ne ;bad carry 347e : d0fe > bne * ;failed not equal (non zero) 3480 : 28 plp 3481 : 08 php ;save carry for next add 3482 : a50d lda ad1 3484 : e512 sbc sb2 ;perform subtract 3486 : 08 php 3487 : c50f cmp adrl ;check result trap_ne ;bad result 3489 : d0fe > bne * ;failed not equal (non zero) 348b : 68 pla ;check flags 348c : 2901 and #1 ;mask carry 348e : c510 cmp adrh trap_ne ;bad flags 3490 : d0fe > bne * ;failed not equal (non zero) 3492 : 28 plp ; decimal ADC / SBC abs 3493 : 08 php ;save carry for subtract 3494 : a50d lda ad1 3496 : 6d0302 adc ada2 ;perform add 3499 : 08 php 349a : c50f cmp adrl ;check result trap_ne ;bad result 349c : d0fe > bne * ;failed not equal (non zero) 349e : 68 pla ;check flags 349f : 2901 and #1 ;mask carry 34a1 : c510 cmp adrh trap_ne ;bad carry 34a3 : d0fe > bne * ;failed not equal (non zero) 34a5 : 28 plp 34a6 : 08 php ;save carry for next add 34a7 : a50d lda ad1 34a9 : ed0402 sbc sba2 ;perform subtract 34ac : 08 php 34ad : c50f cmp adrl ;check result trap_ne ;bad result 34af : d0fe > bne * ;failed not equal (non zero) 34b1 : 68 pla ;check flags 34b2 : 2901 and #1 ;mask carry 34b4 : c510 cmp adrh trap_ne ;bad carry 34b6 : d0fe > bne * ;failed not equal (non zero) 34b8 : 28 plp ; decimal ADC / SBC # 34b9 : 08 php ;save carry for subtract 34ba : a50e lda ad2 34bc : 8d1202 sta ex_adci+1 ;set ADC # operand 34bf : a50d lda ad1 34c1 : 201102 jsr ex_adci ;execute ADC # in RAM 34c4 : 08 php 34c5 : c50f cmp adrl ;check result trap_ne ;bad result 34c7 : d0fe > bne * ;failed not equal (non zero) 34c9 : 68 pla ;check flags 34ca : 2901 and #1 ;mask carry 34cc : c510 cmp adrh trap_ne ;bad carry 34ce : d0fe > bne * ;failed not equal (non zero) 34d0 : 28 plp 34d1 : 08 php ;save carry for next add 34d2 : a512 lda sb2 34d4 : 8d1502 sta ex_sbci+1 ;set SBC # operand 34d7 : a50d lda ad1 34d9 : 201402 jsr ex_sbci ;execute SBC # in RAM 34dc : 08 php 34dd : c50f cmp adrl ;check result trap_ne ;bad result 34df : d0fe > bne * ;failed not equal (non zero) 34e1 : 68 pla ;check flags 34e2 : 2901 and #1 ;mask carry 34e4 : c510 cmp adrh trap_ne ;bad carry 34e6 : d0fe > bne * ;failed not equal (non zero) 34e8 : 28 plp ; decimal ADC / SBC zp,x 34e9 : 08 php ;save carry for subtract 34ea : a50d lda ad1 34ec : 7500 adc 0,x ;perform add 34ee : 08 php 34ef : c50f cmp adrl ;check result trap_ne ;bad result 34f1 : d0fe > bne * ;failed not equal (non zero) 34f3 : 68 pla ;check flags 34f4 : 2901 and #1 ;mask carry 34f6 : c510 cmp adrh trap_ne ;bad carry 34f8 : d0fe > bne * ;failed not equal (non zero) 34fa : 28 plp 34fb : 08 php ;save carry for next add 34fc : a50d lda ad1 34fe : f504 sbc sb2-ad2,x ;perform subtract 3500 : 08 php 3501 : c50f cmp adrl ;check result trap_ne ;bad result 3503 : d0fe > bne * ;failed not equal (non zero) 3505 : 68 pla ;check flags 3506 : 2901 and #1 ;mask carry 3508 : c510 cmp adrh trap_ne ;bad carry 350a : d0fe > bne * ;failed not equal (non zero) 350c : 28 plp ; decimal ADC / SBC abs,x 350d : 08 php ;save carry for subtract 350e : a50d lda ad1 3510 : 7df501 adc ada2-ad2,x ;perform add 3513 : 08 php 3514 : c50f cmp adrl ;check result trap_ne ;bad result 3516 : d0fe > bne * ;failed not equal (non zero) 3518 : 68 pla ;check flags 3519 : 2901 and #1 ;mask carry 351b : c510 cmp adrh trap_ne ;bad carry 351d : d0fe > bne * ;failed not equal (non zero) 351f : 28 plp 3520 : 08 php ;save carry for next add 3521 : a50d lda ad1 3523 : fdf601 sbc sba2-ad2,x ;perform subtract 3526 : 08 php 3527 : c50f cmp adrl ;check result trap_ne ;bad result 3529 : d0fe > bne * ;failed not equal (non zero) 352b : 68 pla ;check flags 352c : 2901 and #1 ;mask carry 352e : c510 cmp adrh trap_ne ;bad carry 3530 : d0fe > bne * ;failed not equal (non zero) 3532 : 28 plp ; decimal ADC / SBC abs,y 3533 : 08 php ;save carry for subtract 3534 : a50d lda ad1 3536 : 790401 adc ada2-$ff,y ;perform add 3539 : 08 php 353a : c50f cmp adrl ;check result trap_ne ;bad result 353c : d0fe > bne * ;failed not equal (non zero) 353e : 68 pla ;check flags 353f : 2901 and #1 ;mask carry 3541 : c510 cmp adrh trap_ne ;bad carry 3543 : d0fe > bne * ;failed not equal (non zero) 3545 : 28 plp 3546 : 08 php ;save carry for next add 3547 : a50d lda ad1 3549 : f90501 sbc sba2-$ff,y ;perform subtract 354c : 08 php 354d : c50f cmp adrl ;check result trap_ne ;bad result 354f : d0fe > bne * ;failed not equal (non zero) 3551 : 68 pla ;check flags 3552 : 2901 and #1 ;mask carry 3554 : c510 cmp adrh trap_ne ;bad carry 3556 : d0fe > bne * ;failed not equal (non zero) 3558 : 28 plp ; decimal ADC / SBC (zp,x) 3559 : 08 php ;save carry for subtract 355a : a50d lda ad1 355c : 6144 adc (lo adi2-ad2,x) ;perform add 355e : 08 php 355f : c50f cmp adrl ;check result trap_ne ;bad result 3561 : d0fe > bne * ;failed not equal (non zero) 3563 : 68 pla ;check flags 3564 : 2901 and #1 ;mask carry 3566 : c510 cmp adrh trap_ne ;bad carry 3568 : d0fe > bne * ;failed not equal (non zero) 356a : 28 plp 356b : 08 php ;save carry for next add 356c : a50d lda ad1 356e : e146 sbc (lo sbi2-ad2,x) ;perform subtract 3570 : 08 php 3571 : c50f cmp adrl ;check result trap_ne ;bad result 3573 : d0fe > bne * ;failed not equal (non zero) 3575 : 68 pla ;check flags 3576 : 2901 and #1 ;mask carry 3578 : c510 cmp adrh trap_ne ;bad carry 357a : d0fe > bne * ;failed not equal (non zero) 357c : 28 plp ; decimal ADC / SBC (abs),y 357d : 08 php ;save carry for subtract 357e : a50d lda ad1 3580 : 7156 adc (adiy2),y ;perform add 3582 : 08 php 3583 : c50f cmp adrl ;check result trap_ne ;bad result 3585 : d0fe > bne * ;failed not equal (non zero) 3587 : 68 pla ;check flags 3588 : 2901 and #1 ;mask carry 358a : c510 cmp adrh trap_ne ;bad carry 358c : d0fe > bne * ;failed not equal (non zero) 358e : 28 plp 358f : 08 php ;save carry for next add 3590 : a50d lda ad1 3592 : f158 sbc (sbiy2),y ;perform subtract 3594 : 08 php 3595 : c50f cmp adrl ;check result trap_ne ;bad result 3597 : d0fe > bne * ;failed not equal (non zero) 3599 : 68 pla ;check flags 359a : 2901 and #1 ;mask carry 359c : c510 cmp adrh trap_ne ;bad carry 359e : d0fe > bne * ;failed not equal (non zero) 35a0 : 28 plp 35a1 : 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 35a2 : a511 chkadd lda adrf ;add V-flag if overflow 35a4 : 2983 and #$83 ;keep N-----ZC / clear V 35a6 : 48 pha 35a7 : a50d lda ad1 ;test sign unequal between operands 35a9 : 450e eor ad2 35ab : 300a bmi ckad1 ;no overflow possible - operands have different sign 35ad : a50d lda ad1 ;test sign equal between operands and result 35af : 450f eor adrl 35b1 : 1004 bpl ckad1 ;no overflow occured - operand and result have same sign 35b3 : 68 pla 35b4 : 0940 ora #$40 ;set V 35b6 : 48 pha 35b7 : 68 ckad1 pla 35b8 : 8511 sta adrf ;save expected flags ; binary ADC / SBC zp 35ba : 08 php ;save carry for subtract 35bb : a50d lda ad1 35bd : 650e adc ad2 ;perform add 35bf : 08 php 35c0 : c50f cmp adrl ;check result trap_ne ;bad result 35c2 : d0fe > bne * ;failed not equal (non zero) 35c4 : 68 pla ;check flags 35c5 : 29c3 and #$c3 ;mask NV----ZC 35c7 : c511 cmp adrf trap_ne ;bad flags 35c9 : d0fe > bne * ;failed not equal (non zero) 35cb : 28 plp 35cc : 08 php ;save carry for next add 35cd : a50d lda ad1 35cf : e512 sbc sb2 ;perform subtract 35d1 : 08 php 35d2 : c50f cmp adrl ;check result trap_ne ;bad result 35d4 : d0fe > bne * ;failed not equal (non zero) 35d6 : 68 pla ;check flags 35d7 : 29c3 and #$c3 ;mask NV----ZC 35d9 : c511 cmp adrf trap_ne ;bad flags 35db : d0fe > bne * ;failed not equal (non zero) 35dd : 28 plp ; binary ADC / SBC abs 35de : 08 php ;save carry for subtract 35df : a50d lda ad1 35e1 : 6d0302 adc ada2 ;perform add 35e4 : 08 php 35e5 : c50f cmp adrl ;check result trap_ne ;bad result 35e7 : d0fe > bne * ;failed not equal (non zero) 35e9 : 68 pla ;check flags 35ea : 29c3 and #$c3 ;mask NV----ZC 35ec : c511 cmp adrf trap_ne ;bad flags 35ee : d0fe > bne * ;failed not equal (non zero) 35f0 : 28 plp 35f1 : 08 php ;save carry for next add 35f2 : a50d lda ad1 35f4 : ed0402 sbc sba2 ;perform subtract 35f7 : 08 php 35f8 : c50f cmp adrl ;check result trap_ne ;bad result 35fa : d0fe > bne * ;failed not equal (non zero) 35fc : 68 pla ;check flags 35fd : 29c3 and #$c3 ;mask NV----ZC 35ff : c511 cmp adrf trap_ne ;bad flags 3601 : d0fe > bne * ;failed not equal (non zero) 3603 : 28 plp ; binary ADC / SBC # 3604 : 08 php ;save carry for subtract 3605 : a50e lda ad2 3607 : 8d1202 sta ex_adci+1 ;set ADC # operand 360a : a50d lda ad1 360c : 201102 jsr ex_adci ;execute ADC # in RAM 360f : 08 php 3610 : c50f cmp adrl ;check result trap_ne ;bad result 3612 : d0fe > bne * ;failed not equal (non zero) 3614 : 68 pla ;check flags 3615 : 29c3 and #$c3 ;mask NV----ZC 3617 : c511 cmp adrf trap_ne ;bad flags 3619 : d0fe > bne * ;failed not equal (non zero) 361b : 28 plp 361c : 08 php ;save carry for next add 361d : a512 lda sb2 361f : 8d1502 sta ex_sbci+1 ;set SBC # operand 3622 : a50d lda ad1 3624 : 201402 jsr ex_sbci ;execute SBC # in RAM 3627 : 08 php 3628 : c50f cmp adrl ;check result trap_ne ;bad result 362a : d0fe > bne * ;failed not equal (non zero) 362c : 68 pla ;check flags 362d : 29c3 and #$c3 ;mask NV----ZC 362f : c511 cmp adrf trap_ne ;bad flags 3631 : d0fe > bne * ;failed not equal (non zero) 3633 : 28 plp ; binary ADC / SBC zp,x 3634 : 08 php ;save carry for subtract 3635 : a50d lda ad1 3637 : 7500 adc 0,x ;perform add 3639 : 08 php 363a : c50f cmp adrl ;check result trap_ne ;bad result 363c : d0fe > bne * ;failed not equal (non zero) 363e : 68 pla ;check flags 363f : 29c3 and #$c3 ;mask NV----ZC 3641 : c511 cmp adrf trap_ne ;bad flags 3643 : d0fe > bne * ;failed not equal (non zero) 3645 : 28 plp 3646 : 08 php ;save carry for next add 3647 : a50d lda ad1 3649 : f504 sbc sb2-ad2,x ;perform subtract 364b : 08 php 364c : c50f cmp adrl ;check result trap_ne ;bad result 364e : d0fe > bne * ;failed not equal (non zero) 3650 : 68 pla ;check flags 3651 : 29c3 and #$c3 ;mask NV----ZC 3653 : c511 cmp adrf trap_ne ;bad flags 3655 : d0fe > bne * ;failed not equal (non zero) 3657 : 28 plp ; binary ADC / SBC abs,x 3658 : 08 php ;save carry for subtract 3659 : a50d lda ad1 365b : 7df501 adc ada2-ad2,x ;perform add 365e : 08 php 365f : c50f cmp adrl ;check result trap_ne ;bad result 3661 : d0fe > bne * ;failed not equal (non zero) 3663 : 68 pla ;check flags 3664 : 29c3 and #$c3 ;mask NV----ZC 3666 : c511 cmp adrf trap_ne ;bad flags 3668 : d0fe > bne * ;failed not equal (non zero) 366a : 28 plp 366b : 08 php ;save carry for next add 366c : a50d lda ad1 366e : fdf601 sbc sba2-ad2,x ;perform subtract 3671 : 08 php 3672 : c50f cmp adrl ;check result trap_ne ;bad result 3674 : d0fe > bne * ;failed not equal (non zero) 3676 : 68 pla ;check flags 3677 : 29c3 and #$c3 ;mask NV----ZC 3679 : c511 cmp adrf trap_ne ;bad flags 367b : d0fe > bne * ;failed not equal (non zero) 367d : 28 plp ; binary ADC / SBC abs,y 367e : 08 php ;save carry for subtract 367f : a50d lda ad1 3681 : 790401 adc ada2-$ff,y ;perform add 3684 : 08 php 3685 : c50f cmp adrl ;check result trap_ne ;bad result 3687 : d0fe > bne * ;failed not equal (non zero) 3689 : 68 pla ;check flags 368a : 29c3 and #$c3 ;mask NV----ZC 368c : c511 cmp adrf trap_ne ;bad flags 368e : d0fe > bne * ;failed not equal (non zero) 3690 : 28 plp 3691 : 08 php ;save carry for next add 3692 : a50d lda ad1 3694 : f90501 sbc sba2-$ff,y ;perform subtract 3697 : 08 php 3698 : c50f cmp adrl ;check result trap_ne ;bad result 369a : d0fe > bne * ;failed not equal (non zero) 369c : 68 pla ;check flags 369d : 29c3 and #$c3 ;mask NV----ZC 369f : c511 cmp adrf trap_ne ;bad flags 36a1 : d0fe > bne * ;failed not equal (non zero) 36a3 : 28 plp ; binary ADC / SBC (zp,x) 36a4 : 08 php ;save carry for subtract 36a5 : a50d lda ad1 36a7 : 6144 adc (lo adi2-ad2,x) ;perform add 36a9 : 08 php 36aa : c50f cmp adrl ;check result trap_ne ;bad result 36ac : d0fe > bne * ;failed not equal (non zero) 36ae : 68 pla ;check flags 36af : 29c3 and #$c3 ;mask NV----ZC 36b1 : c511 cmp adrf trap_ne ;bad flags 36b3 : d0fe > bne * ;failed not equal (non zero) 36b5 : 28 plp 36b6 : 08 php ;save carry for next add 36b7 : a50d lda ad1 36b9 : e146 sbc (lo sbi2-ad2,x) ;perform subtract 36bb : 08 php 36bc : c50f cmp adrl ;check result trap_ne ;bad result 36be : d0fe > bne * ;failed not equal (non zero) 36c0 : 68 pla ;check flags 36c1 : 29c3 and #$c3 ;mask NV----ZC 36c3 : c511 cmp adrf trap_ne ;bad flags 36c5 : d0fe > bne * ;failed not equal (non zero) 36c7 : 28 plp ; binary ADC / SBC (abs),y 36c8 : 08 php ;save carry for subtract 36c9 : a50d lda ad1 36cb : 7156 adc (adiy2),y ;perform add 36cd : 08 php 36ce : c50f cmp adrl ;check result trap_ne ;bad result 36d0 : d0fe > bne * ;failed not equal (non zero) 36d2 : 68 pla ;check flags 36d3 : 29c3 and #$c3 ;mask NV----ZC 36d5 : c511 cmp adrf trap_ne ;bad flags 36d7 : d0fe > bne * ;failed not equal (non zero) 36d9 : 28 plp 36da : 08 php ;save carry for next add 36db : a50d lda ad1 36dd : f158 sbc (sbiy2),y ;perform subtract 36df : 08 php 36e0 : c50f cmp adrl ;check result trap_ne ;bad result 36e2 : d0fe > bne * ;failed not equal (non zero) 36e4 : 68 pla ;check flags 36e5 : 29c3 and #$c3 ;mask NV----ZC 36e7 : c511 cmp adrf trap_ne ;bad flags 36e9 : d0fe > bne * ;failed not equal (non zero) 36eb : 28 plp 36ec : 60 rts ; target for the jump absolute test 36ed : 88 dey 36ee : 88 dey 36ef : test_far 36ef : 08 php ;either SP or Y count will fail, if we do not hit 36f0 : 88 dey 36f1 : 88 dey 36f2 : 88 dey 36f3 : 28 plp trap_cs ;flags loaded? 36f4 : b0fe > bcs * ;failed carry set trap_vs 36f6 : 70fe > bvs * ;failed overflow set trap_mi 36f8 : 30fe > bmi * ;failed minus (bit 7 set) trap_eq 36fa : f0fe > beq * ;failed equal (zero) 36fc : c946 cmp #'F' ;registers loaded? trap_ne 36fe : d0fe > bne * ;failed not equal (non zero) 3700 : e041 cpx #'A' trap_ne 3702 : d0fe > bne * ;failed not equal (non zero) 3704 : c04f cpy #('R'-3) trap_ne 3706 : d0fe > bne * ;failed not equal (non zero) 3708 : 48 pha ;save a,x 3709 : 8a txa 370a : 48 pha 370b : ba tsx 370c : e0fd cpx #$fd ;check SP trap_ne 370e : d0fe > bne * ;failed not equal (non zero) 3710 : 68 pla ;restore x 3711 : aa tax set_stat $ff > load_flag $ff 3712 : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 3714 : 48 > pha ;use stack to load status 3715 : 28 > plp 3716 : 68 pla ;restore a 3717 : e8 inx ;return registers with modifications 3718 : 49aa eor #$aa ;N=1, V=1, Z=0, C=1 371a : 4c0f09 jmp far_ret ; target for the jump indirect test 371d : 00 align 371e : 2737 ptr_tst_ind dw test_ind 3720 : 6409 ptr_ind_ret dw ind_ret trap ;runover protection 3722 : 4c2237 > jmp * ;failed anyway 3725 : 88 dey 3726 : 88 dey 3727 : test_ind 3727 : 08 php ;either SP or Y count will fail, if we do not hit 3728 : 88 dey 3729 : 88 dey 372a : 88 dey 372b : 28 plp trap_cs ;flags loaded? 372c : b0fe > bcs * ;failed carry set trap_vs 372e : 70fe > bvs * ;failed overflow set trap_mi 3730 : 30fe > bmi * ;failed minus (bit 7 set) trap_eq 3732 : f0fe > beq * ;failed equal (zero) 3734 : c949 cmp #'I' ;registers loaded? trap_ne 3736 : d0fe > bne * ;failed not equal (non zero) 3738 : e04e cpx #'N' trap_ne 373a : d0fe > bne * ;failed not equal (non zero) 373c : c041 cpy #('D'-3) trap_ne 373e : d0fe > bne * ;failed not equal (non zero) 3740 : 48 pha ;save a,x 3741 : 8a txa 3742 : 48 pha 3743 : ba tsx 3744 : e0fd cpx #$fd ;check SP trap_ne 3746 : d0fe > bne * ;failed not equal (non zero) 3748 : 68 pla ;restore x 3749 : aa tax set_stat $ff > load_flag $ff 374a : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 374c : 48 > pha ;use stack to load status 374d : 28 > plp 374e : 68 pla ;restore a 374f : e8 inx ;return registers with modifications 3750 : 49aa eor #$aa ;N=1, V=1, Z=0, C=1 3752 : 6c2037 jmp (ptr_ind_ret) trap ;runover protection 3755 : 4c5537 > jmp * ;failed anyway 3758 : 4c0004 jmp start ;catastrophic error - cannot continue ; target for the jump subroutine test 375b : 88 dey 375c : 88 dey 375d : test_jsr 375d : 08 php ;either SP or Y count will fail, if we do not hit 375e : 88 dey 375f : 88 dey 3760 : 88 dey 3761 : 28 plp trap_cs ;flags loaded? 3762 : b0fe > bcs * ;failed carry set trap_vs 3764 : 70fe > bvs * ;failed overflow set trap_mi 3766 : 30fe > bmi * ;failed minus (bit 7 set) trap_eq 3768 : f0fe > beq * ;failed equal (zero) 376a : c94a cmp #'J' ;registers loaded? trap_ne 376c : d0fe > bne * ;failed not equal (non zero) 376e : e053 cpx #'S' trap_ne 3770 : d0fe > bne * ;failed not equal (non zero) 3772 : c04f cpy #('R'-3) trap_ne 3774 : d0fe > bne * ;failed not equal (non zero) 3776 : 48 pha ;save a,x 3777 : 8a txa 3778 : 48 pha 3779 : ba tsx ;sp -4? (return addr,a,x) 377a : e0fb cpx #$fb trap_ne 377c : d0fe > bne * ;failed not equal (non zero) 377e : adff01 lda $1ff ;propper return on stack 3781 : c909 cmp #hi(jsr_ret) trap_ne 3783 : d0fe > bne * ;failed not equal (non zero) 3785 : adfe01 lda $1fe 3788 : c99a cmp #lo(jsr_ret) trap_ne 378a : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 378c : a9ff > lda #$ff ;allow test to change I-flag (no mask) > 378e : 48 > pha ;use stack to load status 378f : 28 > plp 3790 : 68 pla ;pull x,a 3791 : aa tax 3792 : 68 pla 3793 : e8 inx ;return registers with modifications 3794 : 49aa eor #$aa ;N=1, V=1, Z=0, C=1 3796 : 60 rts trap ;runover protection 3797 : 4c9737 > jmp * ;failed anyway 379a : 4c0004 jmp start ;catastrophic error - cannot continue ;trap in case of unexpected IRQ, NMI, BRK, RESET - BRK test target 379d : nmi_trap trap ;check stack for conditions at NMI 379d : 4c9d37 > jmp * ;failed anyway 37a0 : 4c0004 jmp start ;catastrophic error - cannot continue 37a3 : res_trap trap ;unexpected RESET 37a3 : 4ca337 > jmp * ;failed anyway 37a6 : 4c0004 jmp start ;catastrophic error - cannot continue 37a9 : 88 dey 37aa : 88 dey 37ab : irq_trap ;BRK test or unextpected BRK or IRQ 37ab : 08 php ;either SP or Y count will fail, if we do not hit 37ac : 88 dey 37ad : 88 dey 37ae : 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) 37af : c9bd cmp #$ff-'B' ;BRK pass 2 registers loaded? 37b1 : f042 beq break2 37b3 : c942 cmp #'B' ;BRK pass 1 registers loaded? trap_ne 37b5 : d0fe > bne * ;failed not equal (non zero) 37b7 : e052 cpx #'R' trap_ne 37b9 : d0fe > bne * ;failed not equal (non zero) 37bb : c048 cpy #'K'-3 trap_ne 37bd : d0fe > bne * ;failed not equal (non zero) 37bf : 850a sta irq_a ;save registers during break test 37c1 : 860b stx irq_x 37c3 : ba tsx ;test break on stack 37c4 : bd0201 lda $102,x cmp_flag 0 ;break test should have B=1 & unused=1 on stack 37c7 : c930 > cmp #(0 |fao)&m8 ;expected flags + always on bits trap_ne ; - no break flag on stack 37c9 : d0fe > bne * ;failed not equal (non zero) 37cb : 68 pla cmp_flag intdis ;should have added interrupt disable 37cc : c934 > cmp #(intdis |fao)&m8 ;expected flags + always on bits trap_ne 37ce : d0fe > bne * ;failed not equal (non zero) 37d0 : ba tsx 37d1 : e0fc cpx #$fc ;sp -3? (return addr, flags) trap_ne 37d3 : d0fe > bne * ;failed not equal (non zero) 37d5 : adff01 lda $1ff ;propper return on stack 37d8 : c909 cmp #hi(brk_ret0) trap_ne 37da : d0fe > bne * ;failed not equal (non zero) 37dc : adfe01 lda $1fe 37df : c9d1 cmp #lo(brk_ret0) trap_ne 37e1 : d0fe > bne * ;failed not equal (non zero) load_flag $ff 37e3 : a9ff > lda #$ff ;allow test to change I-flag (no mask) 37e5 : 48 pha 37e6 : a60b ldx irq_x 37e8 : e8 inx ;return registers with modifications 37e9 : a50a lda irq_a 37eb : 49aa eor #$aa 37ed : 28 plp ;N=1, V=1, Z=1, C=1 but original flags should be restored 37ee : 40 rti trap ;runover protection 37ef : 4cef37 > jmp * ;failed anyway 37f2 : 4c0004 jmp start ;catastrophic error - cannot continue 37f5 : break2 ;BRK pass 2 37f5 : e0ad cpx #$ff-'R' trap_ne 37f7 : d0fe > bne * ;failed not equal (non zero) 37f9 : c0b1 cpy #$ff-'K'-3 trap_ne 37fb : d0fe > bne * ;failed not equal (non zero) 37fd : 850a sta irq_a ;save registers during break test 37ff : 860b stx irq_x 3801 : ba tsx ;test break on stack 3802 : bd0201 lda $102,x cmp_flag $ff ;break test should have B=1 3805 : c9ff > cmp #($ff |fao)&m8 ;expected flags + always on bits trap_ne ; - no break flag on stack 3807 : d0fe > bne * ;failed not equal (non zero) 3809 : 68 pla 380a : 0908 ora #decmode ;ignore decmode cleared if 65c02 cmp_flag $ff ;actual passed flags 380c : c9ff > cmp #($ff |fao)&m8 ;expected flags + always on bits trap_ne 380e : d0fe > bne * ;failed not equal (non zero) 3810 : ba tsx 3811 : e0fc cpx #$fc ;sp -3? (return addr, flags) trap_ne 3813 : d0fe > bne * ;failed not equal (non zero) 3815 : adff01 lda $1ff ;propper return on stack 3818 : c909 cmp #hi(brk_ret1) trap_ne 381a : d0fe > bne * ;failed not equal (non zero) 381c : adfe01 lda $1fe 381f : c9f7 cmp #lo(brk_ret1) trap_ne 3821 : d0fe > bne * ;failed not equal (non zero) load_flag intdis 3823 : a904 > lda #intdis ;allow test to change I-flag (no mask) 3825 : 48 pha 3826 : a60b ldx irq_x 3828 : e8 inx ;return registers with modifications 3829 : a50a lda irq_a 382b : 49aa eor #$aa 382d : 28 plp ;N=0, V=0, Z=0, C=0 but original flags should be restored 382e : 40 rti trap ;runover protection 382f : 4c2f38 > jmp * ;failed anyway 3832 : 4c0004 jmp start ;catastrophic error - cannot continue if report = 1 include "report.i65" endif ;copy of data to initialize BSS segment if load_data_direct != 1 zp_init zp1_ db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR zp7f_ db $7f ;test pattern for compare ;logical zeropage operands zpOR_ db 0,$1f,$71,$80 ;test pattern for OR zpAN_ db $0f,$ff,$7f,$80 ;test pattern for AND zpEO_ db $ff,$0f,$8f,$8f ;test pattern for EOR ;indirect addressing pointers ind1_ dw abs1 ;indirect pointer to pattern in absolute memory dw abs1+1 dw abs1+2 dw abs1+3 dw abs7f inw1_ dw abs1-$f8 ;indirect pointer for wrap-test pattern indt_ dw abst ;indirect pointer to store area in absolute memory dw abst+1 dw abst+2 dw abst+3 inwt_ dw abst-$f8 ;indirect pointer for wrap-test store indAN_ dw absAN ;indirect pointer to AND pattern in absolute memory dw absAN+1 dw absAN+2 dw absAN+3 indEO_ dw absEO ;indirect pointer to EOR pattern in absolute memory dw absEO+1 dw absEO+2 dw absEO+3 indOR_ dw absOR ;indirect pointer to OR pattern in absolute memory dw absOR+1 dw absOR+2 dw absOR+3 ;add/subtract indirect pointers adi2_ dw ada2 ;indirect pointer to operand 2 in absolute memory sbi2_ dw sba2 ;indirect pointer to complemented operand 2 (SBC) adiy2_ dw ada2-$ff ;with offset for indirect indexed sbiy2_ dw sba2-$ff zp_end if (zp_end - zp_init) != (zp_bss_end - zp_bss) ;force assembler error if size is different ERROR ERROR ERROR ;mismatch between bss and zeropage data endif data_init ex_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 : 9d37 dw nmi_trap fffc : a337 dw res_trap fffe : ab37 dw irq_trap endif fffa = end start No errors in pass 2.